Provided by: libmail-box-imap4-perl_3.008-1_all bug

NAME

       Mail::Transport::IMAP4 - proxy to Mail::IMAPClient

INHERITANCE

        Mail::Transport::IMAP4
          is a Mail::Transport::Receive
          is a Mail::Transport
          is a Mail::Reporter

SYNOPSIS

        my $imap = Mail::Transport::IMAP4->new(...);
        my $message = $imap->receive($id);
        $imap->send($message);

        my Mail::Box::Manager $mgr = Mail::Box::Manager->new;
        $mgr->open(
            # Generic folder options
            folder => 'imaps://...',
            access => 'rw',
            extract => 'ALWAYS',

            # Mail::IMAPClient options start with [A-Z]
            IgnoreSizeErrors => 1,
            Ssl => 1,
        );

DESCRIPTION

       The IMAP4 protocol is quite complicated: it is feature rich and allows various
       asynchronous actions.  The main document describing IMAP is rfc3501 (which obsoleted the
       original specification of protocol 4r1 in rfc2060 in March 2003).

       This package, as part of MailBox, does not implement the actual protocol itself but uses
       Mail::IMAPClient to do the work. The task for this package is to hide as many differences
       between that module's interface and the common MailBox folder types.  Multiple
       Mail::Box::IMAP4 folders can share one Mail::Transport::IMAP4 connection.

       The Mail::IMAPClient module is the best IMAP4 implementation for Perl5, but is not
       maintained.  There are many known problems with the module, and solving those is outside
       the scope of MailBox.  See
       http://rt.cpan.org/Public/Dist/Display.html?Name=Mail-IMAPClient for all the reported
       bugs.

       Extends "DESCRIPTION" in Mail::Transport::Receive.

