extensions/source/config/ldap/ldapuserprof.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ldapuserprof.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_extensions.hxx"
  33 #include "ldapuserprof.hxx"
  34 #include "ldapaccess.hxx"
  35 namespace extensions { namespace config { namespace ldap {
  36 //==============================================================================
  37
  38 //------------------------------------------------------------------------------
  39
  40 /**
  41   Finds the next line in a buffer and returns it, along with a
  42   modified version of the buffer with the line removed.
  43
  44   @param aString    string to extract the next line from
  45   @param aLine      next line
  46   @return   sal_True if a line has been extracted, sal_False otherwise
  47   */
  48 static sal_Bool getNextLine(rtl::OString& aString,
  49                             rtl::OString& aLine)
  50 {
  51     aString = aString.trim() ;
  52     const sal_Char *currentChar = aString ;
  53     const sal_Char *endChar = currentChar + aString.getLength() ;
  54     sal_Int32 lineThreshold = 0 ;
  55
  56     while (currentChar < endChar &&
  57             *currentChar != '\r' && *currentChar != '\n') { ++ currentChar ; }
  58     lineThreshold = currentChar - static_cast<const sal_Char *>(aString) ;
  59     if (lineThreshold == 0) { return sal_False ; }
  60     aLine = aString.copy(0, lineThreshold) ;
  61     aString = aString.copy(lineThreshold) ;
  62     return sal_True ;
  63 }
  64 //------------------------------------------------------------------------------
  65
  66 LdapUserProfileMap::~LdapUserProfileMap(void)
  67 {
  68     // No need to delete the contents of the mAttributes array,
  69     // since they refer to rtl::OStrings stored in the mLdapAttributes
  70     // array.
  71     if (mAttributes != NULL)
  72     {
  73         delete [] mAttributes ;
  74     }
  75 }
  76 //------------------------------------------------------------------------------
  77
  78 void LdapUserProfileMap::source(const rtl::OString& aMap)
  79 {
  80     if (mAttributes != NULL)
  81     {
  82         delete [] mAttributes ; mAttributes = NULL ;
  83         mMapping.clear() ;
  84     }
  85     rtl::OString currentLine ;
  86     rtl::OString buffer = aMap ;
  87     std::set<rtl::OString> attributes ;
  88     rtl::OString prefix ;
  89
  90     // First, parse the buffer to find all the mapping definitions.
  91     // While we're at it, we collect the list of unique LDAP attributes
  92     // involved in the mapping.
  93     while (getNextLine(buffer, currentLine))
  94     {
  95         addNewMapping(currentLine, attributes, prefix) ;
  96     }
  97     // Now we use the list of attributes to build mAttributes
  98     mAttributes = new const sal_Char * [attributes.size() + 1] ;
  99     std::set<rtl::OString>::const_iterator attribute ;
 100     sal_Int32 i = 0 ;
 101
 102     for (attribute = attributes.begin() ;
 103             attribute != attributes.end() ; ++ attribute)
 104     {
 105         mAttributes [i ++] = static_cast<const sal_Char *>(*attribute) ;
 106     }
 107     mAttributes [i] = NULL ;
 108 }
 109 //------------------------------------------------------------------------------
 110
 111 void LdapUserProfileMap::ldapToUserProfile(LDAP *aConnection,
 112                                            LDAPMessage *aEntry,
 113                                            LdapUserProfile& aProfile) const
 114 {
 115     if (aEntry == NULL) { return ; }
 116     // Ensure return value has proper size
 117     aProfile.mProfile.resize(mMapping.size()) ;
 118     sal_Char **values = NULL ;
 119
 120     for (sal_uInt32 i = 0 ; i < mMapping.size() ; ++ i)
 121     {
 122         aProfile.mProfile [i].mAttribute = rtl::OStringToOUString(
 123                                                mMapping [i].mProfileElement,
 124                                                RTL_TEXTENCODING_ASCII_US);
 125         rtl::OUString debugStr = aProfile.mProfile [i].mAttribute;
 126
 127         for (sal_uInt32 j = 0 ;
 128                 j < mMapping [i].mLdapAttributes.size() ; ++ j)
 129         {
 130             values = (*LdapConnection::s_p_get_values)(aConnection, aEntry,
 131                                      mMapping [i].mLdapAttributes [j]) ;
 132
 133             if (values != NULL)
 134             {
 135                 aProfile.mProfile[i].mValue = rtl::OStringToOUString(
 136                     *values, RTL_TEXTENCODING_UTF8);
 137                 (*LdapConnection::s_p_value_free)(values);
 138                 break;
 139             }
 140         }
 141     }
 142 }
 143 //------------------------------------------------------------------------------
 144 void LdapUserProfileMap::addNewMapping(const rtl::OString& aLine,
 145                                     std::set<rtl::OString>& aLdapAttributes,
 146                                     rtl::OString& aPrefix)
 147 {
 148     if (aLine.getStr() [0] == '#') { return ; }
 149     sal_Int32 prefixLength = aPrefix.getLength() ;
 150
 151     if (prefixLength == 0)
 152     {
 153         sal_Int32 firstSlash = aLine.indexOf('/') ;
 154
 155         if (firstSlash == -1) { return ; }
 156         sal_Int32 secondSlash = aLine.indexOf('/', firstSlash + 1) ;
 157
 158         if (secondSlash == -1){ return; }
 159
 160
 161         mComponentName =
 162             rtl::OUString::createFromAscii(aLine.copy(0, firstSlash)) ;
 163         mGroupName =
 164             rtl::OUString::createFromAscii(aLine.copy(firstSlash + 1,
 165                                                 secondSlash - firstSlash - 1)) ;
 166         aPrefix = aLine.copy(0, secondSlash + 1) ;
 167         prefixLength = secondSlash + 1 ;
 168
 169     }
 170     else if (aLine.compareTo(aPrefix, prefixLength) != 0)
 171     {
 172         return ;
 173     }
 174     mMapping.push_back(Mapping()) ;
 175     if (!mMapping.back().parse(aLine.copy(prefixLength)))
 176     {
 177         mMapping.pop_back() ;
 178     }
 179     else
 180     {
 181         const std::vector<rtl::OString>& attributes =
 182                                         mMapping.back().mLdapAttributes ;
 183         std::vector<rtl::OString>::const_iterator ldapAttribute ;
 184
 185         for (ldapAttribute = attributes.begin() ;
 186                 ldapAttribute != attributes.end() ; ++ ldapAttribute)
 187         {
 188             aLdapAttributes.insert(*ldapAttribute) ;
 189         }
 190     }
 191 }
 192 //------------------------------------------------------------------------------
 193
 194 static sal_Char kMappingSeparator = '=' ;
 195 static sal_Char kLdapMapSeparator = ',' ;
 196
 197 sal_Bool LdapUserProfileMap::Mapping::parse(const rtl::OString& aLine)
 198 {
 199     sal_Int32 index = aLine.indexOf(kMappingSeparator) ;
 200
 201     if (index == -1)
 202     {
 203         // Imparsable line
 204         return sal_False ;
 205     }
 206     sal_Int32 oldIndex = index + 1 ;
 207
 208     mProfileElement = aLine.copy(0, index).trim() ;
 209     mLdapAttributes.clear() ;
 210     index = aLine.indexOf(kLdapMapSeparator, oldIndex) ;
 211     while (index != -1)
 212     {
 213         mLdapAttributes.push_back(
 214                                 aLine.copy(oldIndex, index - oldIndex).trim()) ;
 215         oldIndex = index + 1 ;
 216         index = aLine.indexOf(kLdapMapSeparator, oldIndex) ;
 217     }
 218     rtl::OString endOfLine = aLine.copy(oldIndex).trim() ;
 219
 220     if (endOfLine.getLength() > 0)
 221     {
 222         mLdapAttributes.push_back(endOfLine) ;
 223     }
 224     return sal_True ;
 225 }
 226 //------------------------------------------------------------------------------
 227
 228 } } } // extensiond.config.ldap
 229