Gecko [ goons4good.org ]

Name	Size	Permission	Date
M2Crypto	[ DIR ]	drwxr-xr-x	2021-09-16 14:54
M2Crypto-0.31.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2021-09-16 14:54
MarkupSafe-0.11-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2021-09-16 14:49
OpenSSL	[ DIR ]	drwxr-xr-x	2021-09-16 10:58
backports	[ DIR ]	drwxr-xr-x	2021-09-16 10:43
cffi	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
cffi-1.6.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
cryptography	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
cryptography-1.7.2-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
curl	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
dbus	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
dns	[ DIR ]	drwxr-xr-x	2024-09-22 02:58
gi	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
glib	[ DIR ]	drwxr-xr-x	2021-09-16 14:49
gobject	[ DIR ]	drwxr-xr-x	2021-09-16 14:49
gpgme	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
gssapi	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
gssapi-1.2.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
gtk-2.0	[ DIR ]	drwxr-xr-x	2021-09-16 14:49
hgext	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
ldap	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
lxml	[ DIR ]	drwxr-xr-x	2021-09-16 10:55
lxml-3.2.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2021-09-16 10:55
markupsafe	[ DIR ]	drwxr-xr-x	2021-09-16 14:49
meld3	[ DIR ]	drwxr-xr-x	2024-07-29 10:18
mercurial	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
netifaces-0.10.4-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
nss	[ DIR ]	drwxr-xr-x	2022-07-26 09:09
numpy	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
policycoreutils	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
pygtkcompat	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
pyliblzma-0.5.3-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
pylve-2.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2026-02-10 03:49
pynche	[ DIR ]	drwxr-xr-x	2025-12-01 04:36
pyxattr-0.5.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
rpm	[ DIR ]	drwxr-xr-x	2021-11-25 03:44
selinux	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
seobject	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
sepolgen	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
sepolicy	[ DIR ]	drwxr-xr-x	2021-09-16 10:31
simplejson	[ DIR ]	drwxr-xr-x	2021-10-17 04:05
simplejson-3.11.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2021-10-17 04:05
yaml	[ DIR ]	drwxr-xr-x	2021-09-16 14:54
PyYAML-3.11-py2.7.egg-info	1.63 KB	-rw-r--r--	2020-04-22 15:44
README	119 B	-rw-r--r--	2025-11-12 09:24
_audit.so	163.65 KB	-rwxr-xr-x	2019-08-08 08:06
_cffi_backend.so	156.55 KB	-rwxr-xr-x	2016-11-05 20:41
_dbus_bindings.so	162.35 KB	-rwxr-xr-x	2014-06-10 03:12
_dbus_glib_bindings.so	11.7 KB	-rwxr-xr-x	2014-06-10 03:12
_ldap.so	70.13 KB	-rwxr-xr-x	2015-03-06 00:13
_semanage.so	311.41 KB	-rwxr-xr-x	2018-10-30 19:44
_snackmodule.so	39.95 KB	-rwxr-xr-x	2014-06-10 03:48
_sqlitecache.so	49.03 KB	-rwxr-xr-x	2014-06-10 04:39
_yaml.so	184.32 KB	-rw-r--r--	2020-04-22 15:44
acutilmodule.so	11.08 KB	-rwxr-xr-x	2017-08-04 05:05
audit.py	45.11 KB	-rw-r--r--	2019-08-08 08:06
audit.pyc	43.89 KB	-rw-r--r--	2019-08-08 08:06
audit.pyo	43.89 KB	-rw-r--r--	2019-08-08 08:06
auparse.so	63.2 KB	-rwxr-xr-x	2019-08-08 08:06
dmidecode.py	3.38 KB	-rw-r--r--	2020-03-31 15:46
dmidecode.pyc	2.25 KB	-rw-r--r--	2020-03-31 15:46
dmidecode.pyo	2.25 KB	-rw-r--r--	2020-03-31 15:46
dmidecodemod.so	182.78 KB	-rwxr-xr-x	2020-03-31 15:46
dnspython-1.12.0-py2.7.egg-info	1.25 KB	-rw-r--r--	2024-08-23 16:46
drv_libxml2.py	14.71 KB	-rw-r--r--	2025-09-08 09:50
drv_libxml2.pyc	10.94 KB	-rw-r--r--	2025-09-08 09:50
drv_libxml2.pyo	10.94 KB	-rw-r--r--	2025-09-08 09:50
dsml.py	8.06 KB	-rw-r--r--	2014-03-24 06:20
dsml.pyc	9.31 KB	-rw-r--r--	2015-03-06 00:13
dsml.pyo	9.17 KB	-rw-r--r--	2015-03-06 00:13
ethtool-0.8-py2.7.egg-info	307 B	-rw-r--r--	2019-06-09 05:30
ethtool.so	42.83 KB	-rwxr-xr-x	2019-06-09 05:30
gudev.so	28.99 KB	-rwxr-xr-x	2014-09-17 11:00
ldapurl.py	11.61 KB	-rw-r--r--	2014-03-24 06:20
ldapurl.pyc	13.29 KB	-rw-r--r--	2015-03-06 00:13
ldapurl.pyo	12.89 KB	-rw-r--r--	2015-03-06 00:13
ldif.py	13.34 KB	-rw-r--r--	2014-03-24 06:20
ldif.pyc	13.77 KB	-rw-r--r--	2015-03-06 00:13
ldif.pyo	13.77 KB	-rw-r--r--	2015-03-06 00:13
liblzma.py	164 B	-rw-r--r--	2014-06-10 01:20
liblzma.pyc	361 B	-rw-r--r--	2014-06-10 01:20
liblzma.pyo	361 B	-rw-r--r--	2014-06-10 01:20
libxml2.py	337.44 KB	-rw-r--r--	2025-09-08 09:50
libxml2.pyc	438.93 KB	-rw-r--r--	2025-09-08 09:50
libxml2.pyo	438.93 KB	-rw-r--r--	2025-09-08 09:50
libxml2mod.so	417.95 KB	-rwxr-xr-x	2025-09-08 09:50
lzma.so	66.3 KB	-rwxr-xr-x	2014-06-10 01:20
meld3-0.6.10-py2.7.egg-info	550 B	-rw-r--r--	2014-02-18 11:03
mercurial-2.6.2-py2.7.egg-info	1.3 KB	-rw-r--r--	2020-03-31 23:33
netifaces.so	19.41 KB	-rwxr-xr-x	2016-11-05 12:25
numpy-1.7.1-py2.7.egg-info	1.59 KB	-rw-r--r--	2018-04-10 19:40
perf-0.1-py2.7.egg-info	261 B	-rw-r--r--	2019-04-30 10:31
perf.so	311.72 KB	-rwxr-xr-x	2019-04-30 10:52
policycoreutils_default_encoding-0.1-py2.7.egg-info	300 B	-rw-r--r--	2020-04-01 00:04
pyOpenSSL-0.13.1-py2.7.egg-info	582 B	-rw-r--r--	2018-10-30 12:46
pycurl-7.19.0-py2.7.egg-info	366 B	-rw-r--r--	2016-11-05 11:10
pycurl.so	69.09 KB	-rwxr-xr-x	2016-11-05 11:10
pygobject-3.22.0-py2.7-linux-x86_64.egg-info	1013 B	-rw-r--r--	2017-11-21 07:44
pygpgme-0.3-py2.7.egg-info	889 B	-rw-r--r--	2014-06-09 19:30
pygtk.pth	8 B	-rw-r--r--	2014-09-17 07:50
pygtk.py	2.9 KB	-rw-r--r--	2014-09-17 07:50
pygtk.pyc	2.01 KB	-rw-r--r--	2014-09-17 07:50
pygtk.pyo	1.72 KB	-rw-r--r--	2014-09-17 07:50
pyhbac.so	38.23 KB	-rwxr-xr-x	2024-01-25 10:56
pylve.so	23.67 KB	-rwxr-xr-x	2026-01-20 08:47
pysss.so	68.67 KB	-rwxr-xr-x	2024-01-29 02:13
pysss_murmur.so	7.14 KB	-rwxr-xr-x	2024-01-25 10:56
python_dmidecode-3.10.13-py2.7.egg-info	311 B	-rw-r--r--	2020-03-31 15:46
python_ldap-2.4.15-py2.7.egg-info	1.41 KB	-rw-r--r--	2015-03-06 00:13
python_nss-0.16.0-py2.7.egg-info	2.19 KB	-rw-r--r--	2015-11-19 22:21
schedutils-0.4-py2.7.egg-info	291 B	-rw-r--r--	2016-11-05 17:51
schedutils.so	15.53 KB	-rwxr-xr-x	2016-11-05 17:51
semanage.py	54.1 KB	-rwxr-xr-x	2018-10-30 19:44
semanage.pyc	67.86 KB	-rw-r--r--	2018-10-30 19:44
semanage.pyo	67.86 KB	-rw-r--r--	2018-10-30 19:44
seobject-0.1-py2.7.egg-info	291 B	-rw-r--r--	2020-04-01 00:04
sepolicy-1.1-py2.7.egg-info	227 B	-rw-r--r--	2020-04-01 00:04
snack.py	30.23 KB	-rw-r--r--	2014-06-10 03:48
snack.pyc	39.98 KB	-rw-r--r--	2014-06-10 03:48
snack.pyo	39.98 KB	-rw-r--r--	2014-06-10 03:48
sqlitecachec.py	2.45 KB	-rw-r--r--	2009-08-18 11:26
sqlitecachec.pyc	2.12 KB	-rw-r--r--	2014-06-10 04:39
sqlitecachec.pyo	2.12 KB	-rw-r--r--	2014-06-10 04:39
wireshark_be.py	9.88 KB	-rw-r--r--	2020-09-30 13:53
wireshark_be.pyc	5.98 KB	-rw-r--r--	2020-09-30 13:54
wireshark_be.pyo	5.98 KB	-rw-r--r--	2020-09-30 13:54
wireshark_gen.py	91.17 KB	-rw-r--r--	2020-09-30 13:53
wireshark_gen.pyc	65.5 KB	-rw-r--r--	2020-09-30 13:54
wireshark_gen.pyo	65.5 KB	-rw-r--r--	2020-09-30 13:54
xattr.so	31.76 KB	-rw-r--r--	2014-06-09 18:24
yum_metadata_parser-1.1.4-py2.7.egg-info	213 B	-rw-r--r--	2014-06-10 04:39

