Logo Search packages:      
Sourcecode: addresses-for-gnustep version File versions  Download package

utils.m

#include "utils.h"
#include <ldap.h>

NSString* authMethodToString(int authMethod)
{
    switch(authMethod)
    {
      case LDAP_AUTH_NONE: return @"NONE";
      case LDAP_AUTH_SIMPLE: return @"SIMPLE";
      case LDAP_AUTH_SASL: return @"SASL";
      case LDAP_AUTH_KRBV4: return @"KRBV4";
      case LDAP_AUTH_KRBV41: return @"KRBV41";
      case LDAP_AUTH_KRBV42: return @"KRBV42";
      default: return @"UNKNOWN";
    }
}

int stringToAuthMethod(NSString* str)
{
    str = [str uppercaseString];
    if([str isEqualToString: @"NONE"]) return LDAP_AUTH_NONE;
    if([str isEqualToString: @"SIMPLE"]) return LDAP_AUTH_SIMPLE;
    if([str isEqualToString: @"SASL"]) return LDAP_AUTH_SASL;
    if([str isEqualToString: @"KRBV4"]) return LDAP_AUTH_KRBV4;
    if([str isEqualToString: @"KRBV41"]) return LDAP_AUTH_KRBV41;
    if([str isEqualToString: @"KRBV42"]) return LDAP_AUTH_KRBV42;
    return -1;
}

NSString* scopeToString(int scope)
{
    switch(scope)
    {
      case LDAP_SCOPE_DEFAULT: return @"DEFAULT";
      case LDAP_SCOPE_BASE: return @"BASE";
      case LDAP_SCOPE_ONELEVEL: return @"ONELEVEL";
      case LDAP_SCOPE_SUBTREE: return @"SUBTREE";
      default: return @"UNKNOWN";
    }
}

int stringToScope(NSString* str)
{
    str = [str uppercaseString];
    if([str isEqualToString: @"DEFAULT"]) return LDAP_SCOPE_DEFAULT;
    if([str isEqualToString: @"BASE"]) return LDAP_SCOPE_BASE;
    if([str isEqualToString: @"ONELEVEL"]) return LDAP_SCOPE_ONELEVEL;
    if([str isEqualToString: @"SUBTREE"]) return LDAP_SCOPE_SUBTREE;
    return -1;
}

NSArray *mapping = NULL;
NSArray *skip = NULL;
@class LDAPAddressBook;

void initMapping(void)
{
    if(!mapping)
    {
      NSBundle *currentBundle; NSString *path; 
      currentBundle = [NSBundle bundleForClass: [LDAPAddressBook class]];
      path = [currentBundle pathForResource: @"LDAPPersonMapping"
                        ofType: @"plist"];
      mapping = [[NSString stringWithContentsOfFile: path] propertyList];
      [mapping retain];
    }
    if(!skip)
    {
      skip = [[NSArray alloc] initWithObjects: @"cn", @"objectClass", NULL];
    }
}

id addressesKeyForLDAPKey(NSString *key)
{
    int i, j;

    if(!mapping) initMapping();

    for(i=0; i<[mapping count]; i++)
    {
      NSArray *arr = [[mapping objectAtIndex: i] 
                     objectForKey: @"LDAPKeys"];
      for(j=0; j<[arr count]; j++)
          if([[arr objectAtIndex: j] caseInsensitiveCompare: key] == 
             NSOrderedSame)
            return [[mapping objectAtIndex: i] 
                     objectForKey: @"AddressesKey"];
    }

    return nil;
}
                   

ADPerson* ldapEntryToPerson(GSLDAPEntry* entry)
{
    ADPerson *p; NSEnumerator *nameE; NSString *name;

    p = [[[ADPerson alloc] init] autorelease];
    nameE = [entry attributeNameEnumerator];
    while((name = [nameE nextObject]))
    {
      NSArray *val; id addrKey; int i;
      NSString *property = nil, *label = nil, *key = nil;
      ADPropertyType type;

      if([skip containsObject: name]) continue;

      val = [entry valuesForAttributeNamed: name];
      addrKey = addressesKeyForLDAPKey(name);

      if(!addrKey)
      {
          NSLog(@"Can't handle LDAP key %@ yet\n", name);
          continue;
      }

      if([addrKey isEqualToString: @"Skip"])
          continue;

      if([addrKey isKindOfClass: [NSString class]])
          property = addrKey;
      else
      {
          property = [addrKey objectForKey: @"Property"];
          label = [addrKey objectForKey: @"Label"];
          key = [addrKey objectForKey: @"Key"];
      }

      type = [[ADPerson class] typeOfProperty: property];
      if(!type)
      {
          NSLog(@"Error in Property %@ for %@\n",
              property, name);
          continue;
      }

      // string? set it directly
      if(type == ADStringProperty)
      {
          [p setValue: [val objectAtIndex: 0]
             forProperty: property];
          continue;
      }
         
      // multi-value, but not multi-dictionary
      else if(type == ADMultiStringProperty)
      {
          ADMultiValue *v; ADMutableMultiValue *mv;

          v = [p valueForProperty: property];
          if(!v)
            mv = [[[ADMutableMultiValue alloc] init] autorelease];
          else
            mv = [v mutableCopy];
          
          for(i=0; i<[val count]; i++)
            [mv addValue: [val objectAtIndex: i]
                withLabel: label];

          [p setValue: [[[ADMultiValue alloc] initWithMultiValue: mv]
                       autorelease]
             forProperty: property];
      }
      
      else if(type == ADMultiDictionaryProperty)
      {
          ADMultiValue *v; ADMutableMultiValue *mv;
          NSDictionary *d; NSMutableDictionary *md;
          int index; BOOL have;

          v = [p valueForProperty: property];
          if(!v)
            mv = [[[ADMutableMultiValue alloc] init] autorelease];
          else
            mv = [v mutableCopy];
          
          d = nil; have = NO;
          for(index=0; index<[mv count]; index++)
            if([[mv labelAtIndex: index] isEqualToString: label])
            {
                have = YES;
                d = [mv valueAtIndex: index];
                break;
            }

          if(!d) md = [NSMutableDictionary dictionary];
          else md = [[[NSMutableDictionary alloc] initWithDictionary: d]
                    autorelease];

          [md setObject: [val objectAtIndex: 0] forKey: key];
          
          if(have)
            [mv replaceValueAtIndex: index
                withValue: [NSDictionary dictionaryWithDictionary: md]];
          else
            [mv addValue: [NSDictionary dictionaryWithDictionary: md]
                withLabel: label];

          [p setValue: [[[ADMultiValue alloc] initWithMultiValue: mv]
                       autorelease]
             forProperty: property];
      }

      else
      {
          NSLog(@"Can't handle values of type %d yet\n", type);
      }
    }

    return p;
}

GSLDAPEntry* personToLDAPEntry(ADPerson* person)
{
    return nil;
}

Generated by  Doxygen 1.6.0   Back to index