net-ldap 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e841cb17541b78bfa5524c4358aa1dc9c7172b62
-  data.tar.gz: 6d32f7ba11d6812d194a93f970e7a4057ecc967c
+  metadata.gz: 1e84cd86cc0974d9380b18caa917cfa8d8f3e8f2
+  data.tar.gz: 6e6783c3b458b1c5b3abd72745a0e56b4e749d35
 SHA512:
-  metadata.gz: a85f9b44249fb246942b13f4cd6885da6217009db03a67f607fb5f4c6b5d6592993a07689ad893a2d78317e3628b8f75fdca774ab0f01e12d904b42a4b992d6c
-  data.tar.gz: 6181f8297c98641b97e03f96a2edca4a8a03bcbde1d47fcbf11b9b9f530b15d19ebf7d50fbe3f4a3c5d834b7bd1173faeaea99150d102bec71218dfa667b4dd9
+  metadata.gz: 5c3b405a5086b6f33522fe611cff02ca6e325498db1b54b9d4415222c870eedae5466a3e9c65ba9d16cfc6db89392eafbbcee4537a0b70a79a6651a92695e9d6
+  data.tar.gz: 81ce6fa1369f1a5bcbacd35efc939a8f9aa97ada21ef122314c029b9c0b3a32d6dddb8c9b43a3d2cf25d9fffad7d2fe97b992cd92c5597f8b26b72ceeacf1dc1

data/README.rdoc

@@ -16,13 +16,8 @@ the most recent LDAP RFCs (4510–4519, plus portions of 4520–4532).
 
 == Where
 