Rename

"""
ldif - generate and parse LDIF data (see RFC 2849)

See http://www.python-ldap.org/ for details.

$Id: ldif.py,v 1.74 2014/03/12 23:11:26 stroeder Exp $

Python compability note:
Tested with Python 2.0+, but should work with Python 1.5.2+.
"""

__version__ = '2.4.15'

__all__ = [
  # constants
  'ldif_pattern',
  # functions
  'AttrTypeandValueLDIF','CreateLDIF','ParseLDIF',
  # classes
  'LDIFWriter',
  'LDIFParser',
  'LDIFRecordList',
  'LDIFCopy',
]

import urlparse,urllib,base64,re,types

try:
  from cStringIO import StringIO
except ImportError:
  from StringIO import StringIO

attrtype_pattern = r'[\w;.-]+(;[\w_-]+)*'
attrvalue_pattern = r'(([^,]|\\,)+|".*?")'
attrtypeandvalue_pattern = attrtype_pattern + r'[ ]*=[ ]*' + attrvalue_pattern
rdn_pattern   = attrtypeandvalue_pattern + r'([ ]*\+[ ]*' + attrtypeandvalue_pattern + r')*[ ]*'
dn_pattern   = rdn_pattern + r'([ ]*,[ ]*' + rdn_pattern + r')*[ ]*'
dn_regex   = re.compile('^%s$' % dn_pattern)