METHODS

       Extends "METHODS" in Mail::Transport::Receive.

   Constructors
       Extends "Constructors" in Mail::Transport::Receive.

       Mail::Transport::IMAP4->new(%options)
           Create the IMAP connection to the server.  IMAP servers can handle multiple folders
           for a single user, which means that connections may get shared.  This is sharing is
           hidden for the user.

           When an "imap_client" is specified, then the options "hostname", "port", "username",
           and "password" are extracted from it.

           All %options which start with a capital are passed as initiation to Mail::IMAPClient.
           See that manual about the huge pile of parameters.  When talking to Microsoft
           Exchange, you probabaly need the "IgnoreSizeErros".  Probably, you need "Ssl" or
           "StartTLS" as well.  As feature, you may also pass a HASH to Ssl, where
           "Mail::IMAPClient" only accepts an ARRAY.

           For backwards compatibility, "ssl" is an alternative for "Ssl", and "starttls" for
           "StartTLS".

            -Option      --Defined in     --Default
             authenticate                   'AUTO'
             domain                         <server_name>
             executable    Mail::Transport  undef
             hostname      Mail::Transport  'localhost'
             imap_client                    Mail::IMAPClient
             interval      Mail::Transport  30
             log           Mail::Reporter   'WARNINGS'
             password      Mail::Transport  undef
             port          Mail::Transport  143
             proxy         Mail::Transport  undef
             retry         Mail::Transport  <false>
             timeout       Mail::Transport  120
             trace         Mail::Reporter   'WARNINGS'
             username      Mail::Transport  undef
             via           Mail::Transport  'imap'

           authenticate => TYPE|ARRAY
             Authenthication method to login(), which will be passed to Mail::IMAPClient
             subroutine authenticate.  See the latter method for the available types.  You may
             provide an ARRAY of types.

           domain => WINDOWS_DOMAIN
             Used for NTLM authentication.

           executable => FILENAME
           hostname => HOSTNAME|ARRAY
           imap_client => OBJECT|CLASS
             When an OBJECT is supplied, that client will be used for the implementation of the
             IMAP4 protocol. Information about server and such are extracted from the OBJECT to
             have the accessors to produce correct results. The OBJECT shall be a
             Mail::IMAPClient.

             When a CLASS is given, an object of that type is created for you.  The created
             object can be retrieved via imapClient(), and than configured as defined by
             Mail::IMAPClient.

           interval => SECONDS
           log => LEVEL
           password => STRING
           port => INTEGER
           proxy => PATH
           retry => NUMBER|undef
           timeout => SECONDS
           trace => LEVEL
           username => STRING
           via => CLASS|NAME

   Receiving mail
       Extends "Receiving mail" in Mail::Transport::Receive.

       $obj->receive( [$unique_message_id] )
           Inherited, see "Receiving mail" in Mail::Transport::Receive

   Server connection
       Extends "Server connection" in Mail::Transport::Receive.

       $obj->findBinary( $name, [@directories] )
           Inherited, see "Server connection" in Mail::Transport

       $obj->remoteHost()
           Inherited, see "Server connection" in Mail::Transport

       $obj->retry()
           Inherited, see "Server connection" in Mail::Transport

   Attributes
       $obj->authentication( ['AUTO'|$type|$types] )
           Returns a LIST of ARRAYS, each describing one possible way to contact the server. Each
           pair contains a mechanism name and a challenge callback (which may be "undef").

           The settings are used by login() to get server access.  The initial value origins from
           new(authenticate), but may be changed later.

           Available basic $types are "CRAM-MD5", "NTLM", and "PLAIN".  With "AUTO", all
           available types will be tried.  When the Authen::NTLM is not installed, the "NTLM"
           option will silently be skipped.  Be warned that, because of "PLAIN", erroneous
           username/password combinations will be passed readible as last attempt!

           The "NTLM" authentication requires Authen::NTLM to be installed.  Other methods may be
           added later.  Besides, you may also specify a CODE reference which implements some
           authentication.

           An ARRAY as $type can be used to specify both mechanism as callback.  When no array is
           used, callback of the pair is set to "undef".  See "authenticate" in Mail::IMAPClient
           for the gory details.

           example:

            $transporter->authentication('CRAM-MD5', [MY_AUTH => \&c], 'PLAIN');

            foreach my $pair ($transporter->authentication)
            {   my ($mechanism, $challenge) = @$pair;
                ...
            }

       $obj->domain( [$domain] )
           Used in NTLM authentication to define the Windows domain which is accessed.  Initially
           set by new(domain) and defaults to the server's name.

       $obj->usesSSL()
           Returns a boolean.

   Exchanging Information
   Protocol [internals]
       The follow methods handle protocol internals, and should not be used by a normal user of
       this class.

       $obj->appendMessage( $message, $foldername, [$date] )
           Write the message to the server.  The optional DATA can be a RFC-822 date or a
           timestamp.

       $obj->createFolder($name)
           Add a folder.

       $obj->createImapClient($class, %options)
           Create an object of $class, which extends Mail::IMAPClient.

           All %options will be passed to the constructor (new) of $class.

       $obj->currentFolder( [$foldername] )
           Be sure that the specific FOLDER is the current one selected.  If the folder is
           already selected, no IMAP traffic will be produced.

           The boolean return value indicates whether the folder is selectable. It will return
           undef if it does not exist.

       $obj->deleteFolder($name)
           Remove one folder.

       $obj->destroyDeleted($folder)
           Command the server to delete for real all messages which are flagged to be deleted.

       $obj->fetch(ARRAY-$of-$messages, $info)
           Get some $info about the $messages from the server.  The specified messages shall
           extend Mail::Box::Net::Message, Returned is a list of hashes, each info about one
           result.  The contents of the hash differs per $info, but at least a "message" field
           will be present, to relate to the message in question.

           The right folder should be selected before this method is called. When the connection
           was lost, "undef" is returned.  Without any messages, and empty array is returned.
           The retrieval is done by Mail::IMAPClient method "fetch()", which is then parsed.

       $obj->flagsToLabels($what, @flags)
       Mail::Transport::IMAP4->flagsToLabels($what, @flags)
           In SCALAR context, a hash with labels is returned.  In LIST context, pairs are
           returned.

           The $what parameter can be 'SET', 'CLEAR', or 'REPLACE'.  With the latter, all
           standard imap flags which do not appear in the list will be ignored: their value may
           either by set or cleared.  See getFlags()

           Unknown flags in @flags are stripped from their backslash and lower-cased.  For
           instance, '\SomeWeirdFlag' will become `someweirdflag => 1'.  It will be set to '1'
           for "SET", and '0' in case of "CLEAR".

           example: translating IMAP4 flags into MailBox flags

            my @flags  = ('\Seen', '\Flagged');
            my $labels = Mail::Transport::IMAP4->flags2labels(SET => @flags);

       $obj->folders( [$foldername] )
           Returns a list of folder names which are sub-folders of the specified $foldername.
           Without $foldername, the top-level foldernames are returned.

       $obj->getFields( $uid, $name, [$name, ...] )
           Get the records with the specified NAMES from the header.  The header fields are
           returned as list of Mail::Message::Field::Fast objects.  When the name is "ALL", the
           whole header is returned.

       $obj->getFlags($folder, $id)
           Returns the values of all flags which are related to the message with the specified
           $id.  These flags are translated into the names which are standard for the MailBox
           suite.

           A HASH is returned.  Names which do not appear will also provide a value in the
           returned: the negative for the value is it was present.

       $obj->getMessageAsString($message|$uid)
           Returns the whole text of the specified message: the head and the body.

       $obj->ids()
           Returns a list of UIDs which are defined by the IMAP server.

       $obj->imapClient()
           Returns the object which implements the IMAP4 protocol, an instance of a
           Mail::IMAPClient, which is logged-in and ready to use.

           If the contact to the server was still present or could be established, an
           Mail::IMAPClient object is returned.  Else, "undef" is returned and no further actions
           should be tried on the object.

       $obj->labelsToFlags(HASH|PAIRS)
       Mail::Transport::IMAP4->labelsToFlags(HASH|PAIRS)
           Convert MailBox labels into IMAP flags.  Returned is a string.  Unsupported labels are
           ignored.

       $obj->listFlags()
           Returns all predefined flags as list.

       $obj->login()
           Establish a new connection to the IMAP4 server, using username and password.

       $obj->setFlags($id, $label, $value, [$label, $value], ...)
           Change the flags on the message which are represented by the label.  The value which
           can be related to the label will be lost, because IMAP only defines a boolean value,
           where MailBox labels can contain strings.

           Returned is a list of $label=>$value pairs which could not be send to the IMAP server.
           These values may be cached in a different way.

   Error handling
       Extends "Error handling" in Mail::Transport::Receive.

       $obj->AUTOLOAD()
           Inherited, see "Error handling" in Mail::Reporter

       $obj->addReport($object)
           Inherited, see "Error handling" in Mail::Reporter

       $obj->defaultTrace( [$level]|[$loglevel, $tracelevel]|[$level, $callback] )
       Mail::Transport::IMAP4->defaultTrace( [$level]|[$loglevel, $tracelevel]|[$level,
       $callback] )
           Inherited, see "Error handling" in Mail::Reporter

       $obj->errors()
           Inherited, see "Error handling" in Mail::Reporter

       $obj->log( [$level, [$strings]] )
       Mail::Transport::IMAP4->log( [$level, [$strings]] )
           Inherited, see "Error handling" in Mail::Reporter

       $obj->logPriority($level)
       Mail::Transport::IMAP4->logPriority($level)
           Inherited, see "Error handling" in Mail::Reporter

       $obj->logSettings()
           Inherited, see "Error handling" in Mail::Reporter

       $obj->notImplemented()
           Inherited, see "Error handling" in Mail::Reporter

       $obj->report( [$level] )
           Inherited, see "Error handling" in Mail::Reporter

       $obj->reportAll( [$level] )
           Inherited, see "Error handling" in Mail::Reporter

       $obj->trace( [$level] )
           Inherited, see "Error handling" in Mail::Reporter

       $obj->warnings()
           Inherited, see "Error handling" in Mail::Reporter

   Cleanup
       Extends "Cleanup" in Mail::Transport::Receive.

       $obj->DESTROY()
           The connection is cleanly terminated when the program is terminated.

DIAGNOSTICS

       Error: Cannot connect to $host:$port for IMAP4: $!
       Error: IMAP cannot connect to $host: $@
       Notice: IMAP4 authenication $mechanism to $host:$port successful
       Error: IMAP4 requires a username and password
       Error: IMAP4 username $username requires a password
       Error: Package $package does not implement $method.
           Fatal error: the specific package (or one of its superclasses) does not implement this
           method where it should. This message means that some other related classes do
           implement this method however the class at hand does not.  Probably you should
           investigate this and probably inform the author of the package.

SEE ALSO

       This module is part of Mail-Box-IMAP4 distribution version 3.008, built on August 09,
       2023. Website: http://perl.overmeer.net/CPAN/

LICENSE

       Copyrights 2001-2023 by [Mark Overmeer]. For other contributors see ChangeLog.

       This program is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself.  See http://dev.perl.org/licenses/