-* {RubyForge}[http://rubyforge.org/projects/net-ldap]
 * {GitHub}[https://github.com/ruby-ldap/ruby-net-ldap]
 * {ruby-ldap@googlegroups.com}[http://groups.google.com/group/ruby-ldap]
-* {Documentation}[http://net-ldap.rubyforge.org/]
-
-The Net::LDAP for Ruby documentation, project description, and main downloads
-can currently be found on {RubyForge}[http://rubyforge.org/projects/net-ldap].
 
 == Synopsis
 

data/lib/net/ber/core_ext/string.rb

@@ -33,7 +33,9 @@ module Net::BER::Extensions::String
       rescue Encoding::UndefinedConversionError
         self
       rescue Encoding::ConverterNotFoundError
-        return self
+        self
+      rescue Encoding::InvalidByteSequenceError
+        self
       end
     else
       self

data/lib/net/ldap.rb

@@ -1160,14 +1160,24 @@ class Net::LDAP::Connection #:nodoc:
     end
   end
 
+  module FixSSLSocketSyncClose
+    def close
+      super
+      io.close
+    end
+  end
+
   def self.wrap_with_ssl(io)
     raise Net::LDAP::LdapError, "OpenSSL is unavailable" unless Net::LDAP::HasOpenSSL
     ctx = OpenSSL::SSL::SSLContext.new
     conn = OpenSSL::SSL::SSLSocket.new(io, ctx)
     conn.connect
-    conn.sync_close = true
+
+    # Doesn't work:
+    # conn.sync_close = true
 
     conn.extend(GetbyteForSSLSocket) unless conn.respond_to?(:getbyte)
+    conn.extend(FixSSLSocketSyncClose)
 
     conn
   end
@@ -1206,7 +1216,7 @@ class Net::LDAP::Connection #:nodoc:
       # go here.
     when :start_tls
       msgid = next_msgid.to_ber
-      request = [Net::LDAP::StartTlsOid.to_ber].to_ber_appsequence(Net::LDAP::PDU::ExtendedRequest)
+      request = [Net::LDAP::StartTlsOid.to_ber_contextspecific(0)].to_ber_appsequence(Net::LDAP::PDU::ExtendedRequest)
       request_pkt = [msgid, request].to_ber_sequence
       @conn.write request_pkt
       be = @conn.read_ber(Net::LDAP::AsnSyntax)

data/lib/net/ldap/entry.rb

@@ -113,6 +113,14 @@ class Net::LDAP::Entry
     @myhash[name] || []
   end
 
+  ##
+  # Read the first value for the provided attribute. The attribute name
+  # is canonicalized prior to reading. Returns nil if the attribute does 
+  # not exist.
+  def first(name)
+    self[name].first
+  end
+
   ##
   # Returns the first distinguished name (dn) of the Entry as a \String.
   def dn
@@ -147,7 +155,7 @@ class Net::LDAP::Entry
     Net::LDAP::Dataset.from_entry(self).to_ldif_string
   end
 
-  def respond_to?(sym) #:nodoc:
+  def respond_to?(sym, include_all = false) #:nodoc:
     return true if valid_attribute?(self.class.attribute_name(sym))
     return super
   end

data/lib/net/ldap/filter.rb

@@ -65,22 +65,22 @@ class Net::LDAP::Filter
       new(:eq, attribute, value)
     end
 
-		##
-		# Creates a Filter object indicating a binary comparison.
-		# this prevents the search data from being forced into a UTF-8 string.
-		#
-		# This is primarily used for Microsoft Active Directory to compare
-		# GUID values.
-		#
-		#    # for guid represented as hex charecters
-		#    guid = "6a31b4a12aa27a41aca9603f27dd5116"
-		#    guid_bin = [guid].pack("H*")
-		#    f = Net::LDAP::Filter.bineq("objectGUID", guid_bin)
-		#
-		# This filter does not perform any escaping.
-		def bineq(attribute, value)
-			new(:bineq, attribute, value)
-		end
+    ##
+    # Creates a Filter object indicating a binary comparison.
+    # this prevents the search data from being forced into a UTF-8 string.
+    #
+    # This is primarily used for Microsoft Active Directory to compare
+    # GUID values.
+    #
+    #    # for guid represented as hex charecters
+    #    guid = "6a31b4a12aa27a41aca9603f27dd5116"
+    #    guid_bin = [guid].pack("H*")
+    #    f = Net::LDAP::Filter.bineq("objectGUID", guid_bin)
+    #
+    # This filter does not perform any escaping.
+    def bineq(attribute, value)
+      new(:bineq, attribute, value)
+    end
 
     ##
     # Creates a Filter object indicating extensible comparison. This Filter
@@ -414,10 +414,8 @@ class Net::LDAP::Filter
     case @op
     when :ne
       "!(#{@left}=#{@right})"
-    when :eq
+    when :eq, :bineq
       "#{@left}=#{@right}"
-		when :bineq
-			"#{@left}=#{@right}"
     when :ex
       "#{@left}:=#{@right}"
     when :ge
@@ -527,9 +525,9 @@ class Net::LDAP::Filter
       else # equality
         [@left.to_s.to_ber, unescape(@right).to_ber].to_ber_contextspecific(3)
       end
-		when :bineq
-			# make sure data is not forced to UTF-8
-			[@left.to_s.to_ber, unescape(@right).to_ber_bin].to_ber_contextspecific(3)
+    when :bineq
+      # make sure data is not forced to UTF-8
+      [@left.to_s.to_ber, unescape(@right).to_ber_bin].to_ber_contextspecific(3)
     when :ex
       seq = []
 
@@ -755,7 +753,7 @@ class Net::LDAP::Filter
         scanner.scan(/\s*/)
         if op = scanner.scan(/<=|>=|!=|:=|=/)
           scanner.scan(/\s*/)
-          if value = scanner.scan(/(?:[-\w*.+@=,#\$%&!'\s\xC3\x80-\xCA\xAF]|[^\x00-\x7F]|\\[a-fA-F\d]{2})+/u)
+          if value = scanner.scan(/(?:[-\w*.+:@=,#\$%&!'\s\xC3\x80-\xCA\xAF]|[^\x00-\x7F]|\\[a-fA-F\d]{2})+/u)
             # 20100313 AZ: Assumes that "(uid=george*)" is the same as
             # "(uid=george* )". The standard doesn't specify, but I can find
             # no examples that suggest otherwise.

data/lib/net/ldap/version.rb

@@ -1,5 +1,5 @@
 module Net
   class LDAP
-    VERSION = "0.6.1"
+    VERSION = "0.7.0"
   end
 end

data/spec/integration/ssl_ber_spec.rb

@@ -1,15 +1,18 @@
 require 'spec_helper'
 
 require 'net/ldap'
+require 'timeout'
 
 describe "BER serialisation (SSL)" do
   # Transmits str to #to and reads it back from #from. 
   #
   def transmit(str)
-    to.write(str)
-    to.close
-    
-    from.read
+    Timeout::timeout(1) do
+      to.write(str)
+      to.close
+
+      from.read
+    end
   end
     
   attr_reader :to, :from

data/spec/spec_helper.rb

@@ -2,4 +2,9 @@ require 'net/ldap'
 
 RSpec.configure do |config|
   config.mock_with :flexmock
+
+  def raw_string(s)
+    # Conveniently, String#b only needs to be called when it exists
+    s.respond_to?(:b) ? s.b : s
+  end
 end

data/spec/unit/ber/ber_spec.rb

@@ -33,28 +33,28 @@ describe "BER encoding of" do
   context "numbers" do
     # Sample based
     {
-      0           => "\x02\x01\x00", 
-      1           => "\x02\x01\x01", 
-      127         => "\x02\x01\x7F", 
-      128         => "\x02\x01\x80", 
-      255         => "\x02\x01\xFF", 
-      256         => "\x02\x02\x01\x00", 
-      65535       => "\x02\x02\xFF\xFF", 
-      65536       => "\x02\x03\x01\x00\x00", 
-      16_777_215  => "\x02\x03\xFF\xFF\xFF", 
-      0x01000000  => "\x02\x04\x01\x00\x00\x00", 
-      0x3FFFFFFF  => "\x02\x04\x3F\xFF\xFF\xFF", 
-      0x4FFFFFFF  => "\x02\x04\x4F\xFF\xFF\xFF", 
-      
+      0           => raw_string("\x02\x01\x00"),
+      1           => raw_string("\x02\x01\x01"),
+      127         => raw_string("\x02\x01\x7F"),
+      128         => raw_string("\x02\x01\x80"),
+      255         => raw_string("\x02\x01\xFF"),
+      256         => raw_string("\x02\x02\x01\x00"),
+      65535       => raw_string("\x02\x02\xFF\xFF"),
+      65536       => raw_string("\x02\x03\x01\x00\x00"),
+      16_777_215  => raw_string("\x02\x03\xFF\xFF\xFF"),
+      0x01000000  => raw_string("\x02\x04\x01\x00\x00\x00"),
+      0x3FFFFFFF  => raw_string("\x02\x04\x3F\xFF\xFF\xFF"),
+      0x4FFFFFFF  => raw_string("\x02\x04\x4F\xFF\xFF\xFF"),
+
       # Some odd samples...
-      5           => "\002\001\005", 
-      500         => "\002\002\001\364", 
-      50_000      => "\x02\x02\xC3P", 
-      5_000_000_000  => "\002\005\001*\005\362\000"
-    }.each do |number, expected_encoding| 
+      5           => raw_string("\002\001\005"),
+      500         => raw_string("\002\002\001\364"),
+      50_000      => raw_string("\x02\x02\xC3P"),
+      5_000_000_000  => raw_string("\002\005\001*\005\362\000")
+    }.each do |number, expected_encoding|
       it "should encode #{number} as #{expected_encoding.inspect}" do
         number.to_ber.should == expected_encoding
-      end 
+      end
     end
 
     # Round-trip encoding: This is mostly to be sure to cover Bignums well.
@@ -79,7 +79,7 @@ describe "BER encoding of" do
     context "strings" do
       it "should properly encode UTF-8 strings" do
         "\u00e5".force_encoding("UTF-8").to_ber.should ==
-          "\x04\x02\xC3\xA5"
+          raw_string("\x04\x02\xC3\xA5")
       end
       it "should properly encode strings encodable as UTF-8" do
         "teststring".encode("US-ASCII").to_ber.should == "\x04\nteststring"
@@ -87,7 +87,7 @@ describe "BER encoding of" do
 			it "should properly encode binary data strings using to_ber_bin" do
 				# This is used for searching for GUIDs in Active Directory
 				["6a31b4a12aa27a41aca9603f27dd5116"].pack("H*").to_ber_bin.should == 
-					"\x04\x10" + "j1\xB4\xA1*\xA2zA\xAC\xA9`?'\xDDQ\x16"
+					raw_string("\x04\x10" + "j1\xB4\xA1*\xA2zA\xAC\xA9`?'\xDDQ\x16")
 			end
       it "should not fail on strings that can not be converted to UTF-8" do
         error = Encoding::UndefinedConversionError

data/spec/unit/ber/core_ext/string_spec.rb

@@ -6,7 +6,7 @@ describe String, "when extended with BER core extensions" do
     context "when passed an ldap bind request and some extra data" do
       attr_reader :str, :result
       before(:each) do
-        @str = "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus UNCONSUMED" 
+        @str = raw_string("0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus UNCONSUMED")
         @result = str.read_ber!(Net::LDAP::AsnSyntax)
       end
       
@@ -22,7 +22,7 @@ describe String, "when extended with BER core extensions" do
         before(:each) do
           stub_exception_class = Class.new(StandardError)
           
-          @initial_value = "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus" 
+          @initial_value = raw_string("0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus")
           @str = initial_value.dup 
 
           # Defines a string

data/spec/unit/ldap/filter_parser_spec.rb

@@ -16,5 +16,11 @@ describe Net::LDAP::Filter::FilterParser do
         expect(Net::LDAP::Filter::FilterParser.parse(filter_string)).to be_a Net::LDAP::Filter
       end
     end
+    context "Given string including colons ':'" do
+      let(:filter_string) { "(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)" }
+      specify "should generate filter object" do
+        expect(Net::LDAP::Filter::FilterParser.parse(filter_string)).to be_a Net::LDAP::Filter
+      end
+    end
   end
 end

data/spec/unit/ldap/filter_spec.rb

@@ -83,12 +83,12 @@ describe Net::LDAP::Filter do
   end
 
   context 'with a well-known BER string' do
-    ber = "\xa4\x2d" \
+    ber = raw_string("\xa4\x2d" \
       "\x04\x0b" "objectclass" \
       "\x30\x1e" \
       "\x80\x08" "foo" "*\\" "bar" \
       "\x81\x08" "foo" "*\\" "bar" \
-      "\x82\x08" "foo" "*\\" "bar"
+      "\x82\x08" "foo" "*\\" "bar")
 
     describe "<- .to_ber" do
       [

data/test/test_snmp.rb

@@ -4,10 +4,15 @@ require 'common'
 require 'net/snmp'
 
 class TestSnmp < Test::Unit::TestCase
-  SnmpGetRequest = "0'\002\001\000\004\006public\240\032\002\002?*\002\001\000\002\001\0000\0160\f\006\b+\006\001\002\001\001\001\000\005\000"
-  SnmpGetResponse = "0+\002\001\000\004\006public\242\036\002\002'\017\002\001\000\002\001\0000\0220\020\006\b+\006\001\002\001\001\001\000\004\004test"
+  def self.raw_string(s)
+    # Conveniently, String#b only needs to be called when it exists
+    s.respond_to?(:b) ? s.b : s
+  end
+
+  SnmpGetRequest = raw_string("0'\002\001\000\004\006public\240\032\002\002?*\002\001\000\002\001\0000\0160\f\006\b+\006\001\002\001\001\001\000\005\000")
+  SnmpGetResponse = raw_string("0+\002\001\000\004\006public\242\036\002\002'\017\002\001\000\002\001\0000\0220\020\006\b+\006\001\002\001\001\001\000\004\004test")
 
-  SnmpGetRequestXXX = "0'\002\001\000\004\006xxxxxx\240\032\002\002?*\002\001\000\002\001\0000\0160\f\006\b+\006\001\002\001\001\001\000\005\000"
+  SnmpGetRequestXXX = raw_string("0'\002\001\000\004\006xxxxxx\240\032\002\002?*\002\001\000\002\001\0000\0160\f\006\b+\006\001\002\001\001\001\000\005\000")
 
   def test_invalid_packet
     data = "xxxx"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-ldap
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Francis Cianfrocca
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-14 00:00:00.000000000 Z
+date: 2014-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc