func mustMarshal(val interface{}, params string) []byte {
data, err := asn1.MarshalWithParams(val, params)
if err != nil {
panic(err)
}
return data
}
func (n Not) marshal() ([]byte, error) {
f, err := n.Filter.marshal()
if err != nil {
return nil, err
}
return asn1.MarshalWithParams(asn1.RawValue{FullBytes: f}, notParam)
}
func (o Or) marshal() (data []byte, err error) {
filters := make([]asn1.RawValue, len(o))
for i, f := range o {
if filters[i].FullBytes, err = f.marshal(); err != nil {
return nil, err
}
}
return asn1.MarshalWithParams(filterSet{filters}, orParam)
}
func (s *authSock) Write(b []byte) (int, error) {
if s.finished {
sz := [4]byte{}
binary.BigEndian.PutUint32(sz[:], uint32(len(b)))
if _, err := s.Conn.Write(sz[:]); err != nil {
return 0, err
}
return s.Conn.Write(b)
}
if s.waitReply {
if _, err := s.Read(nil); err != nil {
return 0, err
}
}
var err error
req := bindRequest{
Version: ldapVersion,
}
if s.mech == "SIMPLE" {
idx := bytes.IndexByte(b, 0)
req.BindDN = b[:idx]
req.Auth.FullBytes, err = asn1.MarshalWithParams(b[idx+1:], simpleBindParam)
} else {
req.Auth.FullBytes, err = asn1.MarshalWithParams(saslCredentials{[]byte(s.mech), b}, saslBindParam)
}
if err != nil {
return 0, err
}
if err := dosend(s.Conn, bindRequestParam, req); err != nil {
return 0, err
}
s.waitReply = true
return len(b), nil
}
func (db *DB) send(param string, req interface{}, reply replyHandler) error {
data, err := asn1.MarshalWithParams(req, param)
if err != nil {
return err
}
db.lk.Lock()
defer db.lk.Unlock()
if db.closed {
return ErrClosed
}
if db.conn == nil {
rw, conn, err := open(db.url, db.cfg)
if err != nil {
return err
}
db.conn = conn
db.rw = rw
go db.rxThread(rw, conn)
}
id := db.nextId
db.nextId++
msg := message{
Id: id,
Data: asn1.RawValue{
FullBytes: data,
},
}
out, err := asn1.Marshal(msg)
if err != nil {
return err
}
if _, err := db.rw.Write(out); err != nil {
return err
}
if reply != nil {
db.replies[id] = reply
}
return nil
}
func dosend(rw io.ReadWriter, param string, req interface{}) error {
rdata, err := asn1.MarshalWithParams(req, param)
if err != nil {
return err
}
msg := message{
Id: 0,
Data: asn1.RawValue{
FullBytes: rdata,
},
}
mdata, err := asn1.Marshal(msg)
if err != nil {
return err
}
if _, err := rw.Write(mdata); err != nil {
return err
}
return nil
}
func (p Present) marshal() ([]byte, error) {
return asn1.MarshalWithParams([]byte(p), presentParam)
}
func (e LessOrEqual) marshal() ([]byte, error) {
return asn1.MarshalWithParams(assertion{[]byte(e.Attr), e.Value}, lessOrEqualParam)
}