ZConf::Mail - Misc mail client functions backed by ZConf.

    use ZConf::Mail;

    my $zcmail = ZConf::Mail->new();
    ...

    if($zcmail->accountExists('pop3/foo)){
        print "pop3/foo does exist";
    }

    #connects to the IMAP account 'imap/foo'
    my $imap=$zcmail->connectIMAP('imap/foo');
    if($zcmail->{error})(
        print "Error!";
    )

    #connects to the maildir account 'maildir/foo'
    my $imap=$zcmail->connectMaildir('maildir/foo');
    if($zcmail->{error})(
        print "Error!";
    )

    #connects to the mbox account 'mbox/foo'
    my $imap=$zcmail->connectMbox('mbox/foo');
    if($zcmail->{error})(
        print "Error!";
    )

    #connects to the mbox account 'pop3/foo'
    my $imap=$zcmail->connectPOP3('pop3/foo');
    if($zcmail->{error})(
        print "Error!";
    )

    #connects to the SMTP account 'smtp/foo'
    my $imap=$zcmail->connectSMTP('smtp/foo');
    if($zcmail->{error})(
        print "Error!";
    )

    #adds a POP3 server
    $zcmail->createAccount({type=>'pop3',
                            account=>'some account name',
                            user=>'monkey',
                            pass=>'ape',
                            auth=>'auto',
                            useSSL=>'0',
                            SSLoptions=>'',
                            deliverTo=>'',
                            fetchable=>'0',
                            server=>'127.0.0.1',
                            })

    account
    subject
    body

    my $defaultFetchable=$zcmail->defaultFetchableGet;
    if(!defined($defaultFetchable)){
        print "There is no default sendable account.\n";
    }

    print $defaultFetchable."\n";

    $zcmail->defaultFechableSet('smtp/foo');
    if($zcmail->{error}){
        print "Error!\n";
    }

    my $defaultSendable=$zcmail->defaultSendableGet;
    if(!defined($defaultSendable)){
        print "There is no default sendable account.\n";
    }

    print $defaultSendable."\n";

    $zcmail->defaultSendableSet('smtp/foo');
    if($zcmail->{error}){
        print "Error!\n";
    }

   #removes the account 'mbox/foo'
   $zcmail->delAccount('mbox/foo');
   if($zcmail->{error}){
       print "ERROR!";
   }

    #check to see if the account is a account that can be delivered to
    if(!zcmail->deliverable('exec/foo')){
        print "Not deliverable.";
    }

    #delivers the mail contained in $mail to 'exec/foo'
    $zcmail->deliver('exec/foo', $mail);
    if($zcmail->{error}){
        print "deliver error";
    }

    #delivers the mail contained in $mail to 'imap/foo' to the 'foo.bar'
    $zcmail->deliver('imap/foo', $mail, {folder=>'foo.bar'});
    if($zcmail->{error}){
        print "deliver error";
    }

    #delivers the mail contained in $mail to 'exec/foo'
    $zcmail->deliverExec('exec/foo', $mail);
    if($zcmail->{error}){
        print "deliver error";
    }

    #delivers the mail contained in $mail to 'imap/foo' to the inbox
    $zcmail->deliverIMAP('imap/foo', $mail);
    if($zcmail->{error}){
        print "deliver error";
    }

    #delivers the mail contained in $mail to 'imap/foo' to the 'foo.bar'
    $zcmail->deliverIMAP('imap/foo', $mail, {folder=>'foo.bar'});
    if($zcmail->{error}){
        print "deliver error";
    }

    #fetches the mail for 'pop3/foo'
    $zcmail->fetch('pop3/foo');
    if($zcmail->{error}){
        print "error";
    }

    my $number=$mail->fetchIMAP('imap/foo');
    if($mail->{error}}){
        print "Error!";
    }else{
        print 'Fetched '.$number."messages.\n";
    }

    my $number=$mail->fetchMaildir('maildir/foo');
    if($mail->{error}}){
        print "Error!";
    }else{
        print 'Fetched '.$number."messages.\n";
    }

    my $number=$mail->fetchMbox('mbox/foo');
    if($mail->{error}}){
        print "Error!";
    }else{
        print 'Fetched '.$number."messages.\n";
    }

    my $number=$mail->fetchPOP3('pop3/foo');
    if($mail->{error}}){
        print "Error!";
    }else{
        print 'Fetched '.$number."messages.\n";
    }

    my @accounts=$zcmail->getAccounts;
    if($zcmail->{error}){
        print 'error';
    }

    #get the account args for 'pop3/foo'
    my %args=$zcmail->getAccountArgs('pop3/foo');
    if($zcmail->{error}){
        print "error!\n";
    }

    my $set=$zcmail->getSet;
    if($zcmail->{error}){
        print "Error!\n";
    }

    $zcmail->init;
    if($zcmail->{error}){
        print 'error';
    }

    my @sets=$zcmail->listSets;
    if($zcmail->{error}){
        print "Error!";
    }

    #read the default set
    $zcmail->readSet();
    if($zcmail->{error}){
        print "Error!\n";
    }

    #read the set 'someSet'
    $zcmail->readSet('someSet');
    if($zcmail->{error}){
        print "Error!\n";
    }

    #checks to see if 'smtp/foo' is sendable
    if(!$zcmail->sendable('smtp/foo')){
        print 'not sendable'
    }

    $self->{error}=undef;
    $self->{errorString}="";

        undef
        /\//
        /^\./
        /^ /
        / $/
        /\.\./

    perldoc ZConf::Mail

package ZConf::Mail;

use Email::Simple;
use Email::Simple::Creator;
use Mail::IMAPTalk;
use Mail::POP3Client;
use Net::SMTP_auth;
use Net::SMTP::TLS;
use Mail::Box::Manager;
use IO::MultiPipe;
use ZConf;
use warnings;
use strict;
use MIME::Lite;
use File::MimeInfo::Magic;
use Email::Date;
use Sys::Hostname;
use MIME::QuotedPrint;
use Text::Autoformat;

our $VERSION = '1.4.1';

sub new {
	my %args;
	if(defined($_[1])){
		%args= %{$_[1]};
	}
	
	my $self={error=>undef, set=>undef};
	bless $self;

	#this is done to keep from throwing an error when we try to pass it to ZConf->new
	if (!defined($args{zconf})) {
		$args{zconf}={};
	}

	$self->{zconf}=ZConf->new(%{$args{zconf}});
	if(defined($self->{zconf}->{error})){
		warn("ZConf-Cron new:1: Could not initiate ZConf. It failed with '"
			 .$self->{zconf}->{error}."', '".$self->{zconf}->{errorString}."'");
		$self->{error}=1;
		return $self;
	}

	#sets $self->{init} to a Perl boolean value...
	#true=config does exist
	#false=config does not exist
	$self->{init}=undef;
	if ($self->{zconf}->configExists('mail')){
		$self->{init}=1;
		$self->{zconf}->read({config=>'mail'});
		if (defined($self->{zconf}->{error})) {
			warn('ZConf-Mail new:18: Failed to read the ZConf config "mail"');
			$self->{error}=18;
			$self->{errorString}='Failed to read the ZConf config "mail"';
			return undef;
		}
	}

	#this defines legal values for later use
	$self->{legal}{pop3}=['user', 'pass', 'auth', 'useSSL',
						  'deliverTo', 'deliverToFolder', 'fetchable',
						  'server', 'port'];
	$self->{legal}{imap}=['user', 'pass', 'useSSL','deliverTo', 'deliverToFolder',
						  'fetchable', 'inbox', 'server', 'port', 'timeout'];
	$self->{legal}{mbox}=['mbox', 'deliverTo', 'deliverToFolder', 'fetchable'];
	$self->{legal}{smtp}=['user', 'pass', 'auth', 'useSSL',
						  'server', 'port', 'name', 'from',
						  'name', 'timeout', 'saveTo', 'saveToFolder', 
						  'usePGP', 'pgpType', 'PGPkey', 'PGPdigestAlgo'];
	$self->{legal}{maildir}=['maildir','deliverTo', 'deliverToFolder', 'fetchable'];
	$self->{legal}{exec}=['deliver'];

	#this defines the required values for later use
	$self->{required}{pop3}=['user', 'pass', 'auth', 'useSSL',
						  'deliverTo', 'fetchable', 'server', 'port'];
	$self->{required}{imap}=['user', 'pass', 'useSSL',
						  'fetchable', 'inbox', 'server', 'port'];
	$self->{required}{mbox}=['mbox', 'deliverTo', 'fetchable'];
	$self->{required}{smtp}=['user', 'pass', 'auth', 'useSSL',
							 'server', 'port', 'name', 'from',
							 'name', 'timeout', 'saveTo'];
	$self->{required}{maildir}=['maildir','deliverTo', 'fetchable'];
	$self->{required}{exec}=['deliver'];

	#This contains a list of account types that are fetchable.
	$self->{fetchable}=['pop3', 'imap', 'maildir', 'mbox'];

	#This contains a list of account types that are deliverable.
	$self->{deliverable}=['exec','imap'];

	#This contains a list of account types that are sendable.
	#Listed for possible future purposes.
	$self->{sendable}=['smtp'];

	return $self;
}