ldif_pattern = '^((dn(:|::) %(dn_pattern)s)|(%(attrtype_pattern)s(:|::) .*)$)+' % vars()

MOD_OP_INTEGER = {
  'add':0,'delete':1,'replace':2
}

MOD_OP_STR = {
  0:'add',1:'delete',2:'replace'
}

CHANGE_TYPES = ['add','delete','modify','modrdn']
valid_changetype_dict = {}
for c in CHANGE_TYPES:
  valid_changetype_dict[c]=None

def is_dn(s):
  """
  returns 1 if s is a LDAP DN
  """
  if s=='':
    return 1
  rm = dn_regex.match(s)
  return rm!=None and rm.group(0)==s

SAFE_STRING_PATTERN = '(^(\000|\n|\r| |:|<)|[\000\n\r\200-\377]+|[ ]+$)'
safe_string_re = re.compile(SAFE_STRING_PATTERN)

def list_dict(l):
  """
  return a dictionary with all items of l being the keys of the dictionary
  """
  return dict([(i,None) for i in l])

class LDIFWriter:
  """
  Write LDIF entry or change records to file object
  Copy LDIF input to a file output object containing all data retrieved
  via URLs
  """

def __init__(self,output_file,base64_attrs=None,cols=76,line_sep='\n'):
    """
    output_file
        file object for output
    base64_attrs
        list of attribute types to be base64-encoded in any case
    cols
        Specifies how many columns a line may have before it's
        folded into many lines.
    line_sep
        String used as line separator
    """
    self._output_file = output_file
    self._base64_attrs = list_dict([a.lower() for a in (base64_attrs or [])])
    self._cols = cols
    self._line_sep = line_sep
    self.records_written = 0

