_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q11100 | Unlisten | train | func (l *Listener) Unlisten(channel string) error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
// Similarly to LISTEN, this is not an error in Postgres, but it seems
// useful to distinguish from the normal conditions.
_, exists := l.channels[channel]
if !exists {
return ErrChannelNotOpen
}
if l.cn != nil {
// Similarly to Listen (see comment in that function), the caller
// should only be bothered with an error if it came from the backend as
// a response to our query.
gotResponse, err := l.cn.Unlisten(channel)
if gotResponse && err != nil {
return err
}
}
// Don't bother waiting for resync if there's no connection.
delete(l.channels, channel)
return nil
} | go | {
"resource": ""
} |
q11101 | UnlistenAll | train | func (l *Listener) UnlistenAll() error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
if l.cn != nil {
// Similarly to Listen (see comment in that function), the caller
// should only be bothered with an error if it came from the backend as
// a response to our query.
gotResponse, err := l.cn.UnlistenAll()
if gotResponse && err != nil {
return err
}
}
// Don't bother waiting for resync if there's no connection.
l.channels = make(map[string]struct{})
return nil
} | go | {
"resource": ""
} |
q11102 | Ping | train | func (l *Listener) Ping() error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
if l.cn == nil {
return errors.New("no connection")
}
return l.cn.Ping()
} | go | {
"resource": ""
} |
q11103 | resync | train | func (l *Listener) resync(cn *ListenerConn, notificationChan <-chan *Notification) error {
doneChan := make(chan error)
go func() {
for channel := range l.channels {
// If we got a response, return that error to our caller as it's
// going to be more descriptive than cn.Err().
gotResponse, err := cn.Listen(channel)
if gotResponse && err != nil {
doneChan <- err
return
}
// If we couldn't reach the server, wait for notificationChan to
// close and then return the error message from the connection, as
// per ListenerConn's interface.
if err != nil {
for _ = range notificationChan {
}
doneChan <- cn.Err()
return
}
}
doneChan <- nil
}()
// Ignore notifications while synchronization is going on to avoid
// deadlocks. We have to send a nil notification over Notify anyway as
// we can't possibly know which notifications (if any) were lost while
// the connection was down, so there's no reason to try and process
// these messages at all.
for {
select {
case _, ok := <-notificationChan:
if !ok {
notificationChan = nil
}
case err := <-doneChan:
return err
}
}
} | go | {
"resource": ""
} |
q11104 | closed | train | func (l *Listener) closed() bool {
l.lock.Lock()
defer l.lock.Unlock()
return l.isClosed
} | go | {
"resource": ""
} |
q11105 | Close | train | func (l *Listener) Close() error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
if l.cn != nil {
l.cn.Close()
}
l.isClosed = true
return nil
} | go | {
"resource": ""
} |
q11106 | appendEncodedText | train | func appendEncodedText(parameterStatus *parameterStatus, buf []byte, x interface{}) []byte {
switch v := x.(type) {
case int64:
return strconv.AppendInt(buf, v, 10)
case float64:
return strconv.AppendFloat(buf, v, 'f', -1, 64)
case []byte:
encodedBytea := encodeBytea(parameterStatus.serverVersion, v)
return appendEscapedText(buf, string(encodedBytea))
case string:
return appendEscapedText(buf, v)
case bool:
return strconv.AppendBool(buf, v)
case time.Time:
return append(buf, formatTs(v)...)
case nil:
return append(buf, "\\N"...)
default:
errorf("encode: unknown type for %T", v)
}
panic("not reached")
} | go | {
"resource": ""
} |
q11107 | getLocation | train | func (c *locationCache) getLocation(offset int) *time.Location {
c.lock.Lock()
defer c.lock.Unlock()
location, ok := c.cache[offset]
if !ok {
location = time.FixedZone("", offset)
c.cache[offset] = location
}
return location
} | go | {
"resource": ""
} |
q11108 | formatTs | train | func formatTs(t time.Time) []byte {
if infinityTsEnabled {
// t <= -infinity : ! (t > -infinity)
if !t.After(infinityTsNegative) {
return []byte("-infinity")
}
// t >= infinity : ! (!t < infinity)
if !t.Before(infinityTsPositive) {
return []byte("infinity")
}
}
return FormatTimestamp(t)
} | go | {
"resource": ""
} |
q11109 | FormatTimestamp | train | func FormatTimestamp(t time.Time) []byte {
// Need to send dates before 0001 A.D. with " BC" suffix, instead of the
// minus sign preferred by Go.
// Beware, "0000" in ISO is "1 BC", "-0001" is "2 BC" and so on
bc := false
if t.Year() <= 0 {
// flip year sign, and add 1, e.g: "0" will be "1", and "-10" will be "11"
t = t.AddDate((-t.Year())*2+1, 0, 0)
bc = true
}
b := []byte(t.Format("2006-01-02 15:04:05.999999999Z07:00"))
_, offset := t.Zone()
offset = offset % 60
if offset != 0 {
// RFC3339Nano already printed the minus sign
if offset < 0 {
offset = -offset
}
b = append(b, ':')
if offset < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(offset), 10)
}
if bc {
b = append(b, " BC"...)
}
return b
} | go | {
"resource": ""
} |
q11110 | parseBytea | train | func parseBytea(s []byte) (result []byte, err error) {
if len(s) >= 2 && bytes.Equal(s[:2], []byte("\\x")) {
// bytea_output = hex
s = s[2:] // trim off leading "\\x"
result = make([]byte, hex.DecodedLen(len(s)))
_, err := hex.Decode(result, s)
if err != nil {
return nil, err
}
} else {
// bytea_output = escape
for len(s) > 0 {
if s[0] == '\\' {
// escaped '\\'
if len(s) >= 2 && s[1] == '\\' {
result = append(result, '\\')
s = s[2:]
continue
}
// '\\' followed by an octal number
if len(s) < 4 {
return nil, fmt.Errorf("invalid bytea sequence %v", s)
}
r, err := strconv.ParseInt(string(s[1:4]), 8, 9)
if err != nil {
return nil, fmt.Errorf("could not parse bytea value: %s", err.Error())
}
result = append(result, byte(r))
s = s[4:]
} else {
// We hit an unescaped, raw byte. Try to read in as many as
// possible in one go.
i := bytes.IndexByte(s, '\\')
if i == -1 {
result = append(result, s...)
break
}
result = append(result, s[:i]...)
s = s[i:]
}
}
}
return result, nil
} | go | {
"resource": ""
} |
q11111 | NewSimpleBindRequest | train | func NewSimpleBindRequest(username string, password string, controls []Control) *SimpleBindRequest {
return &SimpleBindRequest{
Username: username,
Password: password,
Controls: controls,
}
} | go | {
"resource": ""
} |
q11112 | SimpleBind | train | func (l *Conn) SimpleBind(simpleBindRequest *SimpleBindRequest) (*SimpleBindResult, error) {
packet := ber.Encode(ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "LDAP Request")
packet.AppendChild(ber.NewInteger(ber.ClassUniversal, ber.TypePrimitive, ber.TagInteger, l.nextMessageID(), "MessageID"))
encodedBindRequest := simpleBindRequest.encode()
packet.AppendChild(encodedBindRequest)
if l.Debug {
ber.PrintPacket(packet)
}
msgCtx, err := l.sendMessage(packet)
if err != nil {
return nil, err
}
defer l.finishMessage(msgCtx)
packetResponse, ok := <-msgCtx.responses
if !ok {
return nil, NewError(ErrorNetwork, errors.New("ldap: response channel closed"))
}
packet, err = packetResponse.ReadPacket()
l.Debug.Printf("%d: got response %p", msgCtx.id, packet)
if err != nil {
return nil, err
}
if l.Debug {
if err := addLDAPDescriptions(packet); err != nil {
return nil, err
}
ber.PrintPacket(packet)
}
result := &SimpleBindResult{
Controls: make([]Control, 0),
}
if len(packet.Children) == 3 {
for _, child := range packet.Children[2].Children {
result.Controls = append(result.Controls, DecodeControl(child))
}
}
resultCode, resultDescription := getLDAPResultCode(packet)
if resultCode != 0 {
return result, NewError(resultCode, errors.New(resultDescription))
}
return result, nil
} | go | {
"resource": ""
} |
q11113 | Bind | train | func (l *Conn) Bind(username, password string) error {
packet := ber.Encode(ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "LDAP Request")
packet.AppendChild(ber.NewInteger(ber.ClassUniversal, ber.TypePrimitive, ber.TagInteger, l.nextMessageID(), "MessageID"))
bindRequest := ber.Encode(ber.ClassApplication, ber.TypeConstructed, ApplicationBindRequest, nil, "Bind Request")
bindRequest.AppendChild(ber.NewInteger(ber.ClassUniversal, ber.TypePrimitive, ber.TagInteger, 3, "Version"))
bindRequest.AppendChild(ber.NewString(ber.ClassUniversal, ber.TypePrimitive, ber.TagOctetString, username, "User Name"))
bindRequest.AppendChild(ber.NewString(ber.ClassContext, ber.TypePrimitive, 0, password, "Password"))
packet.AppendChild(bindRequest)
if l.Debug {
ber.PrintPacket(packet)
}
msgCtx, err := l.sendMessage(packet)
if err != nil {
return err
}
defer l.finishMessage(msgCtx)
packetResponse, ok := <-msgCtx.responses
if !ok {
return NewError(ErrorNetwork, errors.New("ldap: response channel closed"))
}
packet, err = packetResponse.ReadPacket()
l.Debug.Printf("%d: got response %p", msgCtx.id, packet)
if err != nil {
return err
}
if l.Debug {
if err := addLDAPDescriptions(packet); err != nil {
return err
}
ber.PrintPacket(packet)
}
resultCode, resultDescription := getLDAPResultCode(packet)
if resultCode != 0 {
return NewError(resultCode, errors.New(resultDescription))
}
return nil
} | go | {
"resource": ""
} |
q11114 | NewError | train | func NewError(resultCode uint8, err error) error {
return &Error{ResultCode: resultCode, Err: err}
} | go | {
"resource": ""
} |
q11115 | IsErrorWithCode | train | func IsErrorWithCode(err error, desiredResultCode uint8) bool {
if err == nil {
return false
}
serverError, ok := err.(*Error)
if !ok {
return false
}
return serverError.ResultCode == desiredResultCode
} | go | {
"resource": ""
} |
q11116 | CompileFilter | train | func CompileFilter(filter string) (*ber.Packet, error) {
if len(filter) == 0 || filter[0] != '(' {
return nil, NewError(ErrorFilterCompile, errors.New("ldap: filter does not start with an '('"))
}
packet, pos, err := compileFilter(filter, 1)
if err != nil {
return nil, err
}
if pos != len(filter) {
return nil, NewError(ErrorFilterCompile, errors.New("ldap: finished compiling filter with extra at end: "+fmt.Sprint(filter[pos:])))
}
return packet, nil
} | go | {
"resource": ""
} |
q11117 | escapedStringToEncodedBytes | train | func escapedStringToEncodedBytes(escapedString string) (string, error) {
var buffer bytes.Buffer
i := 0
for i < len(escapedString) {
currentRune, currentWidth := utf8.DecodeRuneInString(escapedString[i:])
if currentRune == utf8.RuneError {
return "", NewError(ErrorFilterCompile, fmt.Errorf("ldap: error reading rune at position %d", i))
}
// Check for escaped hex characters and convert them to their literal value for transport.
if currentRune == '\\' {
// http://tools.ietf.org/search/rfc4515
// \ (%x5C) is not a valid character unless it is followed by two HEX characters due to not
// being a member of UTF1SUBSET.
if i+2 > len(escapedString) {
return "", NewError(ErrorFilterCompile, errors.New("ldap: missing characters for escape in filter"))
}
escByte, decodeErr := hexpac.DecodeString(escapedString[i+1 : i+3])
if decodeErr != nil {
return "", NewError(ErrorFilterCompile, errors.New("ldap: invalid characters for escape in filter"))
}
buffer.WriteByte(escByte[0])
i += 2 // +1 from end of loop, so 3 total for \xx.
} else {
buffer.WriteRune(currentRune)
}
i += currentWidth
}
return buffer.String(), nil
} | go | {
"resource": ""
} |
q11118 | NewDelRequest | train | func NewDelRequest(DN string,
Controls []Control) *DelRequest {
return &DelRequest{
DN: DN,
Controls: Controls,
}
} | go | {
"resource": ""
} |
q11119 | Del | train | func (l *Conn) Del(delRequest *DelRequest) error {
packet := ber.Encode(ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "LDAP Request")
packet.AppendChild(ber.NewInteger(ber.ClassUniversal, ber.TypePrimitive, ber.TagInteger, l.nextMessageID(), "MessageID"))
packet.AppendChild(delRequest.encode())
if delRequest.Controls != nil {
packet.AppendChild(encodeControls(delRequest.Controls))
}
l.Debug.PrintPacket(packet)
msgCtx, err := l.sendMessage(packet)
if err != nil {
return err
}
defer l.finishMessage(msgCtx)
l.Debug.Printf("%d: waiting for response", msgCtx.id)
packetResponse, ok := <-msgCtx.responses
if !ok {
return NewError(ErrorNetwork, errors.New("ldap: response channel closed"))
}
packet, err = packetResponse.ReadPacket()
l.Debug.Printf("%d: got response %p", msgCtx.id, packet)
if err != nil {
return err
}
if l.Debug {
if err := addLDAPDescriptions(packet); err != nil {
return err
}
ber.PrintPacket(packet)
}
if packet.Children[1].Tag == ApplicationDelResponse {
resultCode, resultDescription := getLDAPResultCode(packet)
if resultCode != 0 {
return NewError(resultCode, errors.New(resultDescription))
}
} else {
log.Printf("Unexpected Response: %d", packet.Children[1].Tag)
}
l.Debug.Printf("%d: returning", msgCtx.id)
return nil
} | go | {
"resource": ""
} |
q11120 | sslCertificatePermissions | train | func sslCertificatePermissions(cert, key os.FileInfo) {
kmode := key.Mode()
if kmode != kmode&0600 {
panic(ErrSSLKeyHasWorldPermissions)
}
} | go | {
"resource": ""
} |
q11121 | hexify | train | func hexify(arr []byte) string {
var hexed bytes.Buffer
for i := 0; i < len(arr); i++ {
hexed.WriteString(strings.ToUpper(hex.EncodeToString(arr[i : i+1])))
if i < len(arr)-1 {
hexed.WriteString(":")
}
}
return hexed.String()
} | go | {
"resource": ""
} |
q11122 | decodeKey | train | func decodeKey(publicKey interface{}) (string, int) {
switch publicKey.(type) {
case *dsa.PublicKey:
return "DSA", publicKey.(*dsa.PublicKey).P.BitLen()
case *ecdsa.PublicKey:
return "ECDSA", publicKey.(*ecdsa.PublicKey).Curve.Params().BitSize
case *rsa.PublicKey:
return "RSA", publicKey.(*rsa.PublicKey).N.BitLen()
default:
return "", 0
}
} | go | {
"resource": ""
} |
q11123 | certWarnings | train | func certWarnings(cert *x509.Certificate, uriNames []string) (warnings []string) {
if cert.SerialNumber.Sign() != 1 {
warnings = append(warnings, "Serial number in cert appears to be zero/negative")
}
if cert.SerialNumber.BitLen() > 160 {
warnings = append(warnings, "Serial number too long; should be 20 bytes or less")
}
if cert.KeyUsage&x509.KeyUsageCertSign != 0 && !cert.IsCA {
warnings = append(warnings, "Key usage 'cert sign' is set, but is not a CA cert")
}
if cert.KeyUsage&x509.KeyUsageCertSign == 0 && cert.IsCA {
warnings = append(warnings, "Certificate is a CA cert, but key usage 'cert sign' missing")
}
if cert.Version < 2 {
warnings = append(warnings, fmt.Sprintf("Certificate is not in X509v3 format (version is %d)", cert.Version+1))
}
if len(cert.DNSNames) == 0 && len(cert.IPAddresses) == 0 && len(uriNames) == 0 && !cert.IsCA {
warnings = append(warnings, fmt.Sprintf("Certificate doesn't have any valid DNS/URI names or IP addresses set"))
}
if len(cert.UnhandledCriticalExtensions) > 0 {
warnings = append(warnings, "Certificate has unhandled critical extensions")
}
warnings = append(warnings, algWarnings(cert)...)
return
} | go | {
"resource": ""
} |
q11124 | algWarnings | train | func algWarnings(cert *x509.Certificate) (warnings []string) {
alg, size := decodeKey(cert.PublicKey)
if (alg == "RSA" || alg == "DSA") && size < 2048 {
warnings = append(warnings, fmt.Sprintf("Size of %s key should be at least 2048 bits", alg))
}
if alg == "ECDSA" && size < 224 {
warnings = append(warnings, fmt.Sprintf("Size of %s key should be at least 224 bits", alg))
}
for _, alg := range badSignatureAlgorithms {
if cert.SignatureAlgorithm == alg {
warnings = append(warnings, fmt.Sprintf("Signed with %s, which is an outdated signature algorithm", algString(alg)))
}
}
if alg == "RSA" {
key := cert.PublicKey.(*rsa.PublicKey)
if key.E < 3 {
warnings = append(warnings, "Public key exponent in RSA key is less than 3")
}
if key.N.Sign() != 1 {
warnings = append(warnings, "Public key modulus in RSA key appears to be zero/negative")
}
}
return
} | go | {
"resource": ""
} |
q11125 | ssl | train | func ssl(o values) func(net.Conn) net.Conn {
verifyCaOnly := false
tlsConf := tls.Config{}
switch mode := o.Get("sslmode"); mode {
// "require" is the default.
case "", "require":
// We must skip TLS's own verification since it requires full
// verification since Go 1.3.
tlsConf.InsecureSkipVerify = true
// From http://www.postgresql.org/docs/current/static/libpq-ssl.html:
// Note: For backwards compatibility with earlier versions of PostgreSQL, if a
// root CA file exists, the behavior of sslmode=require will be the same as
// that of verify-ca, meaning the server certificate is validated against the
// CA. Relying on this behavior is discouraged, and applications that need
// certificate validation should always use verify-ca or verify-full.
if _, err := os.Stat(o.Get("sslrootcert")); err == nil {
verifyCaOnly = true
} else {
o.Set("sslrootcert", "")
}
case "verify-ca":
// We must skip TLS's own verification since it requires full
// verification since Go 1.3.
tlsConf.InsecureSkipVerify = true
verifyCaOnly = true
case "verify-full":
tlsConf.ServerName = o.Get("host")
case "disable":
return nil
default:
errorf(`unsupported sslmode %q; only "require" (default), "verify-full", "verify-ca", and "disable" supported`, mode)
}
sslClientCertificates(&tlsConf, o)
sslCertificateAuthority(&tlsConf, o)
sslRenegotiation(&tlsConf)
return func(conn net.Conn) net.Conn {
client := tls.Client(conn, &tlsConf)
if verifyCaOnly {
sslVerifyCertificateAuthority(client, &tlsConf)
}
return client
}
} | go | {
"resource": ""
} |
q11126 | sslClientCertificates | train | func sslClientCertificates(tlsConf *tls.Config, o values) {
sslkey := o.Get("sslkey")
sslcert := o.Get("sslcert")
var cinfo, kinfo os.FileInfo
var err error
if sslcert != "" && sslkey != "" {
// Check that both files exist. Note that we don't do any more extensive
// checks than this (such as checking that the paths aren't directories);
// LoadX509KeyPair() will take care of the rest.
cinfo, err = os.Stat(sslcert)
if err != nil {
panic(err)
}
kinfo, err = os.Stat(sslkey)
if err != nil {
panic(err)
}
} else {
// Automatically find certificates from ~/.postgresql
sslcert, sslkey, cinfo, kinfo = sslHomeCertificates()
if cinfo == nil || kinfo == nil {
// No certificates to load
return
}
}
// The files must also have the correct permissions
sslCertificatePermissions(cinfo, kinfo)
cert, err := tls.LoadX509KeyPair(sslcert, sslkey)
if err != nil {
panic(err)
}
tlsConf.Certificates = []tls.Certificate{cert}
} | go | {
"resource": ""
} |
q11127 | sslCertificateAuthority | train | func sslCertificateAuthority(tlsConf *tls.Config, o values) {
if sslrootcert := o.Get("sslrootcert"); sslrootcert != "" {
tlsConf.RootCAs = x509.NewCertPool()
cert, err := ioutil.ReadFile(sslrootcert)
if err != nil {
panic(err)
}
ok := tlsConf.RootCAs.AppendCertsFromPEM(cert)
if !ok {
errorf("couldn't parse pem in sslrootcert")
}
}
} | go | {
"resource": ""
} |
q11128 | sslHomeCertificates | train | func sslHomeCertificates() (cert, key string, cinfo, kinfo os.FileInfo) {
user, err := user.Current()
if err != nil {
// user.Current() might fail when cross-compiling. We have to ignore the
// error and continue without client certificates, since we wouldn't know
// from where to load them.
return
}
cert = filepath.Join(user.HomeDir, ".postgresql", "postgresql.crt")
key = filepath.Join(user.HomeDir, ".postgresql", "postgresql.key")
cinfo, err = os.Stat(cert)
if err != nil {
cinfo = nil
}
kinfo, err = os.Stat(key)
if err != nil {
kinfo = nil
}
return
} | go | {
"resource": ""
} |
q11129 | sslVerifyCertificateAuthority | train | func sslVerifyCertificateAuthority(client *tls.Conn, tlsConf *tls.Config) {
err := client.Handshake()
if err != nil {
panic(err)
}
certs := client.ConnectionState().PeerCertificates
opts := x509.VerifyOptions{
DNSName: client.ConnectionState().ServerName,
Intermediates: x509.NewCertPool(),
Roots: tlsConf.RootCAs,
}
for i, cert := range certs {
if i == 0 {
continue
}
opts.Intermediates.AddCert(cert)
}
_, err = certs[0].Verify(opts)
if err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q11130 | addLDAPDescriptions | train | func addLDAPDescriptions(packet *ber.Packet) (err error) {
defer func() {
if r := recover(); r != nil {
err = NewError(ErrorDebugging, errors.New("ldap: cannot process packet to add descriptions"))
}
}()
packet.Description = "LDAP Response"
packet.Children[0].Description = "Message ID"
application := uint8(packet.Children[1].Tag)
packet.Children[1].Description = ApplicationMap[application]
switch application {
case ApplicationBindRequest:
addRequestDescriptions(packet)
case ApplicationBindResponse:
addDefaultLDAPResponseDescriptions(packet)
case ApplicationUnbindRequest:
addRequestDescriptions(packet)
case ApplicationSearchRequest:
addRequestDescriptions(packet)
case ApplicationSearchResultEntry:
packet.Children[1].Children[0].Description = "Object Name"
packet.Children[1].Children[1].Description = "Attributes"
for _, child := range packet.Children[1].Children[1].Children {
child.Description = "Attribute"
child.Children[0].Description = "Attribute Name"
child.Children[1].Description = "Attribute Values"
for _, grandchild := range child.Children[1].Children {
grandchild.Description = "Attribute Value"
}
}
if len(packet.Children) == 3 {
addControlDescriptions(packet.Children[2])
}
case ApplicationSearchResultDone:
addDefaultLDAPResponseDescriptions(packet)
case ApplicationModifyRequest:
addRequestDescriptions(packet)
case ApplicationModifyResponse:
case ApplicationAddRequest:
addRequestDescriptions(packet)
case ApplicationAddResponse:
case ApplicationDelRequest:
addRequestDescriptions(packet)
case ApplicationDelResponse:
case ApplicationModifyDNRequest:
addRequestDescriptions(packet)
case ApplicationModifyDNResponse:
case ApplicationCompareRequest:
addRequestDescriptions(packet)
case ApplicationCompareResponse:
case ApplicationAbandonRequest:
addRequestDescriptions(packet)
case ApplicationSearchResultReference:
case ApplicationExtendedRequest:
addRequestDescriptions(packet)
case ApplicationExtendedResponse:
}
return nil
} | go | {
"resource": ""
} |
q11131 | DebugBinaryFile | train | func DebugBinaryFile(fileName string) error {
file, err := ioutil.ReadFile(fileName)
if err != nil {
return NewError(ErrorDebugging, err)
}
ber.PrintBytes(os.Stdout, file, "")
packet := ber.DecodePacket(file)
addLDAPDescriptions(packet)
ber.PrintPacket(packet)
return nil
} | go | {
"resource": ""
} |
q11132 | readBytes | train | func readBytes(r io.Reader) ([]byte, error) {
length, err := readInt32(r)
if err != nil {
return nil, err
}
buf := make([]byte, length)
_, err = io.ReadFull(r, buf)
if err != nil {
return nil, err
}
return buf, nil
} | go | {
"resource": ""
} |
q11133 | getPreKeyedHash | train | func getPreKeyedHash(password []byte) hash.Hash {
md := sha1.New()
buf := make([]byte, len(password)*2)
for i := 0; i < len(password); i++ {
buf[i*2+1] = password[i]
}
md.Write(buf)
// Yes, "Mighty Aphrodite" is a constant used by this method.
md.Write([]byte("Mighty Aphrodite"))
return md
} | go | {
"resource": ""
} |
q11134 | Parse | train | func (ks *KeyStore) Parse(r io.Reader, password []byte) error {
var md hash.Hash
if password != nil {
md = getPreKeyedHash(password)
r = io.TeeReader(r, md)
}
version, err := parseHeader(r)
if err != nil {
return err
}
if version != jceksVersion {
return fmt.Errorf("unexpected version: %d != %d", version, jceksVersion)
}
count, err := readInt32(r)
if err != nil {
return err
}
for i := 0; i < int(count); i++ {
tag, err := readInt32(r)
if err != nil {
return err
}
switch tag {
case 1:
// Private-key entry
err := ks.parsePrivateKey(r)
if err != nil {
return err
}
case 2:
// Trusted-cert entry
err := ks.parseTrustedCert(r)
if err != nil {
return err
}
case 3:
// Secret-key entry
return fmt.Errorf("unimplemented: Secret-key")
default:
return fmt.Errorf("unimplemented tag: %d", tag)
}
}
if md != nil {
computed := md.Sum([]byte{})
actual := make([]byte, len(computed))
_, err := io.ReadFull(r, actual)
if err != nil {
return err
}
if subtle.ConstantTimeCompare(computed, actual) != 1 {
return fmt.Errorf("keystore was tampered with or password was incorrect")
}
}
return nil
} | go | {
"resource": ""
} |
q11135 | GetPrivateKeyAndCerts | train | func (ks *KeyStore) GetPrivateKeyAndCerts(alias string, password []byte) (
key crypto.PrivateKey, certs []*x509.Certificate, err error) {
entry := ks.entries[alias]
if entry == nil {
return
}
switch t := entry.(type) {
case *privateKeyEntry:
if len(t.certs) < 1 {
return nil, nil, fmt.Errorf("key has no certificates")
}
key, err = t.Recover(password)
if err == nil {
certs = t.certs
return
}
}
return
} | go | {
"resource": ""
} |
q11136 | GetCert | train | func (ks *KeyStore) GetCert(alias string) (*x509.Certificate, error) {
entry := ks.entries[alias]
if entry == nil {
return nil, nil
}
switch t := entry.(type) {
case *trustedCertEntry:
return t.cert, nil
}
return nil, nil
} | go | {
"resource": ""
} |
q11137 | ListPrivateKeys | train | func (ks *KeyStore) ListPrivateKeys() []string {
var r []string
for k, v := range ks.entries {
if _, ok := v.(*privateKeyEntry); ok {
r = append(r, k)
}
}
return r
} | go | {
"resource": ""
} |
q11138 | ListCerts | train | func (ks *KeyStore) ListCerts() []string {
var r []string
for k, v := range ks.entries {
if _, ok := v.(*trustedCertEntry); ok {
r = append(r, k)
}
}
return r
} | go | {
"resource": ""
} |
q11139 | LoadFromFile | train | func LoadFromFile(filename string, password []byte) (*KeyStore, error) {
file, err := os.Open(filename)
if err != nil {
return nil, err
}
defer file.Close()
return LoadFromReader(file, password)
} | go | {
"resource": ""
} |
q11140 | LoadFromReader | train | func LoadFromReader(reader io.Reader, password []byte) (*KeyStore, error) {
ks := &KeyStore{
entries: make(map[string]interface{}),
}
err := ks.Parse(reader, password)
if err != nil {
return nil, err
}
return ks, err
} | go | {
"resource": ""
} |
q11141 | QueryContext | train | func (cn *conn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
list := make([]driver.Value, len(args))
for i, nv := range args {
list[i] = nv.Value
}
var closed chan<- struct{}
if ctx.Done() != nil {
closed = watchCancel(ctx, cn.cancel)
}
r, err := cn.query(query, list)
if err != nil {
return nil, err
}
r.closed = closed
return r, nil
} | go | {
"resource": ""
} |
q11142 | ExecContext | train | func (cn *conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
list := make([]driver.Value, len(args))
for i, nv := range args {
list[i] = nv.Value
}
if ctx.Done() != nil {
closed := watchCancel(ctx, cn.cancel)
defer close(closed)
}
return cn.Exec(query, list)
} | go | {
"resource": ""
} |
q11143 | BeginTx | train | func (cn *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
if opts.Isolation != 0 {
return nil, errors.New("isolation levels not supported")
}
if opts.ReadOnly {
return nil, errors.New("read-only transactions not supported")
}
tx, err := cn.Begin()
if err != nil {
return nil, err
}
if ctx.Done() != nil {
cn.txnClosed = watchCancel(ctx, cn.cancel)
}
return tx, nil
} | go | {
"resource": ""
} |
q11144 | Printf | train | func (debug debugging) Printf(format string, args ...interface{}) {
if debug {
log.Printf(format, args...)
}
} | go | {
"resource": ""
} |
q11145 | EncodeTLSInfoToText | train | func EncodeTLSInfoToText(tcs *tls.ConnectionState, cri *tls.CertificateRequestInfo) string {
version := lookup(tlsVersions, tcs.Version)
cipher := lookup(cipherSuites, tcs.CipherSuite)
description := TLSDescription{
Version: tlscolor(version),
Cipher: tlscolor(explainCipher(cipher)),
}
tlsInfoContext := tlsInfoContext{
Conn: &description,
}
if cri != nil {
criDesc, err := EncodeCRIToObject(cri)
if err == nil {
tlsInfoContext.CRI = criDesc.(*CertificateRequestInfo)
}
}
funcMap := sprig.TxtFuncMap()
extras := template.FuncMap{
"printCommonName": PrintCommonName,
"printShortName": PrintShortName,
"greenify": greenify,
}
for k, v := range extras {
funcMap[k] = v
}
t := template.New("TLS template").Funcs(funcMap)
t, err := t.Parse(tlsLayout)
if err != nil {
// Should never happen
panic(err)
}
var buffer bytes.Buffer
w := bufio.NewWriter(&buffer)
err = t.Execute(w, tlsInfoContext)
if err != nil {
// Should never happen
panic(err)
}
w.Flush()
return string(buffer.Bytes())
} | go | {
"resource": ""
} |
q11146 | EncodeTLSToObject | train | func EncodeTLSToObject(t *tls.ConnectionState) interface{} {
version := lookup(tlsVersions, t.Version)
cipher := lookup(cipherSuites, t.CipherSuite)
return &TLSDescription{
version.Slug,
cipher.Slug,
}
} | go | {
"resource": ""
} |
q11147 | EncodeCRIToObject | train | func EncodeCRIToObject(cri *tls.CertificateRequestInfo) (interface{}, error) {
out := &CertificateRequestInfo{}
for _, ca := range cri.AcceptableCAs {
subject, err := parseRawSubject(ca)
if err != nil {
return nil, err
}
out.AcceptableCAs = append(out.AcceptableCAs, simplePKIXName{subject, nil})
}
for _, scheme := range cri.SignatureSchemes {
desc, ok := signatureSchemeStrings[scheme]
if !ok {
desc = fmt.Sprintf("Unknown(0x%x)", scheme)
}
out.SignatureSchemes = append(out.SignatureSchemes, desc)
}
return out, nil
} | go | {
"resource": ""
} |
q11148 | lookup | train | func lookup(descriptions map[uint16]description, what uint16) description {
v, ok := descriptions[what]
if !ok {
unknown := fmt.Sprintf("UNKNOWN_%x", what)
return description{unknown, unknown, 0}
}
return v
} | go | {
"resource": ""
} |
q11149 | explainCipher | train | func explainCipher(d description) description {
kexAndCipher := strings.Split(d.Slug, "_WITH_")
d.Name = fmt.Sprintf("%s key exchange, %s cipher", kexAndCipher[0][len("TLS_"):], kexAndCipher[1])
return d
} | go | {
"resource": ""
} |
q11150 | FindControl | train | func FindControl(controls []Control, controlType string) Control {
for _, c := range controls {
if c.GetControlType() == controlType {
return c
}
}
return nil
} | go | {
"resource": ""
} |
q11151 | NewControlString | train | func NewControlString(controlType string, criticality bool, controlValue string) *ControlString {
return &ControlString{
ControlType: controlType,
Criticality: criticality,
ControlValue: controlValue,
}
} | go | {
"resource": ""
} |
q11152 | readCertsFromStream | train | func readCertsFromStream(reader io.Reader, filename string, format string, password func(string) string, callback func(*pem.Block)) error {
headers := map[string]string{}
if filename != "" && filename != os.Stdin.Name() {
headers[fileHeader] = filename
}
switch strings.TrimSpace(format) {
case "PEM":
scanner := pemScanner(reader)
for scanner.Scan() {
block, _ := pem.Decode(scanner.Bytes())
block.Headers = mergeHeaders(block.Headers, headers)
callback(block)
}
return nil
case "DER":
data, err := ioutil.ReadAll(reader)
if err != nil {
return fmt.Errorf("unable to read input: %s\n", err)
}
x509Certs, err0 := x509.ParseCertificates(data)
if err0 == nil {
for _, cert := range x509Certs {
callback(EncodeX509ToPEM(cert, headers))
}
return nil
}
p7bBlocks, err1 := pkcs7.ParseSignedData(data)
if err1 == nil {
for _, block := range p7bBlocks {
callback(pkcs7ToPem(block, headers))
}
return nil
}
return fmt.Errorf("unable to parse certificates from DER data\n* X.509 parser gave: %s\n* PKCS7 parser gave: %s\n", err0, err1)
case "PKCS12":
data, err := ioutil.ReadAll(reader)
if err != nil {
return fmt.Errorf("unable to read input: %s\n", err)
}
blocks, err := pkcs12.ToPEM(data, password(""))
if err != nil || len(blocks) == 0 {
return fmt.Errorf("keystore appears to be empty or password was incorrect\n")
}
for _, block := range blocks {
block.Headers = mergeHeaders(block.Headers, headers)
callback(block)
}
return nil
case "JCEKS":
keyStore, err := jceks.LoadFromReader(reader, []byte(password("")))
if err != nil {
return fmt.Errorf("unable to parse keystore: %s\n", err)
}
for _, alias := range keyStore.ListCerts() {
cert, _ := keyStore.GetCert(alias)
callback(EncodeX509ToPEM(cert, mergeHeaders(headers, map[string]string{nameHeader: alias})))
}
for _, alias := range keyStore.ListPrivateKeys() {
key, certs, err := keyStore.GetPrivateKeyAndCerts(alias, []byte(password(alias)))
if err != nil {
return fmt.Errorf("unable to parse keystore: %s\n", err)
}
block, err := keyToPem(key, mergeHeaders(headers, map[string]string{nameHeader: alias}))
if err != nil {
return fmt.Errorf("problem reading key: %s\n", err)
}
callback(block)
for _, cert := range certs {
callback(EncodeX509ToPEM(cert, mergeHeaders(headers, map[string]string{nameHeader: alias})))
}
}
return nil
}
return fmt.Errorf("unknown file type '%s'\n", format)
} | go | {
"resource": ""
} |
q11153 | EncodeX509ToPEM | train | func EncodeX509ToPEM(cert *x509.Certificate, headers map[string]string) *pem.Block {
return &pem.Block{
Type: "CERTIFICATE",
Bytes: cert.Raw,
Headers: headers,
}
} | go | {
"resource": ""
} |
q11154 | pkcs7ToPem | train | func pkcs7ToPem(block *pkcs7.SignedDataEnvelope, headers map[string]string) *pem.Block {
return &pem.Block{
Type: "PKCS7",
Bytes: block.Raw,
Headers: headers,
}
} | go | {
"resource": ""
} |
q11155 | keyToPem | train | func keyToPem(key crypto.PrivateKey, headers map[string]string) (*pem.Block, error) {
switch k := key.(type) {
case *rsa.PrivateKey:
return &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(k),
Headers: headers,
}, nil
case *ecdsa.PrivateKey:
raw, err := x509.MarshalECPrivateKey(k)
if err != nil {
return nil, fmt.Errorf("error marshaling key: %s\n", reflect.TypeOf(key))
}
return &pem.Block{
Type: "EC PRIVATE KEY",
Bytes: raw,
Headers: headers,
}, nil
}
return nil, fmt.Errorf("unknown key type: %s\n", reflect.TypeOf(key))
} | go | {
"resource": ""
} |
q11156 | pemScanner | train | func pemScanner(reader io.Reader) *bufio.Scanner {
scanner := bufio.NewScanner(reader)
scanner.Split(func(data []byte, atEOF bool) (int, []byte, error) {
block, rest := pem.Decode(data)
if block != nil {
size := len(data) - len(rest)
return size, data[:size], nil
}
return 0, nil, nil
})
return scanner
} | go | {
"resource": ""
} |
q11157 | TransformVec2 | train | func (mat *T) TransformVec2(v *vec2.T) {
// Use intermediate variables to not alter further computations.
x := mat[0][0]*v[0] + mat[1][0]*v[1]
v[1] = mat[0][1]*v[0] + mat[1][1]*v[1]
v[0] = x
} | go | {
"resource": ""
} |
q11158 | Transpose | train | func (mat *T) Transpose() *T {
temp := mat[0][1]
mat[0][1] = mat[1][0]
mat[1][0] = temp
return mat
} | go | {
"resource": ""
} |
q11159 | Scale | train | func (vec *T) Scale(f float32) *T {
vec[0] *= f
vec[1] *= f
vec[2] *= f
return vec
} | go | {
"resource": ""
} |
q11160 | Invert | train | func (vec *T) Invert() *T {
vec[0] = -vec[0]
vec[1] = -vec[1]
vec[2] = -vec[2]
return vec
} | go | {
"resource": ""
} |
q11161 | Vec3 | train | func (vec *T) Vec3() vec3.T {
return vec3.T{vec[0], vec[1], vec[2]}
} | go | {
"resource": ""
} |
q11162 | AssignVec3 | train | func (vec *T) AssignVec3(v *vec3.T) *T {
vec[0] = v[0]
vec[1] = v[1]
vec[2] = v[2]
vec[3] = 1
return vec
} | go | {
"resource": ""
} |
q11163 | Dot4 | train | func Dot4(a, b *T) float32 {
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]
} | go | {
"resource": ""
} |
q11164 | Angle | train | func Angle(a, b *T) float32 {
v := Dot(a, b) / (a.Length() * b.Length())
// prevent NaN
if v > 1. {
v = v - 2
} else if v < -1. {
v = v + 2
}
return math.Acos(v)
} | go | {
"resource": ""
} |
q11165 | Clamp | train | func (vec *T) Clamp(min, max *T) *T {
for i := range vec {
if vec[i] < min[i] {
vec[i] = min[i]
} else if vec[i] > max[i] {
vec[i] = max[i]
}
}
return vec
} | go | {
"resource": ""
} |
q11166 | Clamped | train | func (vec *T) Clamped(min, max *T) T {
result := *vec
result.Clamp(min, max)
return result
} | go | {
"resource": ""
} |
q11167 | ContainsPoint | train | func (rect *Rect) ContainsPoint(p *T) bool {
return p[0] >= rect.Min[0] && p[0] <= rect.Max[0] &&
p[1] >= rect.Min[1] && p[1] <= rect.Max[1]
} | go | {
"resource": ""
} |
q11168 | Scaled | train | func (vec *T) Scaled(f float64) T {
return T{vec[0] * f, vec[1] * f, vec[2] * f, vec[3]}
} | go | {
"resource": ""
} |
q11169 | Dot4 | train | func Dot4(a, b *T) float64 {
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]
} | go | {
"resource": ""
} |
q11170 | RotateAroundPoint | train | func (vec *T) RotateAroundPoint(point *T, angle float32) *T {
return vec.Sub(point).Rotate(angle).Add(point)
} | go | {
"resource": ""
} |
q11171 | IsLeftWinding | train | func IsLeftWinding(a, b *T) bool {
ab := b.Rotated(-a.Angle())
return ab.Angle() > 0
} | go | {
"resource": ""
} |
q11172 | IsRightWinding | train | func IsRightWinding(a, b *T) bool {
ab := b.Rotated(-a.Angle())
return ab.Angle() < 0
} | go | {
"resource": ""
} |
q11173 | Normalize | train | func (quat *T) Normalize() *T {
norm := quat.Norm()
if norm != 1 && norm != 0 {
ool := 1 / math.Sqrt(norm)
quat[0] *= ool
quat[1] *= ool
quat[2] *= ool
quat[3] *= ool
}
return quat
} | go | {
"resource": ""
} |
q11174 | Normalized | train | func (quat *T) Normalized() T {
norm := quat.Norm()
if norm != 1 && norm != 0 {
ool := 1 / math.Sqrt(norm)
return T{
quat[0] * ool,
quat[1] * ool,
quat[2] * ool,
quat[3] * ool,
}
} else {
return *quat
}
} | go | {
"resource": ""
} |
q11175 | Negate | train | func (quat *T) Negate() *T {
quat[0] = -quat[0]
quat[1] = -quat[1]
quat[2] = -quat[2]
quat[3] = -quat[3]
return quat
} | go | {
"resource": ""
} |
q11176 | Invert | train | func (quat *T) Invert() *T {
quat[0] = -quat[0]
quat[1] = -quat[1]
quat[2] = -quat[2]
return quat
} | go | {
"resource": ""
} |
q11177 | RotateVec3 | train | func (quat *T) RotateVec3(v *vec3.T) {
qv := T{v[0], v[1], v[2], 0}
inv := quat.Inverted()
q := Mul3(quat, &qv, &inv)
v[0] = q[0]
v[1] = q[1]
v[2] = q[2]
} | go | {
"resource": ""
} |
q11178 | Dot | train | func Dot(a, b *T) float32 {
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]
} | go | {
"resource": ""
} |
q11179 | Mul | train | func Mul(a, b *T) T {
q := T{
a[3]*b[0] + a[0]*b[3] + a[1]*b[2] - a[2]*b[1],
a[3]*b[1] + a[1]*b[3] + a[2]*b[0] - a[0]*b[2],
a[3]*b[2] + a[2]*b[3] + a[0]*b[1] - a[1]*b[0],
a[3]*b[3] - a[0]*b[0] - a[1]*b[1] - a[2]*b[2],
}
return q.Normalized()
} | go | {
"resource": ""
} |
q11180 | Mul3 | train | func Mul3(a, b, c *T) T {
q := Mul(a, b)
return Mul(&q, c)
} | go | {
"resource": ""
} |
q11181 | Mul4 | train | func Mul4(a, b, c, d *T) T {
q := Mul(a, b)
q = Mul(&q, c)
return Mul(&q, d)
} | go | {
"resource": ""
} |
q11182 | Vec3Diff | train | func Vec3Diff(a, b *vec3.T) T {
cr := vec3.Cross(a, b)
sr := math.Sqrt(2 * (1 + vec3.Dot(a, b)))
oosr := 1 / sr
q := T{cr[0] * oosr, cr[1] * oosr, cr[2] * oosr, sr * 0.5}
return q.Normalized()
} | go | {
"resource": ""
} |
q11183 | NewRect | train | func NewRect(a, b *T) (rect Rect) {
rect.Min = Min(a, b)
rect.Max = Max(a, b)
return rect
} | go | {
"resource": ""
} |
q11184 | Area | train | func (rect *Rect) Area() float64 {
return (rect.Max[0] - rect.Min[0]) * (rect.Max[1] - rect.Min[1])
} | go | {
"resource": ""
} |
q11185 | Joined | train | func Joined(a, b *Rect) (rect Rect) {
rect.Min = Min(&a.Min, &b.Min)
rect.Max = Max(&a.Max, &b.Max)
return rect
} | go | {
"resource": ""
} |
q11186 | FromAxisAngle | train | func FromAxisAngle(axis *vec3.T, angle float64) T {
angle *= 0.5
sin := math.Sin(angle)
q := T{axis[0] * sin, axis[1] * sin, axis[2] * sin, math.Cos(angle)}
return q.Normalized()
} | go | {
"resource": ""
} |
q11187 | FromEulerAngles | train | func FromEulerAngles(yHead, xPitch, zRoll float64) T {
qy := FromYAxisAngle(yHead)
qx := FromXAxisAngle(xPitch)
qz := FromZAxisAngle(zRoll)
return Mul3(&qy, &qx, &qz)
} | go | {
"resource": ""
} |
q11188 | AxisAngle | train | func (quat *T) AxisAngle() (axis vec3.T, angle float64) {
cos := quat[3]
sin := math.Sqrt(1 - cos*cos)
angle = math.Acos(cos)
var ooSin float64
if math.Abs(sin) < 0.0005 {
ooSin = 1
} else {
ooSin = 1 / sin
}
axis[0] = quat[0] * ooSin
axis[1] = quat[1] * ooSin
axis[2] = quat[2] * ooSin
return axis, angle
} | go | {
"resource": ""
} |
q11189 | ScaleVec2 | train | func (mat *T) ScaleVec2(s *vec2.T) *T {
mat[0][0] *= s[0]
mat[1][1] *= s[1]
return mat
} | go | {
"resource": ""
} |
q11190 | SetTranslation | train | func (mat *T) SetTranslation(v *vec2.T) *T {
mat[2][0] = v[0]
mat[2][1] = v[1]
return mat
} | go | {
"resource": ""
} |
q11191 | Translate | train | func (mat *T) Translate(v *vec2.T) *T {
mat[2][0] += v[0]
mat[2][1] += v[1]
return mat
} | go | {
"resource": ""
} |
q11192 | TransformVec3 | train | func (mat *T) TransformVec3(v *vec3.T) {
// Use intermediate variables to not alter further computations.
x := mat[0][0]*v[0] + mat[1][0]*v[1] + mat[2][0]*v[2]
y := mat[0][1]*v[0] + mat[1][1]*v[1] + mat[2][1]*v[2]
v[2] = mat[0][2]*v[0] + mat[1][2]*v[1] + mat[2][2]*v[2]
v[0] = x
v[1] = y
} | go | {
"resource": ""
} |
q11193 | Quaternion | train | func (mat *T) Quaternion() quaternion.T {
tr := mat.Trace()
s := math.Sqrt(tr + 1)
w := s * 0.5
s = 0.5 / s
q := quaternion.T{
(mat[1][2] - mat[2][1]) * s,
(mat[2][0] - mat[0][2]) * s,
(mat[0][1] - mat[1][0]) * s,
w,
}
return q.Normalized()
} | go | {
"resource": ""
} |
q11194 | AssignQuaternion | train | func (mat *T) AssignQuaternion(q *quaternion.T) *T {
xx := q[0] * q[0] * 2
yy := q[1] * q[1] * 2
zz := q[2] * q[2] * 2
xy := q[0] * q[1] * 2
xz := q[0] * q[2] * 2
yz := q[1] * q[2] * 2
wx := q[3] * q[0] * 2
wy := q[3] * q[1] * 2
wz := q[3] * q[2] * 2
mat[0][0] = 1 - (yy + zz)
mat[1][0] = xy - wz
mat[2][0] = xz + wy
mat[0][1] = xy + wz
mat[1][1] = 1 - (xx + zz)
mat[2][1] = yz - wx
mat[0][2] = xz - wy
mat[1][2] = yz + wx
mat[2][2] = 1 - (xx + yy)
return mat
} | go | {
"resource": ""
} |
q11195 | AssignCoordinateSystem | train | func (mat *T) AssignCoordinateSystem(x, y, z *vec3.T) *T {
mat[0][0] = x[0]
mat[1][0] = x[1]
mat[2][0] = x[2]
mat[0][1] = y[0]
mat[1][1] = y[1]
mat[2][1] = y[2]
mat[0][2] = z[0]
mat[1][2] = z[1]
mat[2][2] = z[2]
return mat
} | go | {
"resource": ""
} |
q11196 | Scale | train | func (vec *T) Scale(f float64) *T {
vec[0] *= f
vec[1] *= f
return vec
} | go | {
"resource": ""
} |
q11197 | Rotated | train | func (vec *T) Rotated(angle float64) T {
sinus := math.Sin(angle)
cosinus := math.Cos(angle)
return T{
vec[0]*cosinus - vec[1]*sinus,
vec[0]*sinus + vec[1]*cosinus,
}
} | go | {
"resource": ""
} |
q11198 | AssignEulerRotation | train | func (mat *T) AssignEulerRotation(yHead, xPitch, zRoll float64) *T {
sinH := math.Sin(yHead)
cosH := math.Cos(yHead)
sinP := math.Sin(xPitch)
cosP := math.Cos(xPitch)
sinR := math.Sin(zRoll)
cosR := math.Cos(zRoll)
mat[0][0] = cosR*cosH - sinR*sinP*sinH
mat[1][0] = -sinR * cosP
mat[2][0] = cosR*sinH + sinR*sinP*cosH
mat[0][1] = sinR*cosH + cosR*sinP*sinH
mat[1][1] = cosR * cosP
mat[2][1] = sinR*sinH - cosR*sinP*cosH
mat[0][2] = -cosP * sinH
mat[1][2] = sinP
mat[2][2] = cosP * cosH
return mat
} | go | {
"resource": ""
} |
q11199 | ExtractEulerAngles | train | func (mat *T) ExtractEulerAngles() (yHead, xPitch, zRoll float64) {
xPitch = math.Asin(mat[1][2])
f12 := math.Abs(mat[1][2])
if f12 > (1.0-0.0001) && f12 < (1.0+0.0001) { // f12 == 1.0
yHead = 0.0
zRoll = math.Atan2(mat[0][1], mat[0][0])
} else {
yHead = math.Atan2(-mat[0][2], mat[2][2])
zRoll = math.Atan2(-mat[1][0], mat[1][1])
}
return yHead, xPitch, zRoll
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.