sub accountExists{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that. It also makes sure that
	#nothing past the account name is refered to.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail accountExists:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#searches and finds any variables for the account
	my @matched=$self->{zconf}->regexVarSearch('mail', '^accounts/'.$account.'/');

	#If no variables are found, we can assume that it does not exist.
	if (!defined($matched[0])) {
		return undef;
	}

	return 1;
}

sub connectIMAP{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail connectIMAP:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
		return undef;;
	}

	#No need to verify the account exists as $self->getsAccountArgs will do that.

	#gets the account variables
	my %avars=$self->getAccountArgs($account);

	#checks to make sure all the required variables are present
	my $requiredInt=0;
	while (defined($self->{required}{$split[0]}[$requiredInt])) {
		if (!defined($avars{$self->{required}{imap}[$requiredInt]})) {
			warn('ZConf-Mail connectIMAP:32: "'.$self->{required}{$split[0]}[$requiredInt].
				 '" is undefined for the account "'.$account.'"');
			$self->{error}=32;
			$self->{errorString}='"'.$self->{required}{$split[0]}[$requiredInt].
			                     '" is undefined for the account "'.$account.'"';
			return undef;
		}
		$requiredInt++;
	}

	#created outside of the SSL if statement to allow it to be exported SSL if statement
	my $imap;

	if (!$avars{useSSL}) {
		$imap=Mail::IMAPTalk->new(Server=>$avars{server},
								  Username=>$avars{user},
								  Password=>$avars{pass},
								  Uid=>0);
	}else {
		#creates the socket that will be used connect to IMAP
		my $socket=IO::Socket::SSL->new(PeerAddr=>$avars{server},
										PeerPort=>$avars{port},
										Proto=>'tcp');

		#creates the IMAP connection use to previously created socket
		$imap=Mail::IMAPTalk->new(Socket=>$socket,
								  Username=>$avars{user},
								  Password=>$avars{pass},
								  Uid=>0);		
	}

	#checks to see if it connected or not
	if (!$imap) {
		warn('ZConf-Mail connectIMAP:9: Failed to connect to IMAP server or authenticate');
		$self->{error}=9;
		$self->{errorString}='Failed to connect to IMAP server or authenticate';
		return undef;
	}

	return $imap;
}

sub connectMaildir{
	my $self=$_[0];
	my $account=$_[1];

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail connectMaildir:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#No need to verify the account exists as $self->getsAccountArgs will do that.

	#gets the account variables
	my %avars=$self->getsAccontArgs($account);

	#checks to make sure all the required variables are present
	my $requiredInt=0;
	while (defined($self->{required}{$split[0]}[$requiredInt])) {
		if (!defined($avars{$self->{required}{maildir}[$requiredInt]})) {
			warn('ZConf-Mail connectMaildir:32: "'.$self->{required}{$split[0]}[$requiredInt].
				 '" is undefined for the account "'.$account.'"');
			$self->{error}=32;
			$self->{errorString}='"'.$self->{required}{$split[0]}[$requiredInt].
			                     '" is undefined for the account "'.$account.'"';
			return undef;
		}
		$requiredInt++;
	}

	my $mgr=Mail::Box::Manager->new;
	my $maildir=$mgr->open(folder=>$avars{maildir}, access=>'rw', lock_file=>'NONE');

	#checks for an error
	if (!$maildir) {
		warn('ZConf-Maildir connectMaildir:14: Failed to access the maildir, "'
			 .$avars{maildir}.'"');
		$self->{error}=14;
		$self->{errorString}='Failed to access the maildir, "'.$avars{maildir}.'"';
	}

	return $maildir;
}

sub connectMbox{
	my $self=$_[0];
	my $account=$_[1];

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail connectMbox:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#No need to verify the account exists as $self->getsAccountArgs will do that.

	#gets the account variables
	my %avars=$self->getAccountArgs($account);

	#checks to make sure all the required variables are present
	my $requiredInt=0;
	while (defined($self->{required}{$split[0]}[$requiredInt])) {
		if (!defined($avars{$self->{required}{mbox}[$requiredInt]})) {
			warn('ZConf-Mail connectMbox:32: "'.$self->{required}{$split[0]}[$requiredInt].
				 '" is undefined for the account "'.$account.'"');
			$self->{error}=32;
			$self->{errorString}='"'.$self->{required}{$split[0]}[$requiredInt].
			                     '" is undefined for the account "'.$account.'"';
			return undef;
		}
		$requiredInt++;
	}

	my $mgr=Mail::Box::Manager->new;
	my $mbox=$mgr->open(folder=>$avars{mbox}, access=>'rw', lock_file=>'NONE');

	#checks for an error
	if (!$mbox) {
		warn('ZConf-Maildir connectMbox:14: Failed to access the mbox, "'
			 .$avars{mbox}.'"');
		$self->{error}=14;
		$self->{errorString}='Failed to access the mbox, "'.$avars{mbox}.'"';
	}

	return $mbox;
}

sub connectPOP3{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail connectPOP3:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#No need to verify the account exists as $self->getsAccountArgs will do that.

	#gets the account variables
	my %avars=$self->getAccountArgs($account);

	#checks to make sure all the required variables are present
	my $requiredInt=0;
	while (defined($self->{required}{$split[0]}[$requiredInt])) {
		if (!defined($avars{$self->{required}{pop3}[$requiredInt]})) {
			warn('ZConf-Mail connectPOP3:32: "'.$self->{required}{$split[0]}[$requiredInt].
				 '" is undefined for the account "'.$account.'"');
			$self->{error}=32;
			$self->{errorString}='"'.$self->{required}{$split[0]}[$requiredInt].
			                     '" is undefined for the account "'.$account.'"';
			return undef;
		}
		$requiredInt++;
	}

	#creates the connection
	my $pop = new Mail::POP3Client( USER=>$avars{user},
									PASSWORD=>$avars{pass},
									HOST=>$avars{server},
									PORT=>$avars{port},
									USESSL=>$avars{useSSL},
									AUTH_MODE=>$avars{auth}
								   );

	#If the state is equal to authorization it means we did not authenticate properly.
	if ($pop->State eq 'AUTHORIZATION') {
		warn('ZConf-Mail connectPOP3:7: Failed to authenticate with the server.'.
			 ' Mail::POP3Client->State="'.$pop->State.'"'.
			 ' Mail::POP3Client->Message returned "'.$pop->Message.'"');
		$self->{error}=7;
		$self->{errorString}='Failed to authenticate with the server.'.
                   			 ' Mail::POP3Client->State="'.$pop->State.'"'.
		                     ' Mail::POP3Client->Message returned "'.$pop->Message.'"';
		return undef;
	}

	#If the state is it means it failed to connect to the server.
	if ($pop->State eq 'DEAD') {
		warn('ZConf-Mail connectPOP3:8: Failed to connect to the server.'.
			 ' Mail::POP3Client->State="'.$pop->State.'"'.
			 ' Mail::POP3Client->Message="'.$pop->Message.'"');
		$self->{error}=8;
		$self->{errorString}='Failed to connect to the server.'.
                   			 ' Mail::POP3Client->State="'.$pop->State.'"'.
		                     ' Mail::POP3Client->Message returned "'.$pop->Message.'"';
		return undef;
	}

	return $pop;
}

sub connectSMTP{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail connectSMTP:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#No need to verify the account exists as $self->getsAccountArgs will do that.

	#gets the account variables
	my %avars=$self->getAccountArgs($account);

	#checks to make sure all the required variables are present
	my $requiredInt=0;
	while (defined($self->{required}{$split[0]}[$requiredInt])) {
		if (!defined($avars{$self->{required}{smtp}[$requiredInt]})) {
			warn('ZConf-Mail connectSMTP:32: "'.$self->{required}{$split[0]}[$requiredInt].
				 '" is undefined for the account "'.$account.'"');
			$self->{error}=32;
			$self->{errorString}='"'.$self->{required}{$split[0]}[$requiredInt].
			                     '" is undefined for the account "'.$account.'"';
			return undef;
		}
		$requiredInt++;
	}

	#created outside of the SSL if statement to allow it to be exported SSL if statement
	my $smtp;

	#Unfortunately the error checking can't be moved out from this if statement
	#as Net::SMTP_auth and Net::SMTP::TLS both work a little different in regards
	#authentication.
	if ($avars{useSSL}) {
		my $smtp=Net::SMTP::TLS->new($avars{server},
									 Port=>$avars{port},
									 User=>$avars{user},
									 Password=>$avars{pass},
									 Timeout=>$avars{timeout});
		if (!$smtp) {
			warn('ZConf-Mail connectSMTP:13: Failed to connect to SMTP server or authenticate');
			$self->{error}=13;
			$self->{errorString}='Failed to connect to SMTP server';
			return undef;
		}
	}else {
		$smtp=Net::SMTP_auth->new($avars{server}.':'.$avars{port}, Timeout=>$avars{timeout});

		#error it it did not connect
		if (!defined($smtp)) {
			warn('ZConf-Mail connectSMTP:10: Failed to connect to SMTP server, "'
				 .$avars{server}.':'.$avars{port}.'"');
			$self->{error}=10;
			$self->{errorString}='Failed to connect to SMTP server, "'
			                     .$avars{server}.':'.$avars{port}.'"';
			return undef;
		}

		#authenticate and error if it does not
		if (!$smtp->auth($avars{auth}, $avars{user}, $avars{pass})){
			warn('ZConf-Mail connectSMTP:11: Failed to authenticate with the SMTP server');
			$self->{error}=11;
			$self->{errorString}='Failed to authenticate with the SMTP server.';
			return undef;
		}
	}

	#sends the from information
	if (!$smtp->mail($avars{from})){
		warn('ZConf-Mail connectSMTP:12: Failed to connect to SMTP server');
		$self->{error}=12;
		$self->{errorString}='Failed to connect to SMTP server';
		return undef
	}

	return $smtp;
}

sub createAccount{
	my $self=$_[0];
	my %args;
	if(defined($_[1])){
		%args= %{$_[1]};
	}

	$self->errorBlank;

	#make sure the type is defined
	if (!defined($args{type})) {
		warn('ZConf-Mail createAccount:2: $args{type} is undefined');
		$self->{error}='2';
		$self->{errorString}='$args{type} is undefined';
		return undef;
	}

	#make sure it is a known type
	if (!defined($self->{required}{$args{type}})) {
		warn('ZConf-Mail createAccount:3: $args{type}, "'.$args{type}.'", not a valid value');
		$self->{error}='3';
		$self->{errorString}='$args{type}, "'.$args{type}.'", not a valid value';
		return undef;
	}

	#make sure it is a legit account name
	if (!$self->{zconf}->setNameLegit($args{account})){
		warn('ZConf-Mail createAccount:4: $args{account}, "'.$args{account}.'", not a legit account name');
		$self->{error}='3';
		$self->{errorString}='$args{account}, "'.$args{account}.'", not a legit account name';
		return undef;
	}

	#makes sure they are all defined
	my $requiredInt=0;
	while (defined($self->{required}{$args{type}}[$requiredInt])) {
		#make sure it is defined
		if (!defined($args{$self->{required}{$args{type}}[$requiredInt]})) {
			warn('ZConf-Mail createAccount:4: $args{'.$self->{required}{$args{type}}[$requiredInt].' is not defined');
			$self->{error}='3';
			$self->{errorString}='$args{'.$self->{required}{$args{type}}[$requiredInt].' is not defined';
			return undef;
		}

		$requiredInt++;
	}

	#adds them
	$requiredInt=0;
	while (defined($self->{required}{$args{type}}[$requiredInt])) {
		my $variable='accounts/'.$args{type}.'/'.$args{account}.'/'.$self->{required}{$args{type}}[$requiredInt];
		
		#sets the value
		#not doing any error checking as there is no reason to believe it will fail
		$self->{zconf}->setVar('mail', $variable, $args{$self->{required}{$args{type}}[$requiredInt]});

		$requiredInt++;
	}

	#saves it
	$self->{zconf}->writeSetFromLoadedConfig({config=>'mail'});
	if ($self->{zconf}->{error}) {
		warn('ZConf-Mail createAccount:36: ZConf failed to write the set out');
		$self->{error}=36;
		$self->{errorString}='ZConf failed to write the set out.';
		return undef;
	}

	return 1;
}

sub createEmailSimple{
	my $self=$_[0];
	my %args;
	if(defined($_[1])){
		%args= %{$_[1]};
	}

	$self->errorBlank;

	if (!defined($args{account})) {
		$args{account}=$self->defaultSendableGet;
	}

	#makes sure the args for the account, subject, and body are defined
	if (!defined($args{account}) || (!defined($args{subject}) || !defined($args{body}))) {
		warn('ZConf-Mail createEmailSimple:5: A required hash arguement was not defined' );
		$self->{error}='5';
		$self->{errorString}='A required hash arguement was not defined.';
		return undef;
	}

	my %Aargs=$self->getAccountArgs($args{account});
	if ($self->{error}) {
		warn('ZConf-Mail createEmailSimpe: getAccountArgs errors');
		return undef;
	}
	
	#makes sure that either to or cc is given
	if (!defined($args{cc}) && !defined($args{to})) {
		warn('ZConf-Mail createEmailSimple:5: Neither to or cc given' );
		$self->{error}=5;
		$self->{errorString}='Neither to or cc given.';
		return undef;
	}

	my $mail=Email::Simple->create(header=>[Subject=>$args{subject}], body=>$args{body});

	if (!$mail) {
		warn('ZConf-Mail createEmailSimple:31: Failed to create an Email::Simple object');
		$self->{error}=31;
		$self->{errorString}='Failed to create an Email::Simple object.';
		return undef;
	}

	#process the to stuff
	if (defined($args{to})){
		my $to=join(', ', @{$args{to}});
		$mail->header_set('To'=>$to);
	}

	#process the cc stuff
	if (defined($args{cc}[0])){
		my $to=join(', ', @{$args{cc}});
		$mail->header_set('CC'=>$to);
	}

	my $shost=hostname;
	$shost=~s/\..*//g;
	$mail->header_set('Message-ID'=>'<'.rand().'.'.time().'.ZConf::Mail'.'@'.$shost.'>');

	$mail->header_set('Subject'=>$args{subject});

	$mail->header_set('From'=>$Aargs{name}.' <'.$Aargs{from}.'>');

	return $mail;
}

sub createMimeLite{
	my $self=$_[0];
	my %args;
	if(defined($_[1])){
		%args= %{$_[1]};
	}

	$self->errorBlank;

	if (!defined($args{account})) {
		$args{account}=$self->defaultSendableGet;
	}

	#makes sure the args for the account, subject, and body are defined
	if (!defined($args{account}) || (!defined($args{subject}) || !defined($args{body}))) {
		warn('ZConf-Mail createMimeLite:5: A required hash arguement was not defined' );
		$self->{error}='5';
		$self->{errorString}='A required hash arguement was not defined.';
		return undef;
	}

	my %Aargs=$self->getAccountArgs($args{account});
	if ($self->{error}) {
		warn('ZConf-Mail createEmailSimpe: getAccountArgs errors');
		return undef;
	}

	#makes sure that either to or cc is given
	if (!defined($args{cc}[0]) && !defined($args{to}[0])) {
		warn('ZConf-Mail createEmailMime:5: Neither to or cc given' );
		$self->{error}=5;
		$self->{errorString}='Neither to or cc given.';
		return undef;
	}

	my $signed;
	if ($Aargs{usePGP}) {
		my $to='';
		$signed=$self->sign($args{account}, $args{body}, $to);
		if ($self->{error}) {
			warn('ZConf-Mail createMimeLite: Signing required and sign failed');
			return undef;
		}

		if ($Aargs{pgpType} eq 'clearsign') {
			$args{body}=$signed;
		}
		
		if ($Aargs{pgpType} eq 'signencrypt') {
			$args{body}='';
		}
	}

	my $email=undef;

	if ($Aargs{usePGP}) {
		if ($Aargs{pgpType} eq 'clearsign') {
			$email=MIME::Lite->new(Type=>'multipart/signed');
			$email->attach('Content-Type'=>'text/plain', Data=>$signed);
		}

		if ($Aargs{pgpType} eq 'mimesign') {
			$email=MIME::Lite->new(Type=>'multipart/signed');

			$email->attr('content-type.protocol'=>'application/pgp-signature');

			my $hash='SHA512';
			if (defined($Aargs{PGPdigestAlgo})) {
				$hash=$Aargs{PGPdigestAlgo};
			}

			$email->attr('content-type.micalg'=>'PGP-'.$hash);

			$email->attach('Content-Type'=>'text/plain',
						   Encoding=>'quoted-printable',
						   Data=>$args{body});

			$email->attach(Type=>'application/pgp-signature',
						   Filename=>'signature.asc', Disposition=>'attachment',
						   Encoding=>'7bit',Data=>$signed);
		}

		if ($Aargs{pgpType} eq 'signencrypt') {
			$email=MIME::Lite->new(Type=>'multipart/signed');

			$email->attr('content-type'=>'multipart/encrypted');
			$email->attr('content-type.protocol'=>'application/pgp-encrypted');
			$email->attach('Content-Type'=>'application/pgp-encrypted',
						ata=>"Version: 1.0\n");
			$email->attach('Content-Type'=>'application/octet-stream',
						   Data=>$signed);
		}
	}else {
		$email=MIME::Lite->new(Data=>$args{body});
	}

	#process the to stuff
	if (defined($args{to})){
		my $to=join(', ', @{$args{to}});
		$email->add('To'=>$to);
	}

	#process the cc stuff
	if (defined($args{cc}[0])){
		my $to=join(', ', @{$args{cc}});
		$email->add('CC'=>$to);
	}

	if (defined($args{'in-reply-to'})) {
		$email->add('In-Reply-To'=>$args{'in-reply-to'});
	}

	$email->add('Subject'=>$args{subject});

	$email->add('From'=>$Aargs{from});

	my $shost=hostname;
	$shost=~s/\..*//g;
	$email->add('Message-ID'=>'<'.rand().'.'.time().'.ZConf::Mail'.'@'.$shost.'>');

	#attach all the files
	my $int=0;
	while ($args{files}[$int]) {
		if (! -e $args{files}[$int]) {
			warn('ZConf-Mail createEmailMime:38: "'.$args{files}[0].'" does not exist');
			$self->{error}=38;
			$self->{errorString}='"'.$args{files}[0].'" does not exist';
			return undef;
		}

		my $mimetype=mimetype($args{files}[$int]);

		$email->attach(Type=>$mimetype, Path=>$args{files}[$int]);

		$int++;
	}

	return $email;
}

sub defaultFetchableGet{
	my $self=$_[0];
	$self->errorBlank;

	my %var=$self->{zconf}->regexVarGet('mail', '^default/fetchable$');

	if (!defined($var{'default/fetchable'})) {
		return undef;
	}

	if ($var{'default/fetchable'} eq '') {
		return undef;
	}

	return $var{'default/fetchable'};
}

sub defaultFetchableSet{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#make sure we have a account
	if (!defined($account)) {
		$self->{errorString}='No account specified.';
		$self->{error}='5';
		warn('ZConf-Mail defaultFetchableSet:5: '.$self->{errorString});
		return undef;
	}
	
	my $fetchable=$self->fetchable($account);
	if ($self->{error}) {
		warn('ZConf-Mail defaultFetchableSet: fetchable errored');
		return undef;
	}

	if (!$fetchable) {
		$self->{error}=24;
		$self->{errorString}='The account, "'.$account.'", is not sendable.';
		warn('ZConf-Mail defaultFetchableSet:24: '.$self->{errorString});
		return undef;
	}

	#sets the value
	#not doing any error checking as there is no reason to believe it will fail
	$self->{zconf}->setVar('mail', 'default/fetchable', $account);

	#saves it
	$self->{zconf}->writeSetFromLoadedConfig({config=>'mail'});
	if ($self->{zconf}->{error}) {
		$self->{errorString}='ZConf failed to write the set out.';
		$self->{error}=36;
		warn('ZConf-Mail defaultFetchableSet:36: '.$self->{errorString});
		return undef;
	}

	return 1;
}

sub defaultSendableGet{
	my $self=$_[0];
	$self->errorBlank;

	my %var=$self->{zconf}->regexVarGet('mail', '^default/sendable$');

	if (!defined($var{'default/sendable'})) {
		return undef;
	}

	if ($var{'default/sendable'} eq '') {
		return undef;
	}

	return $var{'default/sendable'};
}

sub defaultSendableSet{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#make sure we have a account
	if (!defined($account)) {
		$self->{errorString}='Account not specified.';
		$self->{error}='5';
		warn('ZConf-Mail defaultSendableSet:5: '.$self->{errorString});
		return undef;
	}
	
	my $sendable=$self->sendable($account);
	if ($self->{error}) {
		warn('ZConf-Mail defaultSendableSet: sendable errored');
		return undef;
	}

	if (!$sendable) {
		$self->{error}=24;
		$self->{errorString}='The account, "'.$account.'", is not sendable.';
		warn('ZConf-Mail defaultSendableSet:24: '.$self->{errorString});
		return undef;
	}

	#sets the value
	#not doing any error checking as there is no reason to believe it will fail
	$self->{zconf}->setVar('mail', 'default/sendable', $account);

	#saves it
	$self->{zconf}->writeSetFromLoadedConfig({config=>'mail'});
	if ($self->{zconf}->{error}) {
		$self->{errorString}='ZConf failed to write the set out.';
		$self->{error}=36;
		warn('ZConf-Mail defaultSendableSet:36: '.$self->{errorString});
		return undef;
	}

	return 1;
}

sub defaultImapGet{
	my $self=$_[0];
	$self->errorBlank;

	my %var=$self->{zconf}->regexVarGet('mail', '^default/imap$');

	if (!defined($var{'default/imap'})) {
		return undef;
	}

	if ($var{'default/imap'} eq '') {
		return undef;
	}

	return $var{'default/imap'};
}

sub defaultImapSet{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#make sure we have a account
	if (!defined($account)) {
		$self->{errorString}='Account not specified.';
		$self->{error}='5';
		warn('ZConf-Mail defaultImapSet:5: '.$self->{errorString});
		return undef;
	}
	
	my $sendable=$self->sendable($account);
	if ($self->{error}) {
		warn('ZConf-Mail defaultSendableSet: sendable errored');
		return undef;
	}

	#sets the value
	#not doing any error checking as there is no reason to believe it will fail
	$self->{zconf}->setVar('mail', 'default/imap', $account);

	#saves it
	$self->{zconf}->writeSetFromLoadedConfig({config=>'mail'});
	if ($self->{zconf}->{error}) {
		$self->{errorString}='ZConf failed to write the set out.';
		$self->{error}=36;
		warn('ZConf-Mail defaultImapSet:36: '.$self->{errorString});
		return undef;
	}

	return 1;
}

sub delAccount{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that. It also makes sure that
	#nothing past the account name is refered to.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail delAccount:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#makes sure the account exists
	if (!$self->accountExists($account)) {
		warn('Zconf-Mail delAccount:6: "'.$account.'" does not exist');
		$self->{error}=6;
		$self->{errorString}='"'.$account.'" does not exist';
	}

	#removes the variables
	#Off hand I can't think of a reason it should fail at this point.
	my @deleted=$self->{zconf}->regexVarDel('mail', '^accounts/'.$account.'/');

	#saves it
	$self->{zconf}->writeSetFromLoadedConfig({config=>'mail'});
	if ($self->{zconf}->{error}) {
		warn('ZConf-Mail delAccount:36: ZConf failed to write the set out');
		$self->{error}=36;
		$self->{errorString}='ZConf failed to write the set out.';
		return undef;
	}

	return 1;
}

sub deliverable{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that. It also makes sure that
	#nothing past the account name is refered to.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail deliverable:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#makes sure the account exists
	if (!$self->accountExists($account)) {
		warn('ZConf-Mail deliverable:6: The account "'.$account.'" does not exist');
		$self->{error}=6;
		$self->{errorString}='The account "'.$account.'" does not exist';
	}

	#checks to make sure that is a account type that is deliverable
	my $int=0;
	while(defined($self->{deliverable}[$int])){
		#If it is matched set $matched to true.
		if ($self->{deliverable}[$int] eq $split[0]) {
			return 1;
		}

		$int++;
	}

	return undef;
}

sub deliver{
	my $self=$_[0];
	my $account=$_[1];
	my $mail=$_[2];
	my %args;
	if(defined($_[3])){
		%args= %{$_[3]};
	}

	$self->errorBlank;

	#makes sure the account can be delivered to
	if (!$self->deliverable($account)) {
		warn('ZConf-Mail deliver:15: "'.$account.'" is not deliverable');
		$self->{error}='15';
		$self->{errorString}='"'.$account.'" is not deliverable';
		return undef;
	}

	#delivers it to a exec account
	if ($account =~ /^exec\//) {
		if (!$self->deliverExec($account, $mail)) {
			warn('ZConf-Mail deliver:'.$self->{error}.': '.$self->{errorString});
			return undef;
		}		
	}

	#delivers it to a imap account
	if ($account =~ /^imap\//) {
		if (!$self->deliverIMAP($account, $mail, \%args)) {
			warn('ZConf-Mail deliver:'.$self->{error}.': '.$self->{errorString});
			return undef;
		}
	}

	return 1;
}

sub deliverExec{
	my $self=$_[0];
	my $account=$_[1];
	my $mail=$_[2];

	$self->errorBlank;

	#delivers it to a exec account
	if (!$account =~ /^exec\//) {
		warn('ZConf-Mail deliverExec:19: "'.$account.'" is not a exec account');
		$self->{error}=19;
		$self->{errorString}='"'.$account.'" is not a exec account';
		return undef;
	}

	#Make sure the command is defined.
	if (!defined($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/deliver'})) {
		warn('ZConf-Mail deliverExec:5: "'.$account.'" is missing the variable "deliver"');
		$self->{error}=5;
		$self->{errorString}='"'.$account.'" is missing the variable "deliver"';
		return undef;		
	}

	#sets up the pipe
	my $pipe=IO::MultiPipe->new;
	$pipe->set($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/deliver'});
	if ($pipe->{error}) {
		warn('ZConf-Mail deliverExec:20: IO::MultiPipe errored. $pipe->{error}="'
			 .$pipe->{error}.'" $pipe->{errorString}="'
			 .$pipe->{errorString}.'"');
		$self->{error}=20;
		$self->{errorString}='O::MultiPipe errored. $pipe->{error}="'
		                     .$pipe->{error}.'" $pipe->{errorString}="'
							 .$pipe->{errorString}.'"';
		return undef;
	}

	#runs it
	$pipe->run($mail);
	if ($pipe->{error}) {
		warn('ZConf-Mail deliverExec:20: IO::MultiPipe errored. $pipe->{error}="'
			 .$pipe->{error}.'" $pipe->{errorString}="'
			 .$pipe->{errorString}.'"');
		$self->{error}=20;
		$self->{errorString}='O::MultiPipe errored. $pipe->{error}="'
		                     .$pipe->{error}.'" $pipe->{errorString}="'
							 .$pipe->{errorString}.'"';
		return undef;
	}

	return 1;
}

sub deliverIMAP{
	my $self=$_[0];
	my $account=$_[1];
	my $mail=$_[2];
	my %args;
	if(defined($_[3])){
		%args= %{$_[3]};
	}

	$self->errorBlank;

	#connects to the IMAP server
	my $imap=$self->connectIMAP($account);
	if ($self->{error}) {
		warn('ZConf-Mail fetchIMAP:22: Failed to connect to the IMAP server.');
		return undef;
	}

	#delivers it to a exec account
	if (!$account =~ /^IMAP\//) {
		warn('ZConf-Mail deliverIMAP:19: "'.$account.'" is not a IMAP account');
		$self->{error}=19;
		$self->{errorString}='"'.$account.'" is not a IMAP account';
		return undef;
	}

	#
	if (!defined($args{folder})) {
		#Make sure the command is defined.
		if (!defined($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/inbox'})) {
			warn('ZConf-Mail deliverIMAP:33: "'.$account.'" is missing the variable "inbox"');
			$self->{error}=33;
			$self->{errorString}='"'.$account.'" is missing the variable "inbox"';
			return undef;		
		}
		
		$args{folder}=$self->{zconf}->{conf}{mail}{'accounts/'.$account.'/inbox'};
	}

	#make sure the folder exists
	my $select=$imap->select($args{folder});
	if (!$select) {
		warn('ZConf-Mail deliverIMAP:34: Failed to select folder "'.$args{folder}.
			 '" for account "'.$account.'"');
		$self->{error}=34;
		$self->{errorString}='Failed to select folder "'.$args{folder}.
		                     '"for account "'.$account.'"';
		return undef;
	}

	my $append=$imap->append($args{folder}, ['Literal', $mail]);
	if (!$append) {
		warn('ZConf-Mail deliverIMAP:34: Failed to append to folder "'.$args{folder}.
			 '"for account "'.$account.'"');
		$self->{error}=35;
		$self->{errorString}='Failed to append to folder "'.$args{folder}.
		                     '"for account "'.$account.'"';
		return undef;
	}

	return 1;
}

sub fetch{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#gets the default fetchable account if no account is given
	if (!defined($account)) {
		$account=$self->defaultFetchableGet;
	}

	#if we get to this point it means the account does has not
	#been specified and no default account exists
	if (!defined($account)) {
		$self->{error}=5;
		$self->{errorString}='No account specified and there is no default fetchable account.';
		warn('ZConf-Mail fetch:5: '.$self->{errorString});
		return undef;
	}

	if (!$self->fetchable($account)) {
		warn('ZConf-Mail fetch:15: "'.$account.'" is not fetchable');
		$self->{error}='15';
		$self->{errorString}='"'.$account.'" is not fetchable';
		return undef;
	}

	#used for returning the number fetched
	my $fetched;

	#Fetches a account if it is a POP3 account.
	if ($account =~ /^pop3\//) {
	    $fetched=$self->fetchPOP3($account);
		if (!defined($fetched)) {
			warn('ZConf-Mail fetch:'.$self->{error}.': '.$self->{errorString});
			return undef;
		}
	}

	#Fetches a account if it is a mbox account.
	if ($account =~ /^mbox\//) {
	    $fetched=$self->fetchMbox($account);
		if (!defined($fetched)) {
			warn('ZConf-Mail fetch:'.$self->{error}.': '.$self->{errorString});
			return undef;
		}
	}

	#Fetches a account if it is a maildir account.
	if ($account =~ /^maildir\//) {
	    $fetched=$self->fetchMaildir($account);
		if (!defined($fetched)) {
			warn('ZConf-Mail fetch:'.$self->{error}.': '.$self->{errorString});
			return undef;
		}
	}

	#Fetches a account if it is a maildir account.
	if ($account =~ /^imap\//) {
	    $fetched=$self->fetchIMAP($account);
		if (!defined($fetched)) {
			warn('ZConf-Mail fetch:'.$self->{error}.': '.$self->{errorString});
			return undef;
		}
	}

	return $fetched;
}

sub fetchable{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that. It also makes sure that
	#nothing past the account name is refered to.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail fetchable:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
		return undef;
	}

	#makes sure the account exists
	if (!$self->accountExists($account)) {
		warn('ZConf-Mail fetchable:6: The account "'.$account.'" does not exist');
		$self->{error}=6;
		$self->{errorString}='The account "'.$account.'" does not exist';
		return undef;
	}

	my $int=0;
	while(defined($self->{fetchable}[$int])){
		#If it is matched set $matched to true.
		if ($self->{fetchable}[$int] eq $split[0]) {
			return $self->{zconf}->{conf}{mail}{'accounts/'.$account.'/fetchable'};
		}
		$int++;
	}

	#Returns undef if the account type was not matched.
	return undef;
}

sub fetchIMAP{
	my $self=$_[0];
	my $account=$_[1];

	#makes sure it is fetchable
	if (!$self->fetchable($account)) {
		warn('ZConf-Mail fetchIMAP:15: "'.$account.'" is not fetchable');
		$self->{error}='15';
		$self->{errorString}='"'.$account.'" is not fetchable';
		return undef;
	}

	#returns
	if (!defined($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/inbox'})) {
		warn('ZConf-Mail fetchIMAP:5: No IMAP inbox defined');
		$self->{error}=5;
		$self->{errorString}='No IMAP inbox defined';
		return undef;
	}

	#connects to the IMAP server
	my $imap=$self->connectIMAP($account);
	if ($self->{error}) {
		warn('ZConf-Mail fetchIMAP:22: Failed to connect to the IMAP server.');
		return undef;
	}

	#selects the proper folder
	if (!$imap->select($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/inbox'})) {
#	if (!$imap->select('Inbox')) {
		warn('ZConf-Mail fetchIMAP:23: Failed to select IMAP folder "'.
			 $self->{zconf}->{conf}{mail}{'accounts/'.$account.'/inbox'}.'"');
		$self->{error}=23;
		$self->{errorString}='Failed to select IMAP folder "'.
		    $self->{zconf}->{conf}{mail}{'accounts/'.$account.'/inbox'}.'"';
		return undef;
	}

	#gets the number of messages
	my $count=$imap->message_count($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/inbox'});

	#processes each one
	my $countInt=1;
	while ($countInt <= $count && $count > 0) {
		my $mail=$imap->fetch($countInt, 'rfc822');
		if ($?) {
			warn('ZConf-Mail fetchImap:22: $imap->fetch('.$countInt.', \'rfc822\') failed');
			$self->{error}=22;
			$self->{errorString}='$imap->fetch('.$countInt.', \'rfc822\') failed';
			return undef;
		}

		#delivers the fetched message.
		$self->deliver($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/deliverTo'},
					   $mail->{$countInt}{rfc822});
		if ($self->{error}) {
			warn('ZConf-Mail fetchIMAP:'.$self->{error}.': Delivery error');
			return undef;
		}

		#removes the old one
		if (!$imap->store($countInt, , '+flags', '(\\deleted)')) {
			warn('ZConf-Mail fetchMbox:21: $mbox->message('.$countInt.')->delete failed');
			$self->{error}=21;
			$self->{errorString}='$mbox->message('.$countInt.')->delete failed';
			return undef;
		}
		$imap->expunge();
		
		$countInt++;
	}

	return $count;
}

sub fetchMaildir{
	my $self=$_[0];
	my $account=$_[1];

	#makes sure it is fetchable
	if (!$self->fetchable($account)) {
		warn('ZConf-Mail fetchMaildir:15: "'.$account.'" is not fetchable');
		$self->{error}='15';
		$self->{errorString}='"'.$account.'" is not fetchable';
		return undef;
	}

	my $maildir=$self->connectMaildir($account);

	if ($self->{error}) {
		warn('ZConf-Mail fetchMaildir:16: Failed to connect to the maildir.');
		return undef;
	}

	#gets the number of messages
	my $count=$maildir->nrMessages;
	#This is done as the function above returns an extra one.
	$count--;

	#processes each one
	my $countInt=0;
	while ($countInt < $count && $count > 0) {
		my $mail=$maildir->message($countInt)->string;
		if ($?) {
			warn('ZConf-Mail fetchMbox:22: $mbox->message('.$countInt.')->print failed');
			$self->{error}=22;
			$self->{errorString}='$mbox->message('.$countInt.')->print failed';
			return undef;
		}

		#delivers the fetched message.
		$self->deliver($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/deliverTo'},
					   $mail);
		if ($self->{error}) {
			warn('ZConf-Mail fetchMbox:'.$self->{error}.': Delivery error');
			return undef;
		}

		#removes the old one
		if (!$maildir->message($countInt)->delete) {
			warn('ZConf-Mail fetchMbox:21: $mbox->message('.$countInt.')->delete failed');
			$self->{error}=21;
			$self->{errorString}='$mbox->message('.$countInt.')->delete failed';
			return undef;
		}
		
		$countInt++;
	}

	return $count;
}

sub fetchMbox{
	my $self=$_[0];
	my $account=$_[1];

	#makes sure it is fetchable
	if (!$self->fetchable($account)) {
		warn('ZConf-Mail fetchMbox:15: "'.$account.'" is not fetchable');
		$self->{error}='15';
		$self->{errorString}='"'.$account.'" is not fetchable';
		return undef;
	}

	my $mbox=$self->connectMbox($account);

	if ($self->{error}) {
		warn('ZConf-Mail fetchMbox:16: Failed to connect to the mbox.');
		return undef;
	}

	#gets the number of messages
	my $count=$mbox->nrMessages;
	#This is done as the function above returns an extra one.
	$count--;

	#processes each one
	my $countInt=0;
	while ($countInt < $count && $count > 0) {

		my $mail=$mbox->message($countInt)->string;
		if ($?) {
			warn('ZConf-Mail fetchMbox:22: $mbox->message('.$countInt.')->print failed');
			$self->{error}=22;
			$self->{errorString}='$mbox->message('.$countInt.')->print failed';
			return undef;
		}

		#delivers the fetched message.
		$self->deliver($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/deliverTo'},
					   $mail);
		if ($self->{error}) {
			warn('ZConf-Mail fetchMbox:'.$self->{error}.': Delivery error');
			return undef;
		}

		#removes the old one
		if (!$mbox->message($countInt)->delete) {
			warn('ZConf-Mail fetchMbox:21: $mbox->message('.$countInt.')->delete failed');
			$self->{error}=21;
			$self->{errorString}='$mbox->message('.$countInt.')->delete failed';
			return undef;
		}
		
		$countInt++;
	}

	return $count;
}

sub fetchPOP3{
	my $self=$_[0];
	my $account=$_[1];

	#makes sure it is fetchable
	if (!$self->fetchable($account)) {
		warn('ZConf-Mail fetchPOP3:15: "'.$account.'" is not fetchable');
		$self->{error}='15';
		$self->{errorString}='"'.$account.'" is not fetchable';
		return undef;
	}

	my $pop=$self->connectPOP3($account);

	if ($self->{error}) {
		warn('ZConf-Mail fetchPOP3:16: Failed to connect to the POP3 server.');
		return undef;
	}

	#fetches the messages
	my $count=$pop->Count();
	my $countInt=1;
	while ($countInt <= $count && $count > 0) {

		my $mail=$pop->Retrieve($countInt);
		if ($?) {
			warn('ZConf-Mail fetchPOP3:17: $pop->Retrieve failed. $?="'.$?.'"');
			$self->{error}=17;
			$self->{errorString}='$pop->Retrieve failed. $?="'.$?.'"';
			return undef;
		}


		#delivers the fetched message.
		$self->deliver($self->{zconf}->{conf}{mail}{'accounts/'.$account.'/deliverTo'},
					   $mail);
		if ($self->{error}) {
			warn('ZConf-Mail fetchPOP3:'.$self->{error}.': Delivery error');
			return undef;
		}

		#removes the old one
		if (!$pop->Delete($countInt)) {
			warn('ZConf-Mail fetchPOP3:17: $pop->Delete failed. $?="'.$?.'"');
			$self->{error}=17;
			$self->{errorString}='$pop->Delete failed. $?="'.$?.'"';
			return undef;
		}

		$countInt++;
	}

	#returns the number of fetched messages
	return $count;
}

sub formatter{
	my $self=$_[0];
	my $text=$_[1];

	my %f=$self->{zconf}->regexVarGet('mail', '^formatter/');

	if (!defined($f{'formatter/marginLeft'})) {
		$f{'formatter/marginLeft'}=0;
	}

	if (!defined($f{'formatter/marginRight'})) {
		$f{'formatter/marginRight'}=72;
	}

	if (!defined($f{'formatter/squeeze'})) {
		$f{'formatter/squeeze'}=1;
	}

	if (!defined($f{'formatter/ignoree'})) {
		$f{'formatter/ignore'}='^[ \t]';
	}

	if (!defined($f{'formatter/justify'})) {
		$f{'formatter/justify'}='left';
	}

	if (!defined($f{'formatter/tabspace'})) {
		$f{'formatter/tabspace'}='4';
	}

	my $ignore=$f{'formatter/justify'};

	$text=autoformat($text, {left=>$f{'formatter/marginLeft'},
							 right=>$f{'formatter/marginRight'},
							 squeeze=>$f{'formatter/squeeze'},
							 justify=>$f{'formatter/justify'},
							 ignore=>qr/$ignore/,
							 all=>1});

	return $text;
}

sub formatterGet{

}

sub formatterSet{

}

sub getAccounts{
	my $self=$_[0];

	#searches the mail config for any thing under 'acounts/'
	my @matched=$self->{zconf}->regexVarSearch('mail', '^accounts/');

	my $matchedInt=0;

	my %accountsH;

	#goes through the list and splits it apart...
	#A hash is used for this as this operates on every key under a account... this means
	#it will be finding multiple hits for each account
	while (defined($matched[$matchedInt])) {
		my @split=split(/\//, $matched[$matchedInt],4);
		$accountsH{$split[1].'/'.$split[2]}='';
		
		$matchedInt++;
	}

	#returns a array of the accounts
	return keys(%accountsH);
}

sub getAccountArgs{
	my $self=$_[0];
	my $account=$_[1];

	$self->errorBlank;

	#This implements a simple check to make sure no one passed
	#'pop3/' or something like that. It also makes sure that
	#nothing past the account name is refered to.
	my @split=split(/\//, $account);
	if (!defined($split[1]) || defined($split[3])) {
		warn('ZConf-Mail getAccountArgs:4: "'.$account.'" is not a valid acocunt name');
		$self->{error}=4;
		$self->{errorString}='"'.$account.'" is not a valid acocunt name';
	}

	#
	if (!$self->accountExists($account)) {
		warn('ZConf-Mail getAccountArgs:6: The account "'.$account.'" does not exist');
		$self->{error}=6;
		$self->{errorString}='The account "'.$account.'" does not exist';
	}

	#gets the variables for the account.
	my %vars=$self->{zconf}->regexVarGet('mail', '^accounts/'.$account.'/');

	my @keys=keys(%vars);
	my $keysInt=0;
	while (defined($keys[$keysInt])) {
		my $newvar=$keys[$keysInt];
		#removes the prefixed stuff for the variables for the account
		$newvar=~s/^accounts\/$account\///;

		#copies it
		$vars{$newvar}=$vars{$keys[$keysInt]};

		#removes the original
		delete($vars{$keys[$keysInt]});

		$keysInt++;
	}

	return %vars;
}

sub getSet{
	my $self=$_[0];

	my $set=$self->{zconf}->getSet('mail');
	if($self->{zconf}->{error}){
		warn('ZConf-Mail getSet:2: ZConf error getting the loaded set the config "mail".'.
			 ' ZConf error="'.$self->{zconf}->{error}.'" '.
			 'ZConf error string="'.$self->{zconf}->{errorString}.'"');
		$self->{error}=2;
		$self->{errorString}='ZConf error getting the loaded set the config "mail".'.
			                 ' ZConf error="'.$self->{zconf}->{error}.'" '.
			                 'ZConf error string="'.$self->{zconf}->{errorString}.'"';
		return undef;
	}

	return $set;
}

sub init{
	my $self=$_[0];
	my %args;
	if(defined($_[1])){
		%args= %{$_[1]};
	}

	$self->errorBlank();

	#creates the config if needed
	if (!$self->{zconf}->configExists("mail")){
		if ($self->{zconf}->createConfig('mail')){
			warn('ZConf-Mail init:1: Could not create the config. $self->{zconf}->{error}="'.
				 $self->{zconf}->{error}.'" $self->{zconf}->{errorString}="'.
				 $self->{zconf}->{errorString}.'"');
			$self->{error}=8;
			$self->{errorString}='Could not create the config. $self->{zconf}->{error}="'.
			    $self->{zconf}->{error}.'" $self->{zconf}->{errorString}="'.
			    $self->{zconf}->{errorString}.'"';
			return undef;
		}
	}

	return 1;
}

sub listSets{
	my $self=$_[0];

	#blanks any previous errors
	$self->errorBlank;

	my @sets=$self->{zconf}->getAvailableSets('mail');
	if($self->{zconf}->{error}){
		warn('ZConf-Mail listSets:2: ZConf error listing sets for the config "mail".'.
			 ' ZConf error="'.$self->{zconf}->{error}.'" '.
			 'ZConf error string="'.$self->{zconf}->{errorString}.'"');
		$self->{error}=2;
		$self->{errorString}='ZConf error listing sets for the config "mail".'.
			                 ' ZConf error="'.$self->{zconf}->{error}.'" '.
			                 'ZConf error string="'.$self->{zconf}->{errorString}.'"';
		return undef;
	}

	return @sets;
}

sub modAccount{
	my $self=$_[0];
	my %args;
	if(defined($_[1])){
		%args= %{$_[1]};
	}

	#blanks any previous errors
	$self->errorBlank;

	#make sure the type is defined
	if (!defined($args{type})) {
		warn('ZConf-Mail createAccount:2: $args{type} is undefined');
		$self->{error}='2';
		$self->{errorString}='$args{type} is undefined';
		return undef;
	}

	#make sure it is a known type
	if (!defined($self->{legal}{$args{type}})) {
		warn('ZConf-Mail modAccount:3: $args{type}, "'.$args{type}.'", not a valid type');
		$self->{error}='3';
		$self->{errorString}='$args{type}, "'.$args{type}.'", not a valid value';
		return undef;
	}

	#make sure it is a legit account name
	if (!$self->{zconf}->setNameLegit($args{account})){
		warn('ZConf-Mail modAccount:4: $args{account}, "'.$args{account}.'", not a legit account name');
		$self->{error}='3';
		$self->{errorString}='$args{account}, "'.$args{account}.'", not a legit account name';
		return undef;
	}

	#puts together the accountname
	my $account=$args{type}.'/'.$args{account};

	#makes sure the account exists
	if (!$self->accountExists($account)) {
		warn('ZConf-Mail modAccount:6: The account "'.$account.'" does not exist');
		$self->{error}=6;
		$self->{errorString}='The account "'.$account.'" does not exist';
		return undef;
	}

	#adds them
	my $int=0;
	while (defined($self->{legal}{$args{type}}[$int])) {
		my $variable='accounts/'.$args{type}.'/'.$args{account}.'/'.$self->{legal}{$args{type}}[$int];

		#sets the value
		#not doing any error checking as there is no reason to believe it will fail
		$self->{zconf}->setVar('mail', $variable, $args{$self->{legal}{$args{type}}[$int]});

		$int++;
	}

	#saves it
	$self->{zconf}->writeSetFromLoadedConfig({config=>'mail'});
	if ($self->{zconf}->{error}) {
		warn('ZConf-Mail modAccount:36: ZConf failed to write the set out');
		$self->{error}=36;
		$self->{errorString}='ZConf failed to write the set out.';
		return undef;
	}

	return 1;
}

sub readSet{
	my $self=$_[0];
	my $set=$_[1];

	
	#blanks any previous errors
	$self->errorBlank;

	$self->{zconf}->read({config=>'mail', set=>$set});
	if ($self->{zconf}->{error}) {
		warn('ZConf-Mail readSet:2: ZConf error reading the config "mail".'.
			 ' ZConf error="'.$self->{zconf}->{error}.'" '.
			 'ZConf error string="'.$self->{zconf}->{errorString}.'"');
		$self->{error}=2;
		$self->{errorString}='ZConf error reading the config "mail".'.
			                 ' ZConf error="'.$self->{zconf}->{error}.'" '.
			                 'ZConf error string="'.$self->{zconf}->{errorString}.'"';
		return undef;
	}

	return 1;
}

sub send{
	my $self=$_[0];
	my %args;
	if(defined($_[1])){
		%args= %{$_[1]};
	}

	$self->errorBlank;

	if (!defined($args{account})) {
		$args{account}=$self->defaultSendableGet;
	}

	#makes sure we have mail
	if (!defined($args{mail})) {
		warn('ZConf-Mail send:5: The hash arg "mail" is missing and thus nothing to send');
		$self->{error}=5;
		$self->{errorString}='The hash arg "mail" is missing and thus nothing to send';
	}

	#creates the SMTP connection
	my $smtp=$self->connectSMTP($args{account});
	if ($self->{error}) {
		warn('ZConf-Mail send:'.$self->{error}.': Failed to establish an SMTP connection');
		return undef;
	}

	$smtp->mail($self->{zconf}->{conf}{mail}{'accounts/'.$args{account}.'/from'});

	#sends the to addresses
	my $int=0;
	while (defined($args{to}[$int])) {
		$smtp->to($args{to}[$int]);
		if ($?) {
			warn('ZConf-Mail send:26: Failed to send the To address "'.
				 $args{to}[$int].'"');
			$self->{error}=26;
			$self->{errorString}='Failed to send the To address "'.$args{to}[$int].'"';
		}
		$int++;
	}

	#sends the cc addresses
	$int=0;
	while (defined($args{cc}[$int])) {
		$smtp->to($args{cc}[$int]);
		if ($?) {
			warn('ZConf-Mail send:26: Failed to send the CC address "'.
				 $args{cc}[$int].'"');
			$self->{error}=26;
			$self->{errorString}='Failed to send the CC address "'.$args{cc}[$int].'"';
		}
		$int++;
	}

	#sends the bcc addresses
	$int=0;
	while (defined($args{bcc}[$int])) {
		$smtp->to($args{bcc}[$int]);
		if ($?) {
			warn('ZConf-Mail send:26: Failed to send the BCC address "'.
				 $args{bcc}[$int].'"');
			$self->{error}=26;
			$self->{errorString}='Failed to send the BCC address "'.$args{bcc}[$int].'"';
		}
		$int++;
	}

	#tries to start the data session
	if (!$smtp->data) {
		warn('ZConf-Mail send:27: Failed to start the data session');
		$self->{error}=27;
		$self->{errorString}='Failed to start the data session.';
	}

	#sends the data
	if (!$smtp->datasend($args{mail})) {
		warn('ZConf-Mail send:28: Failed to send the data.');
		$self->{error}=28;
		$self->{errorString}='Failed to send the data.';
	}

	#ends the data session
	#Not currently doing error checking as this appears to error occasionally
	#with out any detectable reason.
	if (!$smtp->dataend) {
#		warn('ZConf-Mail send:29: Failed to end the data.');
#		$self->{error}=29;
#		$self->{errorString}='Failed to end the data session.';
	}

	#quits
	if (!$smtp->quit) {
		warn('ZConf-Mail send:30: Failed to end the SMTP session.');
		$self->{error}=30;
		$self->{errorString}='Failed to end the SMTP session.';
	}

	#we know it has args if we get this far so we don't have to check it
	my %acctArgs=$self->getAccountArgs($args{account});

	#saves it if asked
	if ($args{save}) {
		if (!defined($acctArgs{saveTo})) {
			warn('ZConf-Mail send:37: saveTo is undefined and thus the mail can\'t be saved');
			$self->{error}=37;
			$self->{errorString}='saveTo is undefined and thus the mail can\'t be saved.';
			return undef;
		}

		if ($acctArgs{saveTo}=~ /^$/) {
			warn('ZConf-Mail send:37: saveTo is set to "" and thus can\'t be saved');
			$self->{error}=37;
			$self->{errorString}='saveTo is is set to "" and thus the mail can\'t be saved';
			return undef;
		}
		
		$self->deliver($acctArgs{saveTo}, $args{mail},{folder=>$acctArgs{folder}});
		if ($self->{error}) {
			warn('ZConf-BGSet send: deliver errored');
			return undef;
		}

		return 1;
	}

	#if this is not defined, we don't save it
	if (!defined($acctArgs{saveTo})) {
		return 1;
	}

	#if this is set, we don't save it
	if ($acctArgs{saveTo}=~ /^$/) {
		return 1;
	}

	$self->deliver($acctArgs{saveTo}, $args{mail},{folder=>$acctArgs{saveToFolder}});
	if ($self->{error}) {
		warn('ZConf-BGSet send: deliver errored');
		return undef;
	}

	return 1;
}