// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// File contains a filter compiler/decompiler
package ldap
import (
"fmt"
"os"
"github.com/mmitton/asn1-ber"
)
const (
FilterAnd = 0
FilterOr = 1
FilterNot = 2
FilterEqualityMatch = 3
FilterSubstrings = 4
FilterGreaterOrEqual = 5
FilterLessOrEqual = 6
FilterPresent = 7
FilterApproxMatch = 8
FilterExtensibleMatch = 9
)
var FilterMap = map[ uint64 ] string {
FilterAnd : "And",
FilterOr : "Or",
FilterNot : "Not",
FilterEqualityMatch : "Equality Match",
FilterSubstrings : "Substrings",
FilterGreaterOrEqual : "Greater Or Equal",
FilterLessOrEqual : "Less Or Equal",
FilterPresent : "Present",
FilterApproxMatch : "Approx Match",
FilterExtensibleMatch : "Extensible Match",
}
const (
FilterSubstringsInitial = 0
FilterSubstringsAny = 1
FilterSubstringsFinal = 2
)
var FilterSubstringsMap = map[ uint64 ] string {
FilterSubstringsInitial : "Substrings Initial",
FilterSubstringsAny : "Substrings Any",
FilterSubstringsFinal : "Substrings Final",
}
func CompileFilter( filter string ) ( *ber.Packet, *Error ) {
if len( filter ) == 0 || filter[ 0 ] != '(' {
return nil, NewError( ErrorFilterCompile, os.NewError( "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, os.NewError( "Finished compiling filter with extra at end.\n" + fmt.Sprint( filter[pos:] ) ) )
}
return packet, nil
}
func DecompileFilter( packet *ber.Packet ) (ret string, err *Error) {
defer func() {
if r := recover(); r != nil {
err = NewError( ErrorFilterDecompile, os.NewError( "Error decompiling filter" ) )
}
}()
ret = "("
err = nil
child_str := ""
switch packet.Tag {
case FilterAnd:
ret += "&"
for _, child := range packet.Children {
child_str, err = DecompileFilter( child )
if err != nil {
return
}
ret += child_str
}
case FilterOr:
ret += "|"
for _, child := range packet.Children {
child_str, err = DecompileFilter( child )
if err != nil {
return
}
ret += child_str
}
case FilterNot:
ret += "!"
child_str, err = DecompileFilter( packet.Children[ 0 ] )
if err != nil {
return
}
ret += child_str
case FilterSubstrings:
ret += ber.DecodeString( packet.Children[ 0 ].Data.Bytes() )
ret += "="
switch packet.Children[ 1 ].Children[ 0 ].Tag {
case FilterSubstringsInitial:
ret += ber.DecodeString( packet.Children[ 1 ].Children[ 0 ].Data.Bytes() ) + "*"
case FilterSubstringsAny:
ret += "*" + ber.DecodeString( packet.Children[ 1 ].Children[ 0 ].Data.Bytes() ) + "*"
case FilterSubstringsFinal:
ret += "*" + ber.DecodeString( packet.Children[ 1 ].Children[ 0 ].Data.Bytes() )
}
case FilterEqualityMatch:
ret += ber.DecodeString( packet.Children[ 0 ].Data.Bytes() )
ret += "="
ret += ber.DecodeString( packet.Children[ 1 ].Data.Bytes() )
case FilterGreaterOrEqual:
ret += ber.DecodeString( packet.Children[ 0 ].Data.Bytes() )
ret += ">="
ret += ber.DecodeString( packet.Children[ 1 ].Data.Bytes() )
case FilterLessOrEqual:
ret += ber.DecodeString( packet.Children[ 0 ].Data.Bytes() )
ret += "<="
ret += ber.DecodeString( packet.Children[ 1 ].Data.Bytes() )
case FilterPresent:
ret += ber.DecodeString( packet.Children[ 0 ].Data.Bytes() )
ret += "=*"
case FilterApproxMatch:
ret += ber.DecodeString( packet.Children[ 0 ].Data.Bytes() )
ret += "~="
ret += ber.DecodeString( packet.Children[ 1 ].Data.Bytes() )
}
ret += ")"
return
}
func compileFilterSet( filter string, pos int, parent *ber.Packet ) ( int, *Error ) {
for pos < len( filter ) && filter[ pos ] == '(' {
child, new_pos, err := compileFilter( filter, pos + 1 )
if err != nil {
return pos, err
}
pos = new_pos
parent.AppendChild( child )
}
if pos == len( filter ) {
return pos, NewError( ErrorFilterCompile, os.NewError( "Unexpected end of filter" ) )
}
return pos + 1, nil
}
func compileFilter( filter string, pos int ) ( p *ber.Packet, new_pos int, err *Error ) {
defer func() {
if r := recover(); r != nil {
err = NewError( ErrorFilterCompile, os.NewError( "Error compiling filter" ) )
}
}()
p = nil
new_pos = pos
err = nil
switch filter[pos] {
case '(':
p, new_pos, err = compileFilter( filter, pos + 1 )
new_pos++
return
case '&':
p = ber.Encode( ber.ClassContext, ber.TypeConstructed, FilterAnd, nil, FilterMap[ FilterAnd ] )
new_pos, err = compileFilterSet( filter, pos + 1, p )
return
case '|':
p = ber.Encode( ber.ClassContext, ber.TypeConstructed, FilterOr, nil, FilterMap[ FilterOr ] )
new_pos, err = compileFilterSet( filter, pos + 1, p )
return
case '!':
p = ber.Encode( ber.ClassContext, ber.TypeConstructed, FilterNot, nil, FilterMap[ FilterNot ] )
var child *ber.Packet
child, new_pos, err = compileFilter( filter, pos + 1 )
p.AppendChild( child )
return
default:
attribute := ""
condition := ""
for new_pos < len( filter ) && filter[ new_pos ] != ')' {
switch {
case p != nil:
condition += fmt.Sprintf( "%c", filter[ new_pos ] )
case filter[ new_pos ] == '=':
p = ber.Encode( ber.ClassContext, ber.TypeConstructed, FilterEqualityMatch, nil, FilterMap[ FilterEqualityMatch ] )
case filter[ new_pos ] == '>' && filter[ new_pos + 1 ] == '=':
p = ber.Encode( ber.ClassContext, ber.TypeConstructed, FilterGreaterOrEqual, nil, FilterMap[ FilterGreaterOrEqual ] )
new_pos++
case filter[ new_pos ] == '<' && filter[ new_pos + 1 ] == '=':
p = ber.Encode( ber.ClassContext, ber.TypeConstructed, FilterLessOrEqual, nil, FilterMap[ FilterLessOrEqual ] )
new_pos++
case filter[ new_pos ] == '~' && filter[ new_pos + 1 ] == '=':
p = ber.Encode( ber.ClassContext, ber.TypeConstructed, FilterApproxMatch, nil, FilterMap[ FilterLessOrEqual ] )
new_pos++
case p == nil:
attribute += fmt.Sprintf( "%c", filter[ new_pos ] )
}
new_pos++
}
if new_pos == len( filter ) {
err = NewError( ErrorFilterCompile, os.NewError( "Unexpected end of filter" ) )
return
}
if p == nil {
err = NewError( ErrorFilterCompile, os.NewError( "Error parsing filter" ) )
return
}
p.AppendChild( ber.NewString( ber.ClassUniversal, ber.TypePrimative, ber.TagOctetString, attribute, "Attribute" ) )
switch {
case p.Tag == FilterEqualityMatch && condition == "*":
p.Tag = FilterPresent
p.Description = FilterMap[ uint64(p.Tag) ]
case p.Tag == FilterEqualityMatch && condition[ 0 ] == '*' && condition[ len( condition ) - 1 ] == '*':
// Any
p.Tag = FilterSubstrings
p.Description = FilterMap[ uint64(p.Tag) ]
seq := ber.Encode( ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "Substrings" )
seq.AppendChild( ber.NewString( ber.ClassContext, ber.TypePrimative, FilterSubstringsAny, condition[ 1 : len( condition ) - 1 ], "Any Substring" ) )
p.AppendChild( seq )
case p.Tag == FilterEqualityMatch && condition[ 0 ] == '*':
// Final
p.Tag = FilterSubstrings
p.Description = FilterMap[ uint64(p.Tag) ]
seq := ber.Encode( ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "Substrings" )
seq.AppendChild( ber.NewString( ber.ClassContext, ber.TypePrimative, FilterSubstringsFinal, condition[ 1: ], "Final Substring" ) )
p.AppendChild( seq )
case p.Tag == FilterEqualityMatch && condition[ len( condition ) - 1 ] == '*':
// Initial
p.Tag = FilterSubstrings
p.Description = FilterMap[ uint64(p.Tag) ]
seq := ber.Encode( ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "Substrings" )
seq.AppendChild( ber.NewString( ber.ClassContext, ber.TypePrimative, FilterSubstringsInitial, condition[ :len( condition ) - 1 ], "Initial Substring" ) )
p.AppendChild( seq )
default:
p.AppendChild( ber.NewString( ber.ClassUniversal, ber.TypePrimative, ber.TagOctetString, condition, "Condition" ) )
}
new_pos++
return
}
err = NewError( ErrorFilterCompile, os.NewError( "Reached end of filter without closing parens" ) )
return
}