def _unfoldLDIFLine(self,line):
    """
    Write string line as one or more folded lines
    """
    # Check maximum line length
    line_len = len(line)
    if line_len<=self._cols:
      self._output_file.write(line)
      self._output_file.write(self._line_sep)
    else:
      # Fold line
      pos = self._cols
      self._output_file.write(line[0:min(line_len,self._cols)])
      self._output_file.write(self._line_sep)
      while pos<line_len:
        self._output_file.write(' ')
        self._output_file.write(line[pos:min(line_len,pos+self._cols-1)])
        self._output_file.write(self._line_sep)
        pos = pos+self._cols-1
    return # _unfoldLDIFLine()

def _needs_base64_encoding(self,attr_type,attr_value):
    """
    returns 1 if attr_value has to be base-64 encoded because
    of special chars or because attr_type is in self._base64_attrs
    """
    return self._base64_attrs.has_key(attr_type.lower()) or \
           not safe_string_re.search(attr_value) is None

def _unparseAttrTypeandValue(self,attr_type,attr_value):
    """
    Write a single attribute type/value pair

attr_type
          attribute type
    attr_value
          attribute value
    """
    if self._needs_base64_encoding(attr_type,attr_value):
      # Encode with base64
      self._unfoldLDIFLine(':: '.join([attr_type,base64.encodestring(attr_value).replace('\n','')]))
    else:
      self._unfoldLDIFLine(': '.join([attr_type,attr_value]))
    return # _unparseAttrTypeandValue()

def _unparseEntryRecord(self,entry):
    """
    entry
        dictionary holding an entry
    """
    attr_types = entry.keys()[:]
    attr_types.sort()
    for attr_type in attr_types:
      for attr_value in entry[attr_type]:
        self._unparseAttrTypeandValue(attr_type,attr_value)

def _unparseChangeRecord(self,modlist):
    """
    modlist
        list of additions (2-tuple) or modifications (3-tuple)
    """
    mod_len = len(modlist[0])
    if mod_len==2:
      changetype = 'add'
    elif mod_len==3:
      changetype = 'modify'
    else:
      raise ValueError,"modlist item of wrong length"
    self._unparseAttrTypeandValue('changetype',changetype)
    for mod in modlist:
      if mod_len==2:
        mod_type,mod_vals = mod
      elif mod_len==3:
        mod_op,mod_type,mod_vals = mod
        self._unparseAttrTypeandValue(MOD_OP_STR[mod_op],mod_type)
      else:
        raise ValueError,"Subsequent modlist item of wrong length"
      if mod_vals:
        for mod_val in mod_vals:
          self._unparseAttrTypeandValue(mod_type,mod_val)
      if mod_len==3:
        self._output_file.write('-'+self._line_sep)

