Mail::Addressbook::Convert::Ldif - convert to and from Ldif formatted addressbooks

			The addressbook format that is used as an intermediate
			between conversions.  It is rfc822 compliant and can
			be used directly as a Eudora addressbook.  Do not use
			a Eudora addressbook as an STF. Some versions of 
			Eudora use a format, that while RFC822 compliant, will
			not work as an STF. Run the Eudora addressbook
			through $Eudora->scan()

#------------------------------------------------------------------------------

use strict;


package Mail::Addressbook::Convert::Ldif;

use Mail::Addressbook::Convert::PersistentUtilities;
use Mail::Addressbook::Convert::Utilities;
use  5.001;

sub new {
	bless {},shift;
}

######################################################################


sub scan {

my $Ldif = shift;
my $inputParm = shift; # reference to input ldif data as an array or reference to a 
			# scalar containing the name of a file containing the ldif.
			
my $perUtil = new Mail::Addressbook::Convert::PersistentUtilities();

my $raLdifArray= getInput($inputParm);
#NOTE
# This method has been modified and never cleaned up
# There may be some sections of code which are either never
# executed, or irrelevant to the output.
#As it stands, it can process ldif output from Netscape Communicator
# and the Netscape LDAP server
# jhd 19980925




my ($alias, $fullName, $outLine, %aliasOf, @outputFile);

push (@$raLdifArray,"dn:\n\n");  #put final dn: line  in for processing purposes
	# as "dn:" acts as an end of record marker in this code

my (%group,$address);
foreach my $i (@$raLdifArray)
	{
	my ($temp,$isGroup, $xalias) ;
	$i =~ s/[\x88\xa9\xd8]//g; 
	$i =~ s/[\x7e-\xff]//g; 
	if ($i =~ /^objectclass: groupOfNames|^objectclass: groupOfUniqueNames/)
		{
		$isGroup = 1;
		}
	if ($i =~ /^objectclass: person/)
		{
		$isGroup = 0;
		}
	if ($i =~ /^xnavnickname:|^xmozillanickname:/)
		{
		($temp,$xalias) = split(/\:/,$i);
		chomp $xalias;
		$xalias =~ s/\s+//g;
		}
	if ($i =~ /^mail\:/)
		{
		$i =~ s/:\s+/:/;
		($temp,$address) = split(/\:/,$i);
		chomp $address;
		$address =~ s/\s+//g;
		}
	if ($i =~ /^member\:|^uniquemember\:/)
		{
		my ($rm, $rawMember);
		$i =~ s/:\s+/:/;
		($temp, $rawMember) = split(/\:/,$i);
		chomp $rawMember;
		if ($rawMember =~ /,mail=/)
			{
			($a,$rm) = split(/\,mail=/,$rawMember)
			#($a,$rawMember) = split(/\,mail=/,$rawMember)
			}
		else
			{
			($a,$rm) = split(/cn=/,$rawMember)
			}
		$rawMember = (split(",",$rm))[0];
		$rawMember =~ tr/A-Z/a-z/;
		$rawMember =~  s/ /_/g;
		if ($aliasOf{$rawMember})
			{
			$rawMember = $aliasOf{$rawMember};
			}
		$group{$alias} .=$rawMember.',';
		$group{$alias} =~  s/\n|\r//g;

		}
	if ($i =~ /^dn/)
		{
		$i =~ s/:\s+/:/;
		($temp,$fullName) = split(/\:/,$i);
		$fullName = (split(",",$fullName))[0];
		{local $^W;
			$fullName =~ s/cn=//;
			$fullName =~ s/"//g;
			chomp $fullName;
			$alias = $fullName;
			$alias =~ s/ /_/g ;
		}
		

		}
	if ($i !~ /\S/)
		{ local $^W;
		my ($outline);

		if(!$isGroup and $alias)
			{
			$alias = $xalias if $xalias;
			$alias = $perUtil->makeAliasUnique($alias,"_");
			$aliasOf{$address} = $alias;
			
			if ($fullName !~ /@/)
				{
				$outLine = qq(alias $alias "$fullName"<$address>);
				}
			else
				{
				$outLine = qq(alias $alias $address);
				}
			$outLine =~ s/\n|\r|\015//g;
			push (@outputFile, $outLine."\n");
			undef $address;
			undef $outline;
			undef $alias;
			undef $xalias;
			undef $fullName;
			}
		}
	} #end of input array
foreach my $key (sort keys %group)
	{
	my $mems = $group{$key};
	chop $mems;
	my $hold =  "alias $key  $mems";
	$hold =~  s/\n|\r//g;
	push (@outputFile,
	"$hold\n");

	}
return \@outputFile;
}


###########################   sub output #######################
sub output

{

my (@outputFile, $alias1,);

my $Ldif = shift;
my $raInputArray = shift; # reference to input Input data as an array



my $id = 0;    my $k=0; my $numberOfGroups=0;

my ($aliasold, %aliasid, %note, $firstName, $lastName, $name, $address, @groupaddr);
my (@indivname, @indivaddr, @indivalias, @groupalias, %indivnameForLists);
my (%indivaddrForLists,  %isGroup, $aliasid1 , @groupmembers);

foreach (@$raInputArray )
	{
	my @line = split(" ",$_,3);
	my $alias= $line[1];
	$aliasold = $alias;
      	$alias = &cleanalias($aliasold);
	my $rest = $line[2];
	my $rest1 = $rest;
	if ($aliasid{$alias} && ($line[0] ne "note") )  
			# this alias alrady exists
		{
		
		}
		
	 else # unique alias, process the data	
		{
		
		my %aliasid;
		if ($line[0] eq "alias") # This is an alias line
			{
			$id++;	
			$aliasid{$alias} = $id;
			my $commas_outside_quotes1 = &commas_outside_quotes($rest);
			if ($commas_outside_quotes1)
				{
		 		# There are commas not enclosed in quotes
				#we have a group list.
                        $isGroup{$alias} = 1;
				$groupalias[$numberOfGroups] = $alias;
				$groupaddr[$numberOfGroups] = $rest;
             	      $groupaddr[$numberOfGroups] =~ s/\s*//g; # get rid of all spaces
				$numberOfGroups++;
				}
			else # we have an individual address
				{
				$indivalias[$k] = $alias;
				if ( $rest =~ /</) 
				# compound address of form Name<Address>
					{
					($name,$address) = split(/</,$rest);
					chop ($address);
					$address  =~s/>*//g; 
					$name =~ s/\"//g;
					$name =~ s/\'//g;
					$indivname[$k] = $name;
					#$holdname{$alias} = $name;
					$rest = $address;
					}
				elsif ( $rest =~ /\(/) 
				# compound address of form Address(Name)
					{
					($address,$name) = split(/\(/,$rest);
					$name  =~s/\)*//g; 
					$name =~ s/\"//g;
					$name =~ s/\'//g;
					chomp($name);
					chop($address);
					$indivname[$k] = $name;
					#$holdname{$alias} = $name;
					$rest = $address;
					}
				else # no name give, use the alias as a name
					{
					$indivname[$k] = $alias;
					}
				$indivaddr[$k] = $rest;
				$indivaddrForLists{$alias} = $indivaddr[$k] ;
				$indivnameForLists{$alias} = $indivname[$k] ;
				$k++;
				}
			}	
			else  #we have a note
				{
				$note{$alias} = $rest1;
				}
		} # end of processing addresses
	}
# Write individual alias section

foreach my $kk (0 .. $k-1)
	{
	  my @hold;
	  $alias1 = $indivalias[$kk];	
	if ($note{$alias1})
		{
		if ($note{$alias1} =~ /name:(.+)>/)
			{
			@hold = split(/>/,$1);
			$indivname[$kk] = $hold[0]
				if length($hold[0]) =~ /\S/;
			}
		}
	@hold = split(" ",$indivname[$kk]);
	$lastName = pop(@hold);
	$firstName = join(" ",@hold);
	push (@outputFile,"\ndn: cn=$indivname[$kk],mail=$indivaddr[$kk]\n");
	push (@outputFile,"cn: $indivname[$kk]\n");
	push (@outputFile,"sn: $lastName\n");
	push (@outputFile,"objectclass: top\n");
	push (@outputFile,"objectclass: person\n");
	push (@outputFile,"mail: $indivaddr[$kk]\n");
	push (@outputFile,"givenname: $firstName\n");
	push (@outputFile,"uid: $alias1\n");
	push (@outputFile,"xnavnickname: $alias1\n");
	push (@outputFile,"xmozillanickname: $alias1\n");
	if ($note{$alias1})
		{
		push (@outputFile,"description: $note{$alias1}\n");
		if ($note{$alias1} =~ /phone:(.+)>/)
			{
			@hold = split(/>/,$1);
			push (@outputFile,
				"telephonenumber: $hold[0]\n");
			}
		}
		if ($note{$alias1} and $note{$alias1} =~ /fax:(.+)>/)
			{
			@hold = split(/>/,$1);
			push (@outputFile,
				"facsimiletelephonenumber: $hold[0]\n");
			}
		if ($note{$alias1} and $note{$alias1} =~ /Home phone.+:(.+)/)
			{
			@hold = split(/</,$1);
			$hold[0] =~ s/^\s+//;
			push (@outputFile,
				"homephone: $hold[0]\n");
			}
	

	
	}


# Write group lists section
foreach my $jj (0 .. $numberOfGroups -1)
	{
	  $alias1 = $groupalias[$jj];


	push (@outputFile,"\ndn: cn=$alias1\n");
	push (@outputFile,"cn: $alias1\n");
	push (@outputFile,"objectclass: top\n");
	push (@outputFile,"objectclass: groupOfNames\n");
	push (@outputFile,"uid: $alias1\n");
	push (@outputFile,"xnavnickname: $alias1\n");
		
      @groupmembers = split(",",$groupaddr[$jj]);
      my $localalias;
	for (@groupmembers)
		{
		if (!/\@/) #  We do not have an internet address as a group member
			{
			$localalias = &cleanalias($_);
			}
		else   #  We have a internet address -- do not modify
				# This makes the error message clearer
			{
			$localalias = $_;
			}

		if ($aliasid{$localalias}) # alias exists
			{
	  		$aliasid1 = $aliasid{$localalias};
			if ($isGroup{$localalias}) #The alias belongs
							   # to a group
				{	
				 push (@outputFile, "member: cn=$localalias\n");
				}
			else     #An individual alias
				{
			
				push (@outputFile, 
				"member: cn=$indivnameForLists{$localalias},mail=$indivaddrForLists{$localalias}\n");				
				
				}
			
			}
		
		}



	}

return \@outputFile;
}



###########################  end sub output #######################
1;