316 lines
9.0 KiB
C#
316 lines
9.0 KiB
C#
/******************************************************************************
|
|
* The MIT License
|
|
* Copyright (c) 2003 Novell Inc. www.novell.com
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the Software), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*******************************************************************************/
|
|
//
|
|
// Novell.Directory.Ldap.Utilclass.RDN.cs
|
|
//
|
|
// Author:
|
|
// Sunil Kumar (Sunilk@novell.com)
|
|
//
|
|
// (C) 2003 Novell, Inc (http://www.novell.com)
|
|
//
|
|
|
|
using System;
|
|
|
|
namespace Novell.Directory.Ldap.Utilclass
|
|
{
|
|
|
|
/// <summary> A RDN encapsulates a single object's name of a Distinguished Name(DN).
|
|
/// The object name represented by this class contains no context. Thus a
|
|
/// Relative Distinguished Name (RDN) could be relative to anywhere in the
|
|
/// Directories tree.
|
|
///
|
|
/// For example, of following DN, 'cn=admin, ou=marketing, o=corporation', all
|
|
/// possible RDNs are 'cn=admin', 'ou=marketing', and 'o=corporation'.
|
|
///
|
|
/// Multivalued attributes are encapsulated in this class. For example the
|
|
/// following could be represented by an RDN: 'cn=john + l=US', or
|
|
/// 'cn=juan + l=ES'
|
|
///
|
|
/// </summary>
|
|
/// <seealso cref="DN">
|
|
/// </seealso>
|
|
|
|
|
|
public class RDN:System.Object
|
|
{
|
|
/// <summary> Returns the actually Raw String before Normalization
|
|
///
|
|
/// </summary>
|
|
/// <returns> The raw string
|
|
/// </returns>
|
|
virtual protected internal System.String RawValue
|
|
{
|
|
get
|
|
{
|
|
return rawValue;
|
|
}
|
|
|
|
}
|
|
/// <summary> Returns the type of this RDN. This method assumes that only one value
|
|
/// is used, If multivalues attributes are used only the first Type is
|
|
/// returned. Use GetTypes.
|
|
/// </summary>
|
|
/// <returns> Type of attribute
|
|
/// </returns>
|
|
virtual public System.String Type
|
|
{
|
|
get
|
|
{
|
|
return (System.String) types[0];
|
|
}
|
|
|
|
}
|
|
/// <summary> Returns all the types for this RDN.</summary>
|
|
/// <returns> list of types
|
|
/// </returns>
|
|
virtual public System.String[] Types
|
|
{
|
|
get
|
|
{
|
|
System.String[] toReturn = new System.String[types.Count];
|
|
for (int i = 0; i < types.Count; i++)
|
|
toReturn[i] = ((System.String) types[i]);
|
|
return toReturn;
|
|
}
|
|
|
|
}
|
|
/// <summary> Returns the values of this RDN. If multivalues attributes are used only
|
|
/// the first Type is returned. Use GetTypes.
|
|
///
|
|
/// </summary>
|
|
/// <returns> Type of attribute
|
|
/// </returns>
|
|
virtual public System.String Value
|
|
{
|
|
get
|
|
{
|
|
return (System.String) values[0];
|
|
}
|
|
|
|
}
|
|
/// <summary> Returns all the types for this RDN.</summary>
|
|
/// <returns> list of types
|
|
/// </returns>
|
|
virtual public System.String[] Values
|
|
{
|
|
get
|
|
{
|
|
System.String[] toReturn = new System.String[values.Count];
|
|
for (int i = 0; i < values.Count; i++)
|
|
toReturn[i] = ((System.String) values[i]);
|
|
return toReturn;
|
|
}
|
|
|
|
}
|
|
/// <summary> Determines if this RDN is multivalued or not</summary>
|
|
/// <returns> true if this RDN is multivalued
|
|
/// </returns>
|
|
virtual public bool Multivalued
|
|
{
|
|
get
|
|
{
|
|
return (values.Count > 1)?true:false;
|
|
}
|
|
|
|
}
|
|
private System.Collections.ArrayList types; //list of Type strings
|
|
private System.Collections.ArrayList values; //list of Value strings
|
|
private System.String rawValue; //the unnormalized value
|
|
|
|
/// <summary> Creates an RDN object from the DN component specified in the string RDN
|
|
///
|
|
/// </summary>
|
|
/// <param name="rdn">the DN component
|
|
/// </param>
|
|
public RDN(System.String rdn)
|
|
{
|
|
rawValue = rdn;
|
|
DN dn = new DN(rdn);
|
|
System.Collections.ArrayList rdns = dn.RDNs;
|
|
//there should only be one rdn
|
|
if (rdns.Count != 1)
|
|
throw new System.ArgumentException("Invalid RDN: see API " + "documentation");
|
|
RDN thisRDN = (RDN) (rdns[0]);
|
|
this.types = thisRDN.types;
|
|
this.values = thisRDN.values;
|
|
this.rawValue = thisRDN.rawValue;
|
|
return ;
|
|
}
|
|
|
|
public RDN()
|
|
{
|
|
types = new System.Collections.ArrayList();
|
|
values = new System.Collections.ArrayList();
|
|
rawValue = "";
|
|
return ;
|
|
}
|
|
|
|
/// <summary> Compares the RDN to the rdn passed. Note: If an there exist any
|
|
/// mulivalues in one RDN they must all be present in the other.
|
|
///
|
|
/// </summary>
|
|
/// <param name="rdn">the RDN to compare to
|
|
///
|
|
/// @throws IllegalArgumentException if the application compares a name
|
|
/// with an OID.
|
|
/// </param>
|
|
[CLSCompliantAttribute(false)]
|
|
public virtual bool equals(RDN rdn)
|
|
{
|
|
if (this.values.Count != rdn.values.Count)
|
|
{
|
|
return false;
|
|
}
|
|
int j, i;
|
|
for (i = 0; i < this.values.Count; i++)
|
|
{
|
|
//verify that the current value and type exists in the other list
|
|
j = 0;
|
|
//May need a more intellegent compare
|
|
while (j < values.Count && (!((System.String) this.values[i]).ToUpper().Equals(((System.String) rdn.values[j]).ToUpper()) || !equalAttrType((System.String) this.types[i], (System.String) rdn.types[j])))
|
|
{
|
|
j++;
|
|
}
|
|
if (j >= rdn.values.Count)
|
|
//couldn't find first value
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary> Internal function used by equal to compare Attribute types. Because
|
|
/// attribute types could either be an OID or a name. There needs to be a
|
|
/// Translation mechanism. This function will absract this functionality.
|
|
///
|
|
/// Currently if types differ (Oid and number) then UnsupportedOperation is
|
|
/// thrown, either one or the other must used. In the future an OID to name
|
|
/// translation can be used.
|
|
///
|
|
///
|
|
/// </summary>
|
|
private bool equalAttrType(System.String attr1, System.String attr2)
|
|
{
|
|
if (System.Char.IsDigit(attr1[0]) ^ System.Char.IsDigit(attr2[0]))
|
|
//isDigit tests if it is an OID
|
|
throw new System.ArgumentException("OID numbers are not " + "currently compared to attribute names");
|
|
|
|
return attr1.ToUpper().Equals(attr2.ToUpper());
|
|
}
|
|
|
|
/// <summary> Adds another value to the RDN. Only one attribute type is allowed for
|
|
/// the RDN.
|
|
/// </summary>
|
|
/// <param name="attrType">Attribute type, could be an OID or String
|
|
/// </param>
|
|
/// <param name="attrValue">Attribute Value, must be normalized and escaped
|
|
/// </param>
|
|
/// <param name="rawValue">or text before normalization, can be Null
|
|
/// </param>
|
|
public virtual void add(System.String attrType, System.String attrValue, System.String rawValue)
|
|
{
|
|
types.Add(attrType);
|
|
values.Add(attrValue);
|
|
this.rawValue += rawValue;
|
|
}
|
|
|
|
/// <summary> Creates a string that represents this RDN, according to RFC 2253
|
|
///
|
|
/// </summary>
|
|
/// <returns> An RDN string
|
|
/// </returns>
|
|
public override System.String ToString()
|
|
{
|
|
return toString(false);
|
|
}
|
|
|
|
/// <summary> Creates a string that represents this RDN.
|
|
///
|
|
/// If noTypes is true then Atribute types will be ommited.
|
|
///
|
|
/// </summary>
|
|
/// <param name="noTypes">true if attribute types will be omitted.
|
|
///
|
|
/// </param>
|
|
/// <returns> An RDN string
|
|
/// </returns>
|
|
[CLSCompliantAttribute(false)]
|
|
public virtual System.String toString(bool noTypes)
|
|
{
|
|
int length = types.Count;
|
|
System.String toReturn = "";
|
|
if (length < 1)
|
|
return null;
|
|
if (!noTypes)
|
|
{
|
|
toReturn = types[0] + "=";
|
|
}
|
|
toReturn += values[0];
|
|
|
|
for (int i = 1; i < length; i++)
|
|
{
|
|
toReturn += "+";
|
|
if (!noTypes)
|
|
{
|
|
toReturn += (types[i] + "=");
|
|
}
|
|
toReturn += values[i];
|
|
}
|
|
return toReturn;
|
|
}
|
|
|
|
/// <summary> Returns each multivalued name in the current RDN as an array of Strings.
|
|
///
|
|
/// </summary>
|
|
/// <param name="noTypes">Specifies whether Attribute types are included. The attribute
|
|
/// type names will be ommitted if the parameter noTypes is true.
|
|
///
|
|
/// </param>
|
|
/// <returns> List of multivalued Attributes
|
|
/// </returns>
|
|
public virtual System.String[] explodeRDN(bool noTypes)
|
|
{
|
|
int length = types.Count;
|
|
if (length < 1)
|
|
return null;
|
|
System.String[] toReturn = new System.String[types.Count];
|
|
|
|
if (!noTypes)
|
|
{
|
|
toReturn[0] = types[0] + "=";
|
|
}
|
|
toReturn[0] += values[0];
|
|
|
|
for (int i = 1; i < length; i++)
|
|
{
|
|
if (!noTypes)
|
|
{
|
|
toReturn[i] += (types[i] + "=");
|
|
}
|
|
toReturn[i] += values[i];
|
|
}
|
|
|
|
return toReturn;
|
|
}
|
|
} //end class RDN
|
|
}
|