def unparse(self,dn,record):
    """
    dn
          string-representation of distinguished name
    record
          Either a dictionary holding the LDAP entry {attrtype:record}
          or a list with a modify list like for LDAPObject.modify().
    """
    # Start with line containing the distinguished name
    self._unparseAttrTypeandValue('dn',dn)
    # Dispatch to record type specific writers
    if isinstance(record,types.DictType):
      self._unparseEntryRecord(record)
    elif isinstance(record,types.ListType):
      self._unparseChangeRecord(record)
    else:
      raise ValueError, "Argument record must be dictionary or list"
    # Write empty line separating the records
    self._output_file.write(self._line_sep)
    # Count records written
    self.records_written = self.records_written+1
    return # unparse()

def CreateLDIF(dn,record,base64_attrs=None,cols=76):
  """
  Create LDIF single formatted record including trailing empty line.
  This is a compability function. Use is deprecated!

dn
        string-representation of distinguished name
  record
        Either a dictionary holding the LDAP entry {attrtype:record}
        or a list with a modify list like for LDAPObject.modify().
  base64_attrs
        list of attribute types to be base64-encoded in any case
  cols
        Specifies how many columns a line may have before it's
        folded into many lines.
  """
  f = StringIO()
  ldif_writer = LDIFWriter(f,base64_attrs,cols,'\n')
  ldif_writer.unparse(dn,record)
  s = f.getvalue()
  f.close()
  return s

class LDIFParser:
  """
  Base class for a LDIF parser. Applications should sub-class this
  class and override method handle() to implement something meaningful.

Public class attributes:

records_read
        Counter for records processed so far
  """

def _stripLineSep(self,s):
    """
    Strip trailing line separators from s, but no other whitespaces
    """
    if s[-2:]=='\r\n':
      return s[:-2]
    elif s[-1:]=='\n':
      return s[:-1]
    else:
      return s

def __init__(
    self,
    input_file,
    ignored_attr_types=None,
    max_entries=0,
    process_url_schemes=None,
    line_sep='\n'
  ):
    """
    Parameters:
    input_file
        File-object to read the LDIF input from
    ignored_attr_types
        Attributes with these attribute type names will be ignored.
    max_entries
        If non-zero specifies the maximum number of entries to be
        read from f.
    process_url_schemes
        List containing strings with URLs schemes to process with urllib.
        An empty list turns off all URL processing and the attribute
        is ignored completely.
    line_sep
        String used as line separator
    """
    self._input_file = input_file
    self._max_entries = max_entries
    self._process_url_schemes = list_dict([s.lower() for s in (process_url_schemes or [])])
    self._ignored_attr_types = list_dict([a.lower() for a in (ignored_attr_types or [])])
    self._line_sep = line_sep
    self.records_read = 0

def handle(self,dn,entry):
    """
    Process a single content LDIF record. This method should be
    implemented by applications using LDIFParser.
    """

def _unfoldLDIFLine(self):
    """
    Unfold several folded lines with trailing space into one line
    """
    unfolded_lines = [ self._stripLineSep(self._line) ]
    self._line = self._input_file.readline()
    while self._line and self._line[0]==' ':
      unfolded_lines.append(self._stripLineSep(self._line[1:]))
      self._line = self._input_file.readline()
    return ''.join(unfolded_lines)

def _parseAttrTypeandValue(self):
    """
    Parse a single attribute type and value pair from one or
    more lines of LDIF data
    """
    # Reading new attribute line
    unfolded_line = self._unfoldLDIFLine()
    # Ignore comments which can also be folded
    while unfolded_line and unfolded_line[0]=='#':
      unfolded_line = self._unfoldLDIFLine()
    if not unfolded_line or unfolded_line=='\n' or unfolded_line=='\r\n':
      return None,None
    try:
      colon_pos = unfolded_line.index(':')
    except ValueError:
      # Treat malformed lines without colon as non-existent
      return None,None
    attr_type = unfolded_line[0:colon_pos]
    # if needed attribute value is BASE64 decoded
    value_spec = unfolded_line[colon_pos:colon_pos+2]
    if value_spec=='::':
      # attribute value needs base64-decoding
      attr_value = base64.decodestring(unfolded_line[colon_pos+2:])
    elif value_spec==':<':
      # fetch attribute value from URL
      url = unfolded_line[colon_pos+2:].strip()
      attr_value = None
      if self._process_url_schemes:
        u = urlparse.urlparse(url)
        if self._process_url_schemes.has_key(u[0]):
          attr_value = urllib.urlopen(url).read()
    elif value_spec==':\r\n' or value_spec=='\n':
      attr_value = ''
    else:
      attr_value = unfolded_line[colon_pos+2:].lstrip()
    return attr_type,attr_value

def parse(self):
    """
    Continously read and parse LDIF records
    """
    self._line = self._input_file.readline()

while self._line and \
          (not self._max_entries or self.records_read<self._max_entries):

# Reset record
      version = None; dn = None; changetype = None; modop = None; entry = {}

attr_type,attr_value = self._parseAttrTypeandValue()

while attr_type!=None and attr_value!=None:
        if attr_type=='dn':
          # attr type and value pair was DN of LDIF record
          if dn!=None:
            raise ValueError, 'Two lines starting with dn: in one record.'
          if not is_dn(attr_value):
            raise ValueError, 'No valid string-representation of distinguished name %s.' % (repr(attr_value))
          dn = attr_value
        elif attr_type=='version' and dn is None:
          version = 1
        elif attr_type=='changetype':
          # attr type and value pair was DN of LDIF record
          if dn is None:
            raise ValueError, 'Read changetype: before getting valid dn: line.'
          if changetype!=None:
            raise ValueError, 'Two lines starting with changetype: in one record.'
          if not valid_changetype_dict.has_key(attr_value):
            raise ValueError, 'changetype value %s is invalid.' % (repr(attr_value))
          changetype = attr_value
        elif attr_value!=None and \
             not self._ignored_attr_types.has_key(attr_type.lower()):
          # Add the attribute to the entry if not ignored attribute
          if entry.has_key(attr_type):
            entry[attr_type].append(attr_value)
          else:
            entry[attr_type]=[attr_value]

# Read the next line within an entry
        attr_type,attr_value = self._parseAttrTypeandValue()

if entry:
        # append entry to result list
        self.handle(dn,entry)
        self.records_read = self.records_read+1

return # parse()

class LDIFRecordList(LDIFParser):
  """
  Collect all records of LDIF input into a single list.
  of 2-tuples (dn,entry). It can be a memory hog!
  """

def __init__(
    self,
    input_file,
    ignored_attr_types=None,max_entries=0,process_url_schemes=None
  ):
    """
    See LDIFParser.__init__()

Additional Parameters:
    all_records
        List instance for storing parsed records
    """
    LDIFParser.__init__(self,input_file,ignored_attr_types,max_entries,process_url_schemes)
    self.all_records = []

def handle(self,dn,entry):
    """
    Append single record to dictionary of all records.
    """
    self.all_records.append((dn,entry))

class LDIFCopy(LDIFParser):
  """
  Copy LDIF input to LDIF output containing all data retrieved
  via URLs
  """

def __init__(
    self,
    input_file,output_file,
    ignored_attr_types=None,max_entries=0,process_url_schemes=None,
    base64_attrs=None,cols=76,line_sep='\n'
  ):
    """
    See LDIFParser.__init__() and LDIFWriter.__init__()
    """
    LDIFParser.__init__(self,input_file,ignored_attr_types,max_entries,process_url_schemes)
    self._output_ldif = LDIFWriter(output_file,base64_attrs,cols,line_sep)

def handle(self,dn,entry):
    """
    Write single LDIF record to output file.
    """
    self._output_ldif.unparse(dn,entry)

def ParseLDIF(f,ignore_attrs=None,maxentries=0):
  """
  Parse LDIF records read from file.
  This is a compability function. Use is deprecated!
  """
  ldif_parser = LDIFRecordList(
    f,ignored_attr_types=ignore_attrs,max_entries=maxentries,process_url_schemes=0
  )
  ldif_parser.parse()
  return ldif_parser.all_records