├── log
    └── .gitkeep
├── cache
    └── .gitkeep
├── owner.html
├── guest.html
├── README.md
├── page
    └── console.php
├── Console.php
├── Plugin.php
├── lib
    ├── class.pop3.php
    ├── class.smtp.php
    └── class.phpmailer.php
└── Action.php


/log/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/cache/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/owner.html:
--------------------------------------------------------------------------------
1 | <div style="margin: 16px 40px; background-color: #eef2fa; border: 1px solid #d8e3e8; padding: 0 15px;  -moz-border-radius:5px; -webkit-border-radius:5px; -khtml-border-radius:5px; border-radius:5px;">
2 | 	<p>{siteTitle}：<a target="_blank" href="{permalink}">{title}</a></strong>&nbsp;有新的评论</p>
3 | 	<p><strong>{author}</strong>&nbsp;评论说：{text}</p>
4 | 	<p>时间：{time}<br />IP：{ip}<br />邮箱：{mail}<br />状态：{status} [<a href='{manage}' target='_blank'>管理评论</a>]<br /></p>
5 | </div>


--------------------------------------------------------------------------------
/guest.html:
--------------------------------------------------------------------------------
1 | <div style="margin: 16px 40px; background-color: #eef2fa; border: 1px solid #d8e3e8; padding: 0 15px;  -moz-border-radius:5px; -webkit-border-radius:5px; -khtml-border-radius:5px; border-radius:5px;">
2 | 	<p>{author_p}：<a target="_blank" href="{permalink}">{title}</a>&nbsp;有新的回复</p>
3 | 	<p><strong>{author}</strong>&nbsp;回复说：{text}</p>
4 | 	<p>你的评论：{text_p}</p>
5 | 	<p>时间：{time}</p>
6 | 	<p>本邮件为{siteTitle}自动发送，请勿直接回复，如有疑问，<a href="mailto:{contactme}" target="_blank">联系我</a> 。</p>
7 | </div>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Typecho 评论邮件提醒插件
 2 | =============
 3 | 访客评论后，将会发送评论内容到您指定的邮箱。
 4 | 原作者是  DEFE (http://defe.me)。
 5 | 个人原因不再维护，所以我在其最终版本1.2.6的基础上继续维护更新。
 6 | 
 7 | 
 8 | ### 使用说明
 9 | 1. 下载插件
10 | 2. 将插件上传到 `/usr/plugins/` 这个目录下
11 | 3. 登陆后台，在“控制台”下拉菜单中进入“插件管理”
12 | 4. 启用相关插件
13 | 5. 设置smtp服务器地址、邮箱地址、密码等信息
14 | 
15 | ### 升级日志
16 | 
17 | ##### 2.0.0 Upgrade at 2014-04-25
18 | 
19 | 版本要求：需要 Typecho `0.9 (13.12.12)`
20 | 
21 | 注意：由于此版本改动较大，请先在 插件管理 中心禁用该插件的低级版本，然后再上传插件并重新激活插件，配置设置
22 | - 添加支持后台评论管理回复评论发邮件
23 | - 添加设置发件人选项，可自由设置发件人名称
24 | - 添加测试发邮件功能
25 | - 添加邮件模板编辑功能
26 | - 支持socket 和 curl 两种方式异步触发请求
27 | 
28 | ##### 1.3.2 Upgrade at 2014-04-17
29 | - 更新PHPMailer邮件类至最新版
30 | - 修复0.9版不能发送邮件的BUG
31 | - 提高安全性，缓存文件读取一次后直接删除
32 | 
33 | ##### 1.3.1 Upgrade at 2014-02-18
34 | - 修复回复评论时不发送邮件的BUG
35 | - 优化邮件发送效率
36 | 
37 | ##### 1.3.0 Upgrade at 2014-01-21
38 |  - 添加联系我邮箱配置
39 |  
40 | ##### 1.2.6 Upgrade at 2012-07-11
41 | - 修复接收邮箱为空时 无法获取 博主邮箱 导致无法发送邮件的BUG
42 | - 修复已经设置邮件标题 却无效的BUG
43 | - 修复评论者对博主的回复进行回复时，发送邮件的格式依然选择博主格式时的逻辑BUG
44 | - 修复由于没有设置字符类型 和 编码类型 可能导致邮件乱码的BUG，字符类型设置为 UTF-8，编码类型为 base64
45 | - 修复评论时间  时错误的BUG
46 | - 邮件标题增加不能为空的校验
47 | - 整理代码格式，提高可读性
48 | 
49 | 


--------------------------------------------------------------------------------
/page/console.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | include 'header.php';
 3 | include 'menu.php';
 4 | 
 5 | $current = $request->get('act', 'index');
 6 | $theme = $request->get('file', 'owner.html');
 7 | $title = $current == 'index' ? $menu->title : '编辑邮件模板 ' . $theme;
 8 | ?>
 9 | 
10 | <div class="main">
11 |     <div class="body container">
12 |         <div class="typecho-page-title">
13 |             <h2><?=$title?></h2>
14 |         </div>
15 |         <div class="row typecho-page-main" role="main">
16 |             <div class="col-mb-12">
17 |                 <ul class="typecho-option-tabs fix-tabs clearfix">
18 |                     <li<?=($current == 'index' ? ' class="current"' : '')?>><a href="<?php $options->adminUrl('extending.php?panel=' . CommentToMail_Plugin::$panel); ?>"><?php _e('邮件发送测试'); ?></a></li>
19 |                     <li<?=($current == 'theme' ? ' class="current"' : '')?>><a href="<?php $options->adminUrl('extending.php?panel=' . CommentToMail_Plugin::$panel . '&act=theme'); ?>">
20 |                     <?php _e('编辑邮件模板'); ?>
21 |                     </a></li>
22 |                     <li><a href="<?php $options->adminUrl('options-plugin.php?config=CommentToMail') ?>"><?php _e('插件设置'); ?></a></li>
23 |                 </ul>
24 |             </div>
25 |             
26 |             <?php if ($current == 'index'): ?>
27 |             <div class="typecho-edit-theme">
28 |                 <div class="col-mb-12 col-tb-8 col-9 content">
29 |                     <?php Typecho_Widget::widget('CommentToMail_Console')->testMailForm()->render(); ?>
30 |                 </div>
31 |             </div>
32 |             <?php else:
33 |                 Typecho_Widget::widget('CommentToMail_Console')->to($files);
34 |             ?>
35 |             <div class="typecho-edit-theme">
36 |                 <div class="col-mb-12 col-tb-8 col-9 content">
37 |                     <form method="post" name="theme" id="theme" action="<?php $options->index('/action/' . CommentToMail_Plugin::$action); ?>">
38 |                         <label for="content" class="sr-only"><?php _e('编辑源码'); ?></label>
39 |                         <textarea name="content" id="content" class="w-100 mono" <?php if(!$files->currentIsWriteable()): ?>readonly<?php endif; ?>><?php echo $files->currentContent(); ?></textarea>
40 |                         <p class="submit">
41 |                             <?php if($files->currentIsWriteable()): ?>
42 |                             <input type="hidden" name="do" value="editTheme" />
43 |                             <input type="hidden" name="edit" value="<?php echo $files->currentFile(); ?>" />
44 |                             <button type="submit" class="btn primary"><?php _e('保存文件'); ?></button>
45 |                             <?php else: ?>
46 |                                 <em><?php _e('此文件无法写入'); ?></em>
47 |                             <?php endif; ?>
48 |                         </p>
49 |                     </form>
50 |                 </div>
51 |                 <ul class="col-mb-12 col-tb-4 col-3">
52 |                     <li><strong>模板文件</strong></li>
53 |                     <?php while($files->next()): ?>
54 |                     <li<?php if($files->current): ?> class="current"<?php endif; ?>>
55 |                     <a href="<?php $options->adminUrl('extending.php?panel=' . CommentToMail_Plugin::$panel . '&act=theme' . '&file=' . $files->file); ?>"><?php $files->file(); ?></a></li>
56 |                     <?php endwhile; ?>
57 |                 </ul>
58 |             </div>
59 |             <?php endif; ?>
60 |         </div>
61 |     </div>
62 | </div>
63 | 
64 | <?php
65 | include 'copyright.php';
66 | include 'common-js.php';
67 | include 'footer.php';
68 | ?>
69 | 


--------------------------------------------------------------------------------
/Console.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * 评论邮件提醒 控制台
  4 |  *
  5 |  * @copyright  Copyright (c) 2014 Byends (http://www.byends.com)
  6 |  * @license    GNU General Public License 2.0
  7 |  */
  8 | class CommentToMail_Console extends Typecho_Widget
  9 | {
 10 |     /** @var  模板文件目录 */
 11 |     private $_dir;
 12 |     /**
 13 |      * 当前文件
 14 |      *
 15 |      * @access private
 16 |      * @var string
 17 |      */
 18 |     private $_currentFile;
 19 |     
 20 |     /**
 21 |      * 执行函数
 22 |      *
 23 |      * @access public
 24 |      * @return void
 25 |      * @throws Typecho_Widget_Exception
 26 |      */
 27 |     public function execute()
 28 |     {
 29 |         /** 管理员权限 */
 30 |         $this->widget('Widget_User')->pass('administrator');
 31 |         $this->_dir = dirname(__FILE__);
 32 |         $files = glob($this->_dir . '/*.{html,HTML}', GLOB_BRACE);
 33 |         $this->_currentFile = $this->request->get('file', 'owner.html');
 34 | 
 35 |         if (preg_match("/^([_0-9a-z-\.\ ])+$/i", $this->_currentFile)
 36 |             && file_exists($this->_dir . '/' . $this->_currentFile)) {
 37 |             foreach ($files as $file) {
 38 |                 if (file_exists($file)) {
 39 |                     $file = basename($file);
 40 |                     $this->push(array(
 41 |                         'file'      =>  $file,
 42 |                         'current'   =>  ($file == $this->_currentFile)
 43 |                     ));
 44 |                 }
 45 |             }
 46 | 
 47 |             return;
 48 |         }
 49 | 
 50 |         throw new Typecho_Widget_Exception('模板文件不存在', 404);
 51 |     }
 52 | 
 53 |     /**
 54 |      * 获取菜单标题
 55 |      *
 56 |      * @access public
 57 |      * @return string
 58 |      */
 59 |     public function getMenuTitle()
 60 |     {
 61 |         return _t('编辑文件 %s', $this->_currentFile);
 62 |     }
 63 | 
 64 |     /**
 65 |      * 获取文件内容
 66 |      *
 67 |      * @access public
 68 |      * @return string
 69 |      */
 70 |     public function currentContent()
 71 |     {
 72 |         return htmlspecialchars(file_get_contents($this->_dir . '/' . $this->_currentFile));
 73 |     }
 74 | 
 75 |     /**
 76 |      * 获取文件是否可读
 77 |      *
 78 |      * @access public
 79 |      * @return string
 80 |      */
 81 |     public function currentIsWriteable()
 82 |     {
 83 |         return is_writeable($this->_dir . '/' . $this->_currentFile);
 84 |     }
 85 | 
 86 |     /**
 87 |      * 获取当前文件
 88 |      *
 89 |      * @access public
 90 |      * @return string
 91 |      */
 92 |     public function currentFile()
 93 |     {
 94 |         return $this->_currentFile;
 95 |     }
 96 |     
 97 |     /**
 98 |      * 邮件测试表单
 99 |      * @return Typecho_Widget_Helper_Form
100 |      */
101 |     public function testMailForm()
102 |     {
103 |         /** 构建表单 */
104 |         $options = Typecho_Widget::widget('Widget_Options');
105 |         $form = new Typecho_Widget_Helper_Form(Typecho_Common::url('/action/' . CommentToMail_Plugin::$action, $options->index),
106 |             Typecho_Widget_Helper_Form::POST_METHOD);
107 | 
108 |         /** 收件人名称 */
109 |         $toName = new Typecho_Widget_Helper_Form_Element_Text('toName', NULL, NULL, _t('收件人名称'), _t('为空则使用博主昵称'));
110 |         $form->addInput($toName);
111 | 
112 |         /** 收件人邮箱 */
113 |         $to = new Typecho_Widget_Helper_Form_Element_Text('to', NULL, NULL, _t('收件人邮箱'), _t('为空则使用博主邮箱'));
114 |         $form->addInput($to);
115 | 
116 |         /** 邮件标题 */
117 |         $title = new Typecho_Widget_Helper_Form_Element_Text('title', NULL, NULL, _t('邮件标题 *'));
118 |         $form->addInput($title);
119 | 
120 |         /** 邮件内容 */
121 |         $content = new Typecho_Widget_Helper_Form_Element_Textarea('content', NULL, NULL, _t('邮件内容 *'));
122 |         $content->input->setAttribute('class', 'w-100 mono');
123 |         $form->addInput($content);
124 | 
125 |         /** 动作 */
126 |         $do = new Typecho_Widget_Helper_Form_Element_Hidden('do');
127 |         $form->addInput($do);
128 | 
129 |         /** 提交按钮 */
130 |         $submit = new Typecho_Widget_Helper_Form_Element_Submit();
131 |         $submit->input->setAttribute('class', 'btn primary');
132 |         $form->addItem($submit);
133 | 
134 |         /** 设置值 */
135 |         $do->value('testMail');
136 |         $submit->value('发送邮件');
137 | 
138 |         /** 添加规则 */
139 |         $to->addRule('email', _t('邮箱地址不正确'));
140 |         $title->addRule('required', _t('必须填写邮件标题'));
141 |         $content->addRule('required', _t('必须填写邮件内容'));
142 | 
143 |         return $form;
144 |     }
145 | }


--------------------------------------------------------------------------------
/Plugin.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * 评论邮件提醒插件
  4 |  *
  5 |  * @package CommentToMail
  6 |  * @author Byends Upd.
  7 |  * @version 2.0.1
  8 |  * @link http://www.byends.com
  9 |  * @oriAuthor DEFE (http://defe.me)
 10 |  * 
 11 |  * 原作者是 DEFE (http://defe.me),请尊重版权
 12 |  *
 13 |  */
 14 | class CommentToMail_Plugin implements Typecho_Plugin_Interface
 15 | {
 16 |     /** @var string 提交路由前缀 */
 17 |     public static $action = 'comment-to-mail';
 18 |     
 19 |     /** @var string 控制菜单链接 */
 20 |     public static $panel  = 'CommentToMail/page/console.php';
 21 | 
 22 |     /** @var bool 是否记录日志 */
 23 |     private static $_isMailLog  = false;
 24 |     
 25 |     /** @var bool 请求适配器 */
 26 |     private static $_adapter    = false;
 27 | 
 28 |     /**
 29 |      * 激活插件方法,如果激活失败,直接抛出异常
 30 |      *
 31 |      * @access public
 32 |      * @return void
 33 |      * @throws Typecho_Plugin_Exception
 34 |      */
 35 |     public static function activate()
 36 |     {
 37 |         if (false == self::isAvailable()) {
 38 |             throw new Typecho_Plugin_Exception(_t('对不起, 您的主机没有打开 allow_url_fopen 功能而且不支持 php-curl 扩展, 无法正常使用此功能'));
 39 |         }
 40 |         
 41 |         if (false == self::isWritable(dirname(__FILE__) . '/cache/')) {
 42 |             throw new Typecho_Plugin_Exception(_t('对不起，插件目录不可写，无法正常使用此功能'));
 43 |         }
 44 | 
 45 |         Typecho_Plugin::factory('Widget_Feedback')->finishComment = array('CommentToMail_Plugin', 'parseComment');
 46 |         Typecho_Plugin::factory('Widget_Comments_Edit')->finishComment = array('CommentToMail_Plugin', 'parseComment');
 47 |         Helper::addAction(self::$action, 'CommentToMail_Action');
 48 |         Helper::addPanel(1, self::$panel, '评论邮件提醒', '评论邮件提醒控制台', 'administrator');
 49 | 
 50 |         return _t('请设置邮箱信息，以使插件正常使用！');
 51 |     }
 52 | 
 53 |     /**
 54 |      * 禁用插件方法,如果禁用失败,直接抛出异常
 55 |      *
 56 |      * @static
 57 |      * @access public
 58 |      * @return void
 59 |      * @throws Typecho_Plugin_Exception
 60 |      */
 61 |     public static function deactivate()
 62 |     {
 63 |         Helper::removeAction(self::$action);
 64 |         Helper::removePanel(1, self::$panel);
 65 |     }
 66 | 
 67 |     /**
 68 |      * 获取插件配置面板
 69 |      *
 70 |      * @access public
 71 |      * @param Typecho_Widget_Helper_Form $form 配置面板
 72 |      * @return void
 73 |      */
 74 |     public static function config(Typecho_Widget_Helper_Form $form)
 75 |     {
 76 |         $mode= new Typecho_Widget_Helper_Form_Element_Radio('mode',
 77 |                 array( 'smtp' => 'smtp',
 78 |                        'mail' => 'mail()',
 79 |                        'sendmail' => 'sendmail()'),
 80 |                 'smtp', '发信方式');
 81 |         $form->addInput($mode);
 82 | 
 83 |         $host = new Typecho_Widget_Helper_Form_Element_Text('host', NULL, 'smtp.',
 84 |                 _t('SMTP地址'), _t('请填写 SMTP 服务器地址'));
 85 |         $form->addInput($host->addRule('required', _t('必须填写一个SMTP服务器地址')));
 86 | 
 87 |         $port = new Typecho_Widget_Helper_Form_Element_Text('port', NULL, '25',
 88 |                 _t('SMTP端口'), _t('SMTP服务端口,一般为25。'));
 89 |         $port->input->setAttribute('class', 'mini');
 90 |         $form->addInput($port->addRule('required', _t('必须填写SMTP服务端口'))
 91 |                 ->addRule('isInteger', _t('端口号必须是纯数字')));
 92 | 
 93 |         $user = new Typecho_Widget_Helper_Form_Element_Text('user', NULL, NULL,
 94 |                 _t('SMTP用户'),_t('SMTP服务验证用户名,一般为邮箱名如：youname@domain.com'));
 95 |         $form->addInput($user->addRule('required', _t('SMTP服务验证用户名')));
 96 | 
 97 |         $pass = new Typecho_Widget_Helper_Form_Element_Password('pass', NULL, NULL,
 98 |                 _t('SMTP密码'));
 99 |         $form->addInput($pass->addRule('required', _t('SMTP服务验证密码')));
100 | 
101 |         $validate = new Typecho_Widget_Helper_Form_Element_Checkbox('validate',
102 |                 array('validate'=>'服务器需要验证',
103 |                     'ssl'=>'ssl加密'),
104 |                 array('validate'),'SMTP验证');
105 |         $form->addInput($validate);
106 |         
107 |         $fromName = new Typecho_Widget_Helper_Form_Element_Text('fromName', NULL, NULL,
108 |                 _t('发件人名称'),_t('发件人名称，留空则使用博客标题'));
109 |         $form->addInput($fromName);
110 | 
111 |         $mail = new Typecho_Widget_Helper_Form_Element_Text('mail', NULL, NULL,
112 |                 _t('接收邮件的地址'),_t('接收邮件的地址,如为空则使用文章作者个人设置中的邮件地址！'));
113 |         $form->addInput($mail->addRule('email', _t('请填写正确的邮件地址！')));
114 | 
115 |         $contactme = new Typecho_Widget_Helper_Form_Element_Text('contactme', NULL, NULL,
116 |                 _t('模板中“联系我”的邮件地址'),_t('联系我用的邮件地址,如为空则使用文章作者个人设置中的邮件地址！'));
117 |         $form->addInput($contactme->addRule('email', _t('请填写正确的邮件地址！')));
118 | 
119 |         $status = new Typecho_Widget_Helper_Form_Element_Checkbox('status',
120 |                 array('approved' => '提醒已通过评论',
121 |                         'waiting' => '提醒待审核评论',
122 |                         'spam' => '提醒垃圾评论'),
123 |                 array('approved', 'waiting'), '提醒设置',_t('该选项仅针对博主，访客只发送已通过的评论。'));
124 |         $form->addInput($status);
125 | 
126 |         $other = new Typecho_Widget_Helper_Form_Element_Checkbox('other',
127 |                 array('to_owner' => '有评论及回复时，发邮件通知博主。',
128 |                     'to_guest' => '评论被回复时，发邮件通知评论者。',
129 |                     'to_me'=>'自己回复自己的评论时，发邮件通知。(同时针对博主和访客)',
130 |                     'to_log' => '记录邮件发送日志。'),
131 |                 array('to_owner','to_guest'), '其他设置',_t('选中该选项插件会在log/mailer_log.txt 文件中记录发送日志。'));
132 |         $form->addInput($other->multiMode());
133 | 
134 |         $titleForOwner = new Typecho_Widget_Helper_Form_Element_Text('titleForOwner',null,"[{title}] 一文有新的评论",
135 |                 _t('博主接收邮件标题'));
136 |         $form->addInput($titleForOwner->addRule('required', _t('博主接收邮件标题 不能为空')));
137 | 
138 |         $titleForGuest = new Typecho_Widget_Helper_Form_Element_Text('titleForGuest',null,"您在 [{title}] 的评论有了回复",
139 |                 _t('访客接收邮件标题'));
140 |         $form->addInput($titleForGuest->addRule('required', _t('访客接收邮件标题 不能为空')));
141 |     }
142 | 
143 |     /**
144 |      * 个人用户的配置面板
145 |      *
146 |      * @access public
147 |      * @param Typecho_Widget_Helper_Form $form
148 |      * @return void
149 |      */
150 |     public static function personalConfig(Typecho_Widget_Helper_Form $form)
151 |     {}
152 | 
153 |     /**
154 |      * 获取邮件内容
155 |      *
156 |      * @access public
157 |      * @param $comment 调用参数
158 |      * @return void
159 |      */
160 |     public static function parseComment($comment)
161 |     {        
162 |         $options           = Typecho_Widget::widget('Widget_Options');
163 |         $cfg = array(
164 |             'siteTitle' => $options->title,
165 |             'timezone'  => $options->timezone,
166 |             'cid'       => $comment->cid,
167 |             'coid'      => $comment->coid,
168 |             'created'   => $comment->created,
169 |             'author'    => $comment->author,
170 |             'authorId'  => $comment->authorId,
171 |             'ownerId'   => $comment->ownerId,
172 |             'mail'      => $comment->mail,
173 |             'ip'        => $comment->ip,
174 |             'title'     => $comment->title,
175 |             'text'      => $comment->text,
176 |             'permalink' => $comment->permalink,
177 |             'status'    => $comment->status,
178 |             'parent'    => $comment->parent,
179 |             'manage'    => $options->siteUrl . 'admin/manage-comments.php'
180 |         );
181 | 
182 |         self::$_isMailLog = in_array('to_log', Helper::options()->plugin('CommentToMail')->other) ? true : false;
183 | 
184 |         //是否接收邮件
185 |         if (isset($_POST['banmail']) && 'stop' == $_POST['banmail']) {
186 |             $cfg['banMail'] = 1;
187 |         } else {
188 |             $cfg['banMail'] = 0;
189 |         }
190 | 
191 |         $fileName = Typecho_Common::randString(7);
192 |         $cfg      = (object)$cfg;
193 |         file_put_contents(dirname(__FILE__) . '/cache/' . $fileName, serialize($cfg));
194 |         $url = ($options->rewrite) ? $options->siteUrl : $options->siteUrl . 'index.php';
195 |         $url = rtrim($url, '/') . '/action/' . self::$action . '?send=' . $fileName;
196 | 
197 |         $date = new Typecho_Date(Typecho_Date::gmtTime());
198 |         $time = $date->format('Y-m-d H:i:s');
199 |         
200 |         self::saveLog("{$time} 开始发送请求：{$url}\n");
201 |         self::asyncRequest($url);
202 |     }
203 | 
204 | 
205 | 
206 |     /**
207 |      * 发送异步请求
208 |      * @param $url
209 |      */
210 |     public static function asyncRequest($url)
211 |     {
212 |         self::isAvailable();
213 |         self::$_adapter == 'Socket' ? self::socket($url) : self::curl($url);
214 |     }
215 | 
216 |     /**
217 |      * Socket 请求
218 |      * @param $url
219 |      * @return bool
220 |      */
221 |     public static function socket($url)
222 |     {
223 |         $params = parse_url($url);
224 |         $path = $params['path'] . '?' . $params['query'];
225 |         $host = $params['host'];
226 |         $port = 80;
227 |         $scheme = '';
228 | 
229 |         if ('https' == $params['scheme']) {
230 |             $port = 443;
231 |             $scheme = 'ssl://';
232 |         }
233 | 
234 |         if (function_exists('fsockopen')) {
235 |             $fp = @fsockopen ($scheme . $host, $port, $errno, $errstr, 30);
236 |         } elseif (function_exists('pfsockopen')) {
237 |             $fp = @pfsockopen ($scheme . $host, $port, $errno, $errstr, 30);
238 |         } else {
239 |             $fp = stream_socket_client($scheme . $host . ":$port", $errno, $errstr, 30);
240 |         }
241 | 
242 |         if ($fp === false) {
243 |             self::saveLog("SOCKET错误," . $errno . ':' . $errstr);
244 |             return false;
245 |         }
246 | 
247 |         stream_set_blocking($fp, 0);
248 | 
249 |         $out = "GET " . $path . " HTTP/1.1\r\n";
250 |         $out .= "Host: $host\r\n";
251 |         $out .= "Connection: Close\r\n\r\n";
252 | 
253 |         self::saveLog("Socket 方式发送\r\n");
254 | 
255 |         fwrite($fp, $out);
256 |         fclose($fp);
257 |         self::saveLog("请求结束\r\n");
258 |     }
259 | 
260 |     /**
261 |      * Curl 请求
262 |      * @param $url
263 |      */
264 |     public static function curl($url)
265 |     {
266 |         $cmh = curl_multi_init();
267 |         $ch1 = curl_init();
268 |         curl_setopt($ch1, CURLOPT_URL, $url);
269 |         curl_multi_add_handle($cmh, $ch1);
270 |         curl_multi_exec($cmh, $active);
271 |         
272 |         self::saveLog("Curl 方式发送\r\n");
273 |         
274 |         curl_multi_remove_handle($cmh, $ch1);
275 |         curl_multi_close($cmh);
276 |         self::saveLog("请求结束\r\n");
277 |     }
278 | 
279 |     /**
280 |      * 检测 适配器
281 |      * @return string
282 |      */
283 |     public static function isAvailable()
284 |     {
285 |         function_exists('ini_get') && ini_get('allow_url_fopen') && (self::$_adapter = 'Socket');
286 |         false == self::$_adapter && function_exists('curl_version') && (self::$_adapter = 'Curl');
287 |         
288 |         return self::$_adapter;
289 |     }
290 | 
291 |     /**
292 |      * 检测 是否可写
293 |      * @param $file
294 |      * @return bool
295 |      */
296 |     public static function isWritable($file)
297 |     {
298 |         if (is_dir($file)) {
299 |             $dir = $file;
300 |             if ($fp = @fopen("$dir/check_writable", 'w')) {
301 |                 @fclose($fp);
302 |                 @unlink("$dir/check_writable");
303 |                 $writeable = true;
304 |             } else {
305 |                 $writeable = false;
306 |             }
307 |         } else {
308 |             if ($fp = @fopen($file, 'a+')) {
309 |                 @fclose($fp);
310 |                 $writeable = true;
311 |             } else {
312 |                 $writeable = false;
313 |             }
314 |         }
315 | 
316 |         return $writeable;
317 |     }
318 | 
319 |     /**
320 |      * 写入记录
321 |      * @param $content
322 |      * @return bool
323 |      */
324 |     public static function saveLog($content)
325 |     {
326 |         if (!self::$_isMailLog) {
327 |             return false;
328 |         }
329 | 
330 |         file_put_contents(dirname(__FILE__) . '/log/mailer_log.txt', $content, FILE_APPEND);
331 |     }
332 | }
333 | 


--------------------------------------------------------------------------------
/lib/class.pop3.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * PHPMailer POP-Before-SMTP Authentication Class.
  4 |  * PHP Version 5.0.0
  5 |  * Version 5.2.7
  6 |  * @package PHPMailer
  7 |  * @link https://github.com/PHPMailer/PHPMailer/
  8 |  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
  9 |  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
 10 |  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
 11 |  * @author Brent R. Matzelle (original founder)
 12 |  * @copyright 2013 Marcus Bointon
 13 |  * @copyright 2010 - 2012 Jim Jagielski
 14 |  * @copyright 2004 - 2009 Andy Prevost
 15 |  * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
 16 |  * @note This program is distributed in the hope that it will be useful - WITHOUT
 17 |  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |  * FITNESS FOR A PARTICULAR PURPOSE.
 19 |  */
 20 | 
 21 | /**
 22 |  * PHPMailer POP-Before-SMTP Authentication Class.
 23 |  * Specifically for PHPMailer to use for RFC1939 POP-before-SMTP authentication.
 24 |  * Does not support APOP.
 25 |  * @package PHPMailer
 26 |  * @author Richard Davey (original author) <rich@corephp.co.uk>
 27 |  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
 28 |  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
 29 |  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
 30 |  */
 31 | 
 32 | class POP3
 33 | {
 34 |     /**
 35 |      * The POP3 PHPMailer Version number.
 36 |      * @type string
 37 |      * @access public
 38 |      */
 39 |     public $Version = '5.2.7';
 40 | 
 41 |     /**
 42 |      * Default POP3 port number.
 43 |      * @type int
 44 |      * @access public
 45 |      */
 46 |     public $POP3_PORT = 110;
 47 | 
 48 |     /**
 49 |      * Default timeout in seconds.
 50 |      * @type int
 51 |      * @access public
 52 |      */
 53 |     public $POP3_TIMEOUT = 30;
 54 | 
 55 |     /**
 56 |      * POP3 Carriage Return + Line Feed.
 57 |      * @type string
 58 |      * @access public
 59 |      * @deprecated Use the constant instead
 60 |      */
 61 |     public $CRLF = "\r\n";
 62 | 
 63 |     /**
 64 |      * Debug display level.
 65 |      * Options: 0 = no, 1+ = yes
 66 |      * @type int
 67 |      * @access public
 68 |      */
 69 |     public $do_debug = 0;
 70 | 
 71 |     /**
 72 |      * POP3 mail server hostname.
 73 |      * @type string
 74 |      * @access public
 75 |      */
 76 |     public $host;
 77 | 
 78 |     /**
 79 |      * POP3 port number.
 80 |      * @type int
 81 |      * @access public
 82 |      */
 83 |     public $port;
 84 | 
 85 |     /**
 86 |      * POP3 Timeout Value in seconds.
 87 |      * @type int
 88 |      * @access public
 89 |      */
 90 |     public $tval;
 91 | 
 92 |     /**
 93 |      * POP3 username
 94 |      * @type string
 95 |      * @access public
 96 |      */
 97 |     public $username;
 98 | 
 99 |     /**
100 |      * POP3 password.
101 |      * @type string
102 |      * @access public
103 |      */
104 |     public $password;
105 | 
106 |     /**
107 |      * Resource handle for the POP3 connection socket.
108 |      * @type resource
109 |      * @access private
110 |      */
111 |     private $pop_conn;
112 | 
113 |     /**
114 |      * Are we connected?
115 |      * @type bool
116 |      * @access private
117 |      */
118 |     private $connected;
119 | 
120 |     /**
121 |      * Error container.
122 |      * @type array
123 |      * @access private
124 |      */
125 |     private $error;
126 | 
127 |     /**
128 |      * Line break constant
129 |      */
130 |     const CRLF = "\r\n";
131 | 
132 |     /**
133 |      * Constructor.
134 |      * @access public
135 |      */
136 |     public function __construct()
137 |     {
138 |         $this->pop_conn = 0;
139 |         $this->connected = false;
140 |         $this->error = null;
141 |     }
142 | 
143 |     /**
144 |      * Simple static wrapper for all-in-one POP before SMTP
145 |      * @param $host
146 |      * @param bool $port
147 |      * @param bool $tval
148 |      * @param string $username
149 |      * @param string $password
150 |      * @param int $debug_level
151 |      * @return bool
152 |      */
153 |     public static function popBeforeSmtp(
154 |         $host,
155 |         $port = false,
156 |         $tval = false,
157 |         $username = '',
158 |         $password = '',
159 |         $debug_level = 0
160 |     ) {
161 |         $pop = new POP3;
162 |         return $pop->authorise($host, $port, $tval, $username, $password, $debug_level);
163 |     }
164 | 
165 |     /**
166 |      * Authenticate with a POP3 server.
167 |      * A connect, login, disconnect sequence
168 |      * appropriate for POP-before SMTP authorisation.
169 |      * @access public
170 |      * @param string $host
171 |      * @param bool|int $port
172 |      * @param bool|int $tval
173 |      * @param string $username
174 |      * @param string $password
175 |      * @param int $debug_level
176 |      * @return bool
177 |      */
178 |     public function authorise($host, $port = false, $tval = false, $username = '', $password = '', $debug_level = 0)
179 |     {
180 |         $this->host = $host;
181 |         // If no port value provided, use default
182 |         if ($port === false) {
183 |             $this->port = $this->POP3_PORT;
184 |         } else {
185 |             $this->port = $port;
186 |         }
187 |         // If no timeout value provided, use default
188 |         if ($tval === false) {
189 |             $this->tval = $this->POP3_TIMEOUT;
190 |         } else {
191 |             $this->tval = $tval;
192 |         }
193 |         $this->do_debug = $debug_level;
194 |         $this->username = $username;
195 |         $this->password = $password;
196 |         //  Refresh the error log
197 |         $this->error = null;
198 |         //  connect
199 |         $result = $this->connect($this->host, $this->port, $this->tval);
200 |         if ($result) {
201 |             $login_result = $this->login($this->username, $this->password);
202 |             if ($login_result) {
203 |                 $this->disconnect();
204 |                 return true;
205 |             }
206 |         }
207 |         // We need to disconnect regardless of whether the login succeeded
208 |         $this->disconnect();
209 |         return false;
210 |     }
211 | 
212 |     /**
213 |      * Connect to a POP3 server.
214 |      * @access public
215 |      * @param string $host
216 |      * @param bool|int $port
217 |      * @param integer $tval
218 |      * @return boolean
219 |      */
220 |     public function connect($host, $port = false, $tval = 30)
221 |     {
222 |         //  Are we already connected?
223 |         if ($this->connected) {
224 |             return true;
225 |         }
226 | 
227 |         //On Windows this will raise a PHP Warning error if the hostname doesn't exist.
228 |         //Rather than suppress it with @fsockopen, capture it cleanly instead
229 |         set_error_handler(array($this, 'catchWarning'));
230 | 
231 |         //  connect to the POP3 server
232 |         $this->pop_conn = fsockopen(
233 |             $host, //  POP3 Host
234 |             $port, //  Port #
235 |             $errno, //  Error Number
236 |             $errstr, //  Error Message
237 |             $tval
238 |         ); //  Timeout (seconds)
239 |         //  Restore the error handler
240 |         restore_error_handler();
241 |         //  Does the Error Log now contain anything?
242 |         if ($this->error && $this->do_debug >= 1) {
243 |             $this->displayErrors();
244 |         }
245 |         //  Did we connect?
246 |         if ($this->pop_conn == false) {
247 |             //  It would appear not...
248 |             $this->error = array(
249 |                 'error' => "Failed to connect to server $host on port $port",
250 |                 'errno' => $errno,
251 |                 'errstr' => $errstr
252 |             );
253 |             if ($this->do_debug >= 1) {
254 |                 $this->displayErrors();
255 |             }
256 |             return false;
257 |         }
258 | 
259 |         //  Increase the stream time-out
260 |         //  Check for PHP 4.3.0 or later
261 |         if (version_compare(phpversion(), '5.0.0', 'ge')) {
262 |             stream_set_timeout($this->pop_conn, $tval, 0);
263 |         } else {
264 |             //  Does not work on Windows
265 |             if (substr(PHP_OS, 0, 3) !== 'WIN') {
266 |                 socket_set_timeout($this->pop_conn, $tval, 0);
267 |             }
268 |         }
269 | 
270 |         //  Get the POP3 server response
271 |         $pop3_response = $this->getResponse();
272 |         //  Check for the +OK
273 |         if ($this->checkResponse($pop3_response)) {
274 |             //  The connection is established and the POP3 server is talking
275 |             $this->connected = true;
276 |             return true;
277 |         }
278 |         return false;
279 |     }
280 | 
281 |     /**
282 |      * Log in to the POP3 server.
283 |      * Does not support APOP (RFC 2828, 4949).
284 |      * @access public
285 |      * @param string $username
286 |      * @param string $password
287 |      * @return boolean
288 |      */
289 |     public function login($username = '', $password = '')
290 |     {
291 |         if ($this->connected == false) {
292 |             $this->error = 'Not connected to POP3 server';
293 | 
294 |             if ($this->do_debug >= 1) {
295 |                 $this->displayErrors();
296 |             }
297 |         }
298 |         if (empty($username)) {
299 |             $username = $this->username;
300 |         }
301 |         if (empty($password)) {
302 |             $password = $this->password;
303 |         }
304 | 
305 |         // Send the Username
306 |         $this->sendString("USER $username" . self::CRLF);
307 |         $pop3_response = $this->getResponse();
308 |         if ($this->checkResponse($pop3_response)) {
309 |             // Send the Password
310 |             $this->sendString("PASS $password" . self::CRLF);
311 |             $pop3_response = $this->getResponse();
312 |             if ($this->checkResponse($pop3_response)) {
313 |                 return true;
314 |             }
315 |         }
316 |         return false;
317 |     }
318 | 
319 |     /**
320 |      * Disconnect from the POP3 server.
321 |      * @access public
322 |      */
323 |     public function disconnect()
324 |     {
325 |         $this->sendString('QUIT');
326 |         //The QUIT command may cause the daemon to exit, which will kill our connection
327 |         //So ignore errors here
328 |         @fclose($this->pop_conn);
329 |     }
330 | 
331 |     /**
332 |      * Get a response from the POP3 server.
333 |      * $size is the maximum number of bytes to retrieve
334 |      * @param integer $size
335 |      * @return string
336 |      * @access private
337 |      */
338 |     private function getResponse($size = 128)
339 |     {
340 |         $r = fgets($this->pop_conn, $size);
341 |         if ($this->do_debug >= 1) {
342 |             echo "Server -> Client: $r";
343 |         }
344 |         return $r;
345 |     }
346 | 
347 |     /**
348 |      * Send raw data to the POP3 server.
349 |      * @param string $string
350 |      * @return integer
351 |      * @access private
352 |      */
353 |     private function sendString($string)
354 |     {
355 |         if ($this->pop_conn) {
356 |             if ($this->do_debug >= 2) { //Show client messages when debug >= 2
357 |                 echo "Client -> Server: $string";
358 |             }
359 |             return fwrite($this->pop_conn, $string, strlen($string));
360 |         }
361 |         return 0;
362 |     }
363 | 
364 |     /**
365 |      * Checks the POP3 server response.
366 |      * Looks for for +OK or -ERR.
367 |      * @param string $string
368 |      * @return boolean
369 |      * @access private
370 |      */
371 |     private function checkResponse($string)
372 |     {
373 |         if (substr($string, 0, 3) !== '+OK') {
374 |             $this->error = array(
375 |                 'error' => "Server reported an error: $string",
376 |                 'errno' => 0,
377 |                 'errstr' => ''
378 |             );
379 |             if ($this->do_debug >= 1) {
380 |                 $this->displayErrors();
381 |             }
382 |             return false;
383 |         } else {
384 |             return true;
385 |         }
386 |     }
387 | 
388 |     /**
389 |      * Display errors if debug is enabled.
390 |      * @access private
391 |      */
392 |     private function displayErrors()
393 |     {
394 |         echo '<pre>';
395 |         foreach ($this->error as $single_error) {
396 |             print_r($single_error);
397 |         }
398 |         echo '</pre>';
399 |     }
400 | 
401 |     /**
402 |      * POP3 connection error handler.
403 |      * @param integer $errno
404 |      * @param string $errstr
405 |      * @param string $errfile
406 |      * @param integer $errline
407 |      * @access private
408 |      */
409 |     private function catchWarning($errno, $errstr, $errfile, $errline)
410 |     {
411 |         $this->error[] = array(
412 |             'error' => "Connecting to the POP3 server raised a PHP warning: ",
413 |             'errno' => $errno,
414 |             'errstr' => $errstr,
415 |             'errfile' => $errfile,
416 |             'errline' => $errline
417 |         );
418 |     }
419 | }
420 | 


--------------------------------------------------------------------------------
/Action.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * CommentToMail Plugin
  4 |  * 异步发送提醒邮件到博主或访客的邮箱
  5 |  * 
  6 |  * @copyright  Copyright (c) 2014 Byends (http://www.byends.com)
  7 |  * @license    GNU General Public License 2.0
  8 |  */
  9 | class CommentToMail_Action extends Typecho_Widget implements Widget_Interface_Do
 10 | {
 11 |     /** @var  数据操作对象 */
 12 |     private $_db;
 13 |     
 14 |     /** @var  插件根目录 */
 15 |     private $_dir;
 16 |     
 17 |     /** @var  插件配置信息 */
 18 |     private $_cfg;
 19 |     
 20 |     /** @var  系统配置信息 */
 21 |     private $_options;
 22 |     
 23 |     /** @var bool 是否记录日志 */
 24 |     private $_isMailLog = false;
 25 |     
 26 |     /** @var 当前登录用户 */
 27 |     private $_user;
 28 |     
 29 |     /** @var  邮件内容信息 */
 30 |     private  $_email;
 31 | 
 32 |     /**
 33 |      * 读取缓存文件内容
 34 |      */
 35 |     public function process($fileName)
 36 |     {
 37 |         ignore_user_abort(TRUE);
 38 |         $this->init();
 39 |         //获取评论内容
 40 |         $file = $this->_dir . '/cache/' . $fileName;
 41 |         if (file_exists($file)) {
 42 |             $this->_email = unserialize(file_get_contents($file));
 43 |             @unlink($file);
 44 | 
 45 |             if (!$this->_user->simpleLogin($this->_email->ownerId)) {
 46 |                 $this->widget('Widget_Archive@404', 'type=404')->render();
 47 |                 exit;
 48 |             }
 49 |         } else {
 50 |             $this->widget('Widget_Archive@404', 'type=404')->render();
 51 |             exit;
 52 |         }
 53 |         
 54 |         //如果本次评论设置了拒收邮件，把coid加入拒收列表
 55 |         if ($this->_email->banMail) {
 56 |             $this->ban($this->_email->coid, true);
 57 |         }
 58 | 
 59 |         //发件人邮箱
 60 |         $this->_email->from = $this->_cfg->user;
 61 | 
 62 |         //发件人名称
 63 |         $this->_email->fromName = $this->_cfg->fromName ? $this->_cfg->fromName : $this->_email->siteTitle;
 64 | 
 65 |         //向博主发邮件的标题格式
 66 |         $this->_email->titleForOwner = $this->_cfg->titleForOwner;
 67 | 
 68 |         //向访客发邮件的标题格式
 69 |         $this->_email->titleForGuest = $this->_cfg->titleForGuest;
 70 |         
 71 |         //验证博主是否接收自己的邮件
 72 |         $toMe = (in_array('to_me', $this->_cfg->other) && $this->_email->ownerId == $this->_email->authorId) ? true : false;
 73 | 
 74 |         //向博主发信
 75 |         if (in_array($this->_email->status, $this->_cfg->status) && in_array('to_owner', $this->_cfg->other)
 76 |             && ( $toMe || $this->_email->ownerId != $this->_email->authorId) && 0 == $this->_email->parent ) {
 77 |             if (empty($this->_cfg->mail)) {
 78 |                 Typecho_Widget::widget('Widget_Users_Author@temp' . $this->_email->cid, array('uid' => $this->_email->ownerId))->to($user);
 79 |             	$this->_email->to = $user->mail;
 80 |             } else {
 81 |                 $this->_email->to = $this->_cfg->mail;
 82 |             }
 83 | 
 84 |             $this->authorMail()->sendMail();
 85 |         }
 86 | 
 87 |         //向访客发信
 88 |         if (0 != $this->_email->parent 
 89 |             && 'approved' == $this->_email->status 
 90 |             && in_array('to_guest', $this->_cfg->other)
 91 |             && !$this->ban($this->_email->parent)) {
 92 |             //如果联系我的邮件地址为空，则使用文章作者的邮件地址
 93 |             if (empty($this->_email->contactme)) {
 94 |                 if (!isset($user) || !$user) {
 95 |                     Typecho_Widget::widget('Widget_Users_Author@temp' . $this->_email->cid, array('uid' => $this->_email->ownerId))->to($user);
 96 |                 }
 97 |                 $this->_email->contactme = $user->mail;
 98 |             } else {
 99 |                 $this->_email->contactme = $this->_cfg->contactme;
100 |             }
101 | 
102 |             $original = $this->_db->fetchRow($this->_db->select('author', 'mail', 'text')
103 |                                                        ->from('table.comments')
104 |                                                        ->where('coid = ?', $this->_email->parent));
105 | 
106 |             if (in_array('to_me', $this->_cfg->other) 
107 |                 || $this->_email->mail != $original['mail']) {
108 |                 $this->_email->to             = $original['mail'];
109 |                 $this->_email->originalText   = $original['text'];
110 |                 $this->_email->originalAuthor = $original['author'];
111 |                 $this->guestMail()->sendMail();
112 |             }
113 |         }
114 | 
115 |         $date = new Typecho_Date(Typecho_Date::gmtTime());
116 |         $time = $date->format('Y-m-d H:i:s');
117 |         $this->mailLog(false, $time . " 邮件发送完毕!\r\n");
118 |     }
119 | 
120 |     /**
121 |      * 作者邮件信息
122 |      * @return $this
123 |      */
124 |     public function authorMail()
125 |     {
126 |         $this->_email->toName = $this->_email->siteTitle;
127 |         $date = new Typecho_Date($this->_email->created);
128 |         $time = $date->format('Y-m-d H:i:s');
129 |         $status = array(
130 |             "approved" => '通过',
131 |             "waiting"  => '待审',
132 |             "spam"     => '垃圾'
133 |         );
134 |         $search  = array(
135 |             '{siteTitle}',
136 |             '{title}',
137 |             '{author}',
138 |             '{ip}',
139 |             '{mail}',
140 |             '{permalink}',
141 |             '{manage}',
142 |             '{text}',
143 |             '{time}',
144 |             '{status}'
145 |         );
146 |         $replace = array(
147 |             $this->_email->siteTitle,
148 |             $this->_email->title,
149 |             $this->_email->author,
150 |             $this->_email->ip,
151 |             $this->_email->mail,
152 |             $this->_email->permalink,
153 |             $this->_email->manage,
154 |             $this->_email->text,
155 |             $time,
156 |             $status[$this->_email->status]
157 |         );
158 | 
159 |         $this->_email->msgHtml = str_replace($search, $replace, $this->getTemplate('owner'));
160 |         $this->_email->subject = str_replace($search, $replace, $this->_email->titleForOwner);
161 |         $this->_email->altBody = "作者：".$this->_email->author."\r\n链接：".$this->_email->permalink."\r\n评论：\r\n".$this->_email->text;
162 | 
163 |         return $this;
164 |     }
165 | 
166 |     /**
167 |      * 访问邮件信息
168 |      * @return $this
169 |      */
170 |     public function guestMail()
171 |     {
172 |         $this->_email->toName = $this->_email->originalAuthor ? $this->_email->originalAuthor : $this->_email->siteTitle;
173 |         $date    = new Typecho_Date($this->_email->created);
174 |         $time    = $date->format('Y-m-d H:i:s');
175 |         $search  = array(
176 |             '{siteTitle}',
177 |             '{title}',
178 |             '{author_p}',
179 |             '{author}',
180 |             '{permalink}',
181 |             '{text}',
182 |             '{contactme}',
183 |             '{text_p}',
184 |             '{time}'
185 |         );
186 |         $replace = array(
187 |             $this->_email->siteTitle,
188 |             $this->_email->title,
189 |             $this->_email->originalAuthor,
190 |             $this->_email->author,
191 |             $this->_email->permalink,
192 |             $this->_email->text,
193 |             $this->_email->contactme,
194 |             $this->_email->originalText,
195 |             $time
196 |         );
197 | 
198 |         $this->_email->msgHtml = str_replace($search, $replace, $this->getTemplate('guest'));
199 |         $this->_email->subject = str_replace($search, $replace, $this->_email->titleForGuest);
200 |         $this->_email->altBody = "作者：".$this->_email->author."\r\n链接：".$this->_email->permalink."\r\n评论：\r\n".$this->_email->text;
201 | 
202 |         return $this;
203 |     }
204 | 
205 |     /*
206 |      * 发送邮件
207 |      */
208 |     public function sendMail()
209 |     {
210 |         /** 载入邮件组件 */
211 |         require_once $this->_dir . '/lib/class.phpmailer.php';
212 |         $mailer = new PHPMailer();
213 |         $mailer->CharSet = 'UTF-8';
214 |         $mailer->Encoding = 'base64';
215 | 
216 |         //选择发信模式
217 |         switch ($this->_cfg->mode)
218 |         {
219 |             case 'mail':
220 |                 break;
221 |             case 'sendmail':
222 |                 $mailer->IsSendmail();
223 |                 break;
224 |             case 'smtp':
225 |                 $mailer->IsSMTP();
226 | 
227 |                 if (in_array('validate', $this->_cfg->validate)) {
228 |                     $mailer->SMTPAuth = true;
229 |                 }
230 | 
231 |                 if (in_array('ssl', $this->_cfg->validate)) {
232 |                     $mailer->SMTPSecure = "ssl";
233 |                 }
234 | 
235 |                 $mailer->Host     = $this->_cfg->host;
236 |                 $mailer->Port     = $this->_cfg->port;
237 |                 $mailer->Username = $this->_cfg->user;
238 |                 $mailer->Password = $this->_cfg->pass;
239 | 
240 |                 break;
241 |         }
242 | 
243 |         $mailer->SetFrom($this->_email->from, $this->_email->fromName);
244 |         $mailer->AddReplyTo($this->_email->to, $this->_email->toName);
245 |         $mailer->Subject = $this->_email->subject;
246 |         $mailer->AltBody = $this->_email->altBody;
247 |         $mailer->MsgHTML($this->_email->msgHtml);
248 |         $mailer->AddAddress($this->_email->to, $this->_email->toName);
249 | 
250 |         if ($result = $mailer->Send()) {
251 |             $this->mailLog();
252 |         } else {
253 |             $this->mailLog(false, $mailer->ErrorInfo . "\r\n");
254 |             $result = $mailer->ErrorInfo;
255 |         }
256 |         
257 |         $mailer->ClearAddresses();
258 |         $mailer->ClearReplyTos();
259 | 
260 |         return $result;
261 |     }
262 | 
263 |     /*
264 |      * 记录邮件发送日志和错误信息
265 |      */
266 |     public function mailLog($type = true, $content = null)
267 |     {
268 |         if (!$this->_isMailLog) {
269 |             return false;
270 |         }
271 | 
272 |         $fileName = $this->_dir . '/log/mailer_log.txt';
273 |         if ($type) {
274 |             $guest = explode('@', $this->_email->to);
275 |             $guest = substr($this->_email->to, 0, 1) . '***' . $guest[1];
276 |             $content  = $content ? $content : "向 " . $guest . " 发送邮件成功！\r\n";
277 |         }
278 | 
279 |         file_put_contents($fileName, $content, FILE_APPEND);
280 |     }
281 | 
282 |     /*
283 |      * 获取邮件正文模板
284 |      * $author owner为博主 guest为访客
285 |      */
286 |     public function getTemplate($template = 'owner')
287 |     {
288 |         $template .= '.html';
289 |         $filename = $this->_dir . '/' . $template;
290 | 
291 |         if (!file_exists($filename)) {
292 |            throw new Typecho_Widget_Exception('模板文件' . $template . '不存在', 404);
293 |         }
294 | 
295 |         return file_get_contents($this->_dir . '/' . $template);
296 |     }
297 | 
298 |     /*
299 |      * 验证原评论者是否接收评论
300 |      */
301 |     public function ban($parent, $isWrite = false)
302 |     {
303 |         if ($parent) {
304 |             $index    = ceil($parent / 500);
305 |             $filename = $this->_dir . '/log/ban_' . $index . '.list';
306 | 
307 |             if (!file_exists($filename)) {
308 |                 $list = array();
309 |                 file_put_contents($filename, serialize($list));
310 |             } else {
311 |                 $list = unserialize(file_get_contents($filename));
312 |             }
313 | 
314 |             //写入记录
315 |             if ($isWrite) {
316 |                 $list[$parent] = 1;
317 |                 file_put_contents($filename, serialize($list));
318 | 
319 |                 return true;
320 |             } else if (isset($list[$parent]) && $list[$parent]) {
321 |                 return true;
322 |             }
323 |         }
324 |         
325 |         return false;
326 |     }
327 | 
328 |     /**
329 |      * 邮件发送测试
330 |      */
331 |     public function testMail()
332 |     {
333 |         if (Typecho_Widget::widget('CommentToMail_Console')->testMailForm()->validate()) {
334 |             $this->response->goBack();
335 |         }
336 | 
337 |         $this->init();
338 |         $this->_isMailLog = true;
339 |         $email = $this->request->from('toName', 'to', 'title', 'content');
340 |         
341 |         $this->_email->from = $this->_cfg->user;
342 |         $this->_email->fromName = $this->_cfg->fromName ? $this->_cfg->fromName : $this->_options->title;
343 |         $this->_email->to = $email['to'] ? $email['to'] : $this->_user->mail;
344 |         $this->_email->toName = $email['toName'] ? $email['toName'] : $this->_user->screenName;
345 |         $this->_email->subject = $email['title'];
346 |         $this->_email->altBody = $email['content'];
347 |         $this->_email->msgHtml = $email['content'];
348 | 
349 |         $result = $this->sendMail();
350 | 
351 |         /** 提示信息 */
352 |         $this->widget('Widget_Notice')->set(true === $result ? _t('邮件发送成功') : _t('邮件发送失败：' . $result),
353 |             true === $result ? 'success' : 'notice');
354 | 
355 |         /** 转向原页 */
356 |         $this->response->goBack();
357 |     }
358 | 
359 |     /**
360 |      * 编辑模板文件
361 |      * @param $file
362 |      * @throws Typecho_Widget_Exception
363 |      */
364 |     public function editTheme($file)
365 |     {
366 |         $this->init();
367 |         $path = $this->_dir . '/' . $file;
368 | 
369 |         if (file_exists($path) && is_writeable($path)) {
370 |             $handle = fopen($path, 'wb');
371 |             if ($handle && fwrite($handle, $this->request->content)) {
372 |                 fclose($handle);
373 |                 $this->widget('Widget_Notice')->set(_t("文件 %s 的更改已经保存", $file), 'success');
374 |             } else {
375 |                 $this->widget('Widget_Notice')->set(_t("文件 %s 无法被写入", $file), 'error');
376 |             }
377 |             $this->response->goBack();
378 |         } else {
379 |             throw new Typecho_Widget_Exception(_t('您编辑的模板文件不存在'));
380 |         }
381 |     }
382 | 
383 |     /**
384 |      * 初始化
385 |      * @return $this
386 |      */
387 |     public function init()
388 |     {
389 |         $this->_dir = dirname(__FILE__);
390 |         $this->_db = Typecho_Db::get();
391 |         $this->_user = $this->widget('Widget_User');
392 |         $this->_options = $this->widget('Widget_Options');
393 |         $this->_cfg = Helper::options()->plugin('CommentToMail');
394 |         $this->mailLog(false, "开始发送邮件Action：" . $this->request->send . "\r\n");
395 |     }
396 | 
397 |     /**
398 |      * action 入口
399 |      *
400 |      * @access public
401 |      * @return void
402 |      */
403 |     public function action()
404 |     {
405 |         $this->on($this->request->is('do=testMail'))->testMail();
406 |         $this->on($this->request->is('do=editTheme'))->editTheme($this->request->edit);
407 |         $this->on($this->request->is('send'))->process($this->request->send);
408 |     }
409 | }


--------------------------------------------------------------------------------
/lib/class.smtp.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * PHPMailer RFC821 SMTP email transport class.
  4 |  * Version 5.2.7
  5 |  * PHP version 5.0.0
  6 |  * @category  PHP
  7 |  * @package   PHPMailer
  8 |  * @link      https://github.com/PHPMailer/PHPMailer/
  9 |  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
 10 |  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
 11 |  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
 12 |  * @copyright 2013 Marcus Bointon
 13 |  * @copyright 2004 - 2008 Andy Prevost
 14 |  * @copyright 2010 - 2012 Jim Jagielski
 15 |  * @license   http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
 16 |  */
 17 | 
 18 | /**
 19 |  * PHPMailer RFC821 SMTP email transport class.
 20 |  *
 21 |  * Implements RFC 821 SMTP commands
 22 |  * and provides some utility methods for sending mail to an SMTP server.
 23 |  *
 24 |  * PHP Version 5.0.0
 25 |  *
 26 |  * @category PHP
 27 |  * @package  PHPMailer
 28 |  * @link     https://github.com/PHPMailer/PHPMailer/blob/master/class.smtp.php
 29 |  * @author   Chris Ryan <unknown@example.com>
 30 |  * @author   Marcus Bointon <phpmailer@synchromedia.co.uk>
 31 |  * @license  http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
 32 |  */
 33 | 
 34 | class SMTP
 35 | {
 36 |     /**
 37 |      * The PHPMailer SMTP Version number.
 38 |      */
 39 |     const VERSION = '5.2.7';
 40 | 
 41 |     /**
 42 |      * SMTP line break constant.
 43 |      */
 44 |     const CRLF = "\r\n";
 45 | 
 46 |     /**
 47 |      * The SMTP port to use if one is not specified.
 48 |      */
 49 |     const DEFAULT_SMTP_PORT = 25;
 50 | 
 51 |     /**
 52 |      * The PHPMailer SMTP Version number.
 53 |      * @type string
 54 |      * @deprecated This should be a constant
 55 |      * @see SMTP::VERSION
 56 |      */
 57 |     public $Version = '5.2.7';
 58 | 
 59 |     /**
 60 |      * SMTP server port number.
 61 |      * @type int
 62 |      * @deprecated This is only ever ued as default value, so should be a constant
 63 |      * @see SMTP::DEFAULT_SMTP_PORT
 64 |      */
 65 |     public $SMTP_PORT = 25;
 66 | 
 67 |     /**
 68 |      * SMTP reply line ending
 69 |      * @type string
 70 |      * @deprecated Use the class constant instead
 71 |      * @see SMTP::CRLF
 72 |      */
 73 |     public $CRLF = "\r\n";
 74 | 
 75 |     /**
 76 |      * Debug output level.
 77 |      * Options:
 78 |      *   0: no output
 79 |      *   1: commands
 80 |      *   2: data and commands
 81 |      *   3: as 2 plus connection status
 82 |      *   4: low level data output
 83 |      * @type int
 84 |      */
 85 |     public $do_debug = 0;
 86 | 
 87 |     /**
 88 |      * The function/method to use for debugging output.
 89 |      * Options: 'echo', 'html' or 'error_log'
 90 |      * @type string
 91 |      */
 92 |     public $Debugoutput = 'echo';
 93 | 
 94 |     /**
 95 |      * Whether to use VERP.
 96 |      * @type bool
 97 |      */
 98 |     public $do_verp = false;
 99 | 
100 |     /**
101 |      * The timeout value for connection, in seconds.
102 |      * Default of 5 minutes (300sec) is from RFC2821 section 4.5.3.2
103 |      * @type int
104 |      */
105 |     public $Timeout = 300;
106 | 
107 |     /**
108 |      * The SMTP timelimit value for reads, in seconds.
109 |      * @type int
110 |      */
111 |     public $Timelimit = 30;
112 | 
113 |     /**
114 |      * The socket for the server connection.
115 |      * @type resource
116 |      */
117 |     protected $smtp_conn;
118 | 
119 |     /**
120 |      * Error message, if any, for the last call.
121 |      * @type string
122 |      */
123 |     protected $error = '';
124 | 
125 |     /**
126 |      * The reply the server sent to us for HELO.
127 |      * @type string
128 |      */
129 |     protected $helo_rply = '';
130 | 
131 |     /**
132 |      * The most recent reply received from the server.
133 |      * @type string
134 |      */
135 |     protected $last_reply = '';
136 | 
137 |     /**
138 |      * Constructor.
139 |      * @access public
140 |      */
141 |     public function __construct()
142 |     {
143 |         $this->smtp_conn = 0;
144 |         $this->error = null;
145 |         $this->helo_rply = null;
146 | 
147 |         $this->do_debug = 0;
148 |     }
149 | 
150 |     /**
151 |      * Output debugging info via a user-selected method.
152 |      * @param string $str Debug string to output
153 |      * @return void
154 |      */
155 |     protected function edebug($str)
156 |     {
157 |         switch ($this->Debugoutput) {
158 |             case 'error_log':
159 |                 //Don't output, just log
160 |                 error_log($str);
161 |                 break;
162 |             case 'html':
163 |                 //Cleans up output a bit for a better looking, HTML-safe output
164 |                 echo htmlentities(
165 |                     preg_replace('/[\r\n]+/', '', $str),
166 |                     ENT_QUOTES,
167 |                     'UTF-8'
168 |                 )
169 |                 . "<br>\n";
170 |                 break;
171 |             case 'echo':
172 |             default:
173 |                 echo gmdate('Y-m-d H:i:s')."\t".trim($str)."\n";
174 |         }
175 |     }
176 | 
177 |     /**
178 |      * Connect to an SMTP server.
179 |      * @param string $host    SMTP server IP or host name
180 |      * @param int $port    The port number to connect to
181 |      * @param int $timeout How long to wait for the connection to open
182 |      * @param array $options An array of options for stream_context_create()
183 |      * @access public
184 |      * @return bool
185 |      */
186 |     public function connect($host, $port = null, $timeout = 30, $options = array())
187 |     {
188 |         // Clear errors to avoid confusion
189 |         $this->error = null;
190 | 
191 |         // Make sure we are __not__ connected
192 |         if ($this->connected()) {
193 |             // Already connected, generate error
194 |             $this->error = array('error' => 'Already connected to a server');
195 |             return false;
196 |         }
197 | 
198 |         if (empty($port)) {
199 |             $port = self::DEFAULT_SMTP_PORT;
200 |         }
201 | 
202 |         // Connect to the SMTP server
203 |         if ($this->do_debug >= 3) {
204 |             $this->edebug('Connection: opening');
205 |         }
206 | 
207 |         $errno = 0;
208 |         $errstr = '';
209 |         $socket_context = stream_context_create($options);
210 |         //Suppress errors; connection failures are handled at a higher level
211 |         $this->smtp_conn = @stream_socket_client(
212 |             $host . ":" . $port,
213 |             $errno,
214 |             $errstr,
215 |             $timeout,
216 |             STREAM_CLIENT_CONNECT,
217 |             $socket_context
218 |         );
219 | 
220 |         // Verify we connected properly
221 |         if (empty($this->smtp_conn)) {
222 |             $this->error = array(
223 |                 'error' => 'Failed to connect to server',
224 |                 'errno' => $errno,
225 |                 'errstr' => $errstr
226 |             );
227 |             if ($this->do_debug >= 1) {
228 |                 $this->edebug(
229 |                     'SMTP ERROR: ' . $this->error['error']
230 |                     . ": $errstr ($errno)"
231 |                 );
232 |             }
233 |             return false;
234 |         }
235 |         if ($this->do_debug >= 3) {
236 |             $this->edebug('Connection: opened');
237 |         }
238 | 
239 |         // SMTP server can take longer to respond, give longer timeout for first read
240 |         // Windows does not have support for this timeout function
241 |         if (substr(PHP_OS, 0, 3) != 'WIN') {
242 |             $max = ini_get('max_execution_time');
243 |             if ($max != 0 && $timeout > $max) { // Don't bother if unlimited
244 |                 @set_time_limit($timeout);
245 |             }
246 |             stream_set_timeout($this->smtp_conn, $timeout, 0);
247 |         }
248 | 
249 |         // Get any announcement
250 |         $announce = $this->get_lines();
251 | 
252 |         if ($this->do_debug >= 2) {
253 |             $this->edebug('SERVER -> CLIENT: ' . $announce);
254 |         }
255 | 
256 |         return true;
257 |     }
258 | 
259 |     /**
260 |      * Initiate a TLS (encrypted) session.
261 |      * @access public
262 |      * @return bool
263 |      */
264 |     public function startTLS()
265 |     {
266 |         if (!$this->sendCommand("STARTTLS", "STARTTLS", 220)) {
267 |             return false;
268 |         }
269 |         // Begin encrypted connection
270 |         if (!stream_socket_enable_crypto(
271 |             $this->smtp_conn,
272 |             true,
273 |             STREAM_CRYPTO_METHOD_TLS_CLIENT
274 |         )
275 |         ) {
276 |             return false;
277 |         }
278 |         return true;
279 |     }
280 | 
281 |     /**
282 |      * Perform SMTP authentication.
283 |      * Must be run after hello().
284 |      * @see hello()
285 |      * @param string $username    The user name
286 |      * @param string $password    The password
287 |      * @param string $authtype    The auth type (PLAIN, LOGIN, NTLM, CRAM-MD5)
288 |      * @param string $realm       The auth realm for NTLM
289 |      * @param string $workstation The auth workstation for NTLM
290 |      * @access public
291 |      * @return bool True if successfully authenticated.
292 |      */
293 |     public function authenticate(
294 |         $username,
295 |         $password,
296 |         $authtype = 'LOGIN',
297 |         $realm = '',
298 |         $workstation = ''
299 |     ) {
300 |         if (empty($authtype)) {
301 |             $authtype = 'LOGIN';
302 |         }
303 | 
304 |         switch ($authtype) {
305 |             case 'PLAIN':
306 |                 // Start authentication
307 |                 if (!$this->sendCommand('AUTH', 'AUTH PLAIN', 334)) {
308 |                     return false;
309 |                 }
310 |                 // Send encoded username and password
311 |                 if (!$this->sendCommand(
312 |                     'User & Password',
313 |                     base64_encode("\0" . $username . "\0" . $password),
314 |                     235
315 |                 )
316 |                 ) {
317 |                     return false;
318 |                 }
319 |                 break;
320 |             case 'LOGIN':
321 |                 // Start authentication
322 |                 if (!$this->sendCommand('AUTH', 'AUTH LOGIN', 334)) {
323 |                     return false;
324 |                 }
325 |                 if (!$this->sendCommand("Username", base64_encode($username), 334)) {
326 |                     return false;
327 |                 }
328 |                 if (!$this->sendCommand("Password", base64_encode($password), 235)) {
329 |                     return false;
330 |                 }
331 |                 break;
332 |             case 'NTLM':
333 |                 /*
334 |                  * ntlm_sasl_client.php
335 |                  * Bundled with Permission
336 |                  *
337 |                  * How to telnet in windows:
338 |                  * http://technet.microsoft.com/en-us/library/aa995718%28EXCHG.65%29.aspx
339 |                  * PROTOCOL Docs http://curl.haxx.se/rfc/ntlm.html#ntlmSmtpAuthentication
340 |                  */
341 |                 require_once 'extras/ntlm_sasl_client.php';
342 |                 $temp = new stdClass();
343 |                 $ntlm_client = new ntlm_sasl_client_class;
344 |                 //Check that functions are available
345 |                 if (!$ntlm_client->Initialize($temp)) {
346 |                     $this->error = array('error' => $temp->error);
347 |                     if ($this->do_debug >= 1) {
348 |                         $this->edebug(
349 |                             'You need to enable some modules in your php.ini file: '
350 |                             . $this->error['error']
351 |                         );
352 |                     }
353 |                     return false;
354 |                 }
355 |                 //msg1
356 |                 $msg1 = $ntlm_client->TypeMsg1($realm, $workstation); //msg1
357 | 
358 |                 if (!$this->sendCommand(
359 |                     'AUTH NTLM',
360 |                     'AUTH NTLM ' . base64_encode($msg1),
361 |                     334
362 |                 )
363 |                 ) {
364 |                     return false;
365 |                 }
366 | 
367 |                 //Though 0 based, there is a white space after the 3 digit number
368 |                 //msg2
369 |                 $challenge = substr($this->last_reply, 3);
370 |                 $challenge = base64_decode($challenge);
371 |                 $ntlm_res = $ntlm_client->NTLMResponse(
372 |                     substr($challenge, 24, 8),
373 |                     $password
374 |                 );
375 |                 //msg3
376 |                 $msg3 = $ntlm_client->TypeMsg3(
377 |                     $ntlm_res,
378 |                     $username,
379 |                     $realm,
380 |                     $workstation
381 |                 );
382 |                 // send encoded username
383 |                 return $this->sendCommand('Username', base64_encode($msg3), 235);
384 |                 break;
385 |             case 'CRAM-MD5':
386 |                 // Start authentication
387 |                 if (!$this->sendCommand('AUTH CRAM-MD5', 'AUTH CRAM-MD5', 334)) {
388 |                     return false;
389 |                 }
390 |                 // Get the challenge
391 |                 $challenge = base64_decode(substr($this->last_reply, 4));
392 | 
393 |                 // Build the response
394 |                 $response = $username . ' ' . $this->hmac($challenge, $password);
395 | 
396 |                 // send encoded credentials
397 |                 return $this->sendCommand('Username', base64_encode($response), 235);
398 |                 break;
399 |         }
400 |         return true;
401 |     }
402 | 
403 |     /**
404 |      * Calculate an MD5 HMAC hash.
405 |      * Works like hash_hmac('md5', $data, $key)
406 |      * in case that function is not available
407 |      * @param string $data The data to hash
408 |      * @param string $key  The key to hash with
409 |      * @access protected
410 |      * @return string
411 |      */
412 |     protected function hmac($data, $key)
413 |     {
414 |         if (function_exists('hash_hmac')) {
415 |             return hash_hmac('md5', $data, $key);
416 |         }
417 | 
418 |         // The following borrowed from
419 |         // http://php.net/manual/en/function.mhash.php#27225
420 | 
421 |         // RFC 2104 HMAC implementation for php.
422 |         // Creates an md5 HMAC.
423 |         // Eliminates the need to install mhash to compute a HMAC
424 |         // Hacked by Lance Rushing
425 | 
426 |         $b = 64; // byte length for md5
427 |         if (strlen($key) > $b) {
428 |             $key = pack('H*', md5($key));
429 |         }
430 |         $key = str_pad($key, $b, chr(0x00));
431 |         $ipad = str_pad('', $b, chr(0x36));
432 |         $opad = str_pad('', $b, chr(0x5c));
433 |         $k_ipad = $key ^ $ipad;
434 |         $k_opad = $key ^ $opad;
435 | 
436 |         return md5($k_opad . pack('H*', md5($k_ipad . $data)));
437 |     }
438 | 
439 |     /**
440 |      * Check connection state.
441 |      * @access public
442 |      * @return bool True if connected.
443 |      */
444 |     public function connected()
445 |     {
446 |         if (!empty($this->smtp_conn)) {
447 |             $sock_status = stream_get_meta_data($this->smtp_conn);
448 |             if ($sock_status['eof']) {
449 |                 // the socket is valid but we are not connected
450 |                 if ($this->do_debug >= 1) {
451 |                     $this->edebug(
452 |                         'SMTP NOTICE: EOF caught while checking if connected'
453 |                     );
454 |                 }
455 |                 $this->close();
456 |                 return false;
457 |             }
458 |             return true; // everything looks good
459 |         }
460 |         return false;
461 |     }
462 | 
463 |     /**
464 |      * Close the socket and clean up the state of the class.
465 |      * Don't use this function without first trying to use QUIT.
466 |      * @see quit()
467 |      * @access public
468 |      * @return void
469 |      */
470 |     public function close()
471 |     {
472 |         $this->error = null; // so there is no confusion
473 |         $this->helo_rply = null;
474 |         if (!empty($this->smtp_conn)) {
475 |             // close the connection and cleanup
476 |             fclose($this->smtp_conn);
477 |             if ($this->do_debug >= 3) {
478 |                 $this->edebug('Connection: closed');
479 |             }
480 |             $this->smtp_conn = 0;
481 |         }
482 |     }
483 | 
484 |     /**
485 |      * Send an SMTP DATA command.
486 |      * Issues a data command and sends the msg_data to the server,
487 |      * finializing the mail transaction. $msg_data is the message
488 |      * that is to be send with the headers. Each header needs to be
489 |      * on a single line followed by a <CRLF> with the message headers
490 |      * and the message body being separated by and additional <CRLF>.
491 |      * Implements rfc 821: DATA <CRLF>
492 |      * @param string $msg_data Message data to send
493 |      * @access public
494 |      * @return bool
495 |      */
496 |     public function data($msg_data)
497 |     {
498 |         if (!$this->sendCommand('DATA', 'DATA', 354)) {
499 |             return false;
500 |         }
501 | 
502 |         /* The server is ready to accept data!
503 |          * according to rfc821 we should not send more than 1000
504 |          * including the CRLF
505 |          * characters on a single line so we will break the data up
506 |          * into lines by \r and/or \n then if needed we will break
507 |          * each of those into smaller lines to fit within the limit.
508 |          * in addition we will be looking for lines that start with
509 |          * a period '.' and append and additional period '.' to that
510 |          * line. NOTE: this does not count towards limit.
511 |          */
512 | 
513 |         // Normalize the line breaks before exploding
514 |         $msg_data = str_replace("\r\n", "\n", $msg_data);
515 |         $msg_data = str_replace("\r", "\n", $msg_data);
516 |         $lines = explode("\n", $msg_data);
517 | 
518 |         /* We need to find a good way to determine if headers are
519 |          * in the msg_data or if it is a straight msg body
520 |          * currently I am assuming rfc822 definitions of msg headers
521 |          * and if the first field of the first line (':' separated)
522 |          * does not contain a space then it _should_ be a header
523 |          * and we can process all lines before a blank "" line as
524 |          * headers.
525 |          */
526 | 
527 |         $field = substr($lines[0], 0, strpos($lines[0], ':'));
528 |         $in_headers = false;
529 |         if (!empty($field) && !strstr($field, ' ')) {
530 |             $in_headers = true;
531 |         }
532 | 
533 |         //RFC 2822 section 2.1.1 limit
534 |         $max_line_length = 998;
535 | 
536 |         foreach ($lines as $line) {
537 |             $lines_out = null;
538 |             if ($line == '' && $in_headers) {
539 |                 $in_headers = false;
540 |             }
541 |             // ok we need to break this line up into several smaller lines
542 |             while (strlen($line) > $max_line_length) {
543 |                 $pos = strrpos(substr($line, 0, $max_line_length), ' ');
544 | 
545 |                 // Patch to fix DOS attack
546 |                 if (!$pos) {
547 |                     $pos = $max_line_length - 1;
548 |                     $lines_out[] = substr($line, 0, $pos);
549 |                     $line = substr($line, $pos);
550 |                 } else {
551 |                     $lines_out[] = substr($line, 0, $pos);
552 |                     $line = substr($line, $pos + 1);
553 |                 }
554 | 
555 |                 /* If processing headers add a LWSP-char to the front of new line
556 |                  * rfc822 on long msg headers
557 |                  */
558 |                 if ($in_headers) {
559 |                     $line = "\t" . $line;
560 |                 }
561 |             }
562 |             $lines_out[] = $line;
563 | 
564 |             // send the lines to the server
565 |             while (list(, $line_out) = @each($lines_out)) {
566 |                 if (strlen($line_out) > 0) {
567 |                     if (substr($line_out, 0, 1) == '.') {
568 |                         $line_out = '.' . $line_out;
569 |                     }
570 |                 }
571 |                 $this->client_send($line_out . self::CRLF);
572 |             }
573 |         }
574 | 
575 |         // Message data has been sent, complete the command
576 |         return $this->sendCommand('DATA END', '.', 250);
577 |     }
578 | 
579 |     /**
580 |      * Send an SMTP HELO or EHLO command.
581 |      * Used to identify the sending server to the receiving server.
582 |      * This makes sure that client and server are in a known state.
583 |      * Implements from RFC 821: HELO <SP> <domain> <CRLF>
584 |      * and RFC 2821 EHLO.
585 |      * @param string $host The host name or IP to connect to
586 |      * @access public
587 |      * @return bool
588 |      */
589 |     public function hello($host = '')
590 |     {
591 |         // Try extended hello first (RFC 2821)
592 |         if (!$this->sendHello('EHLO', $host)) {
593 |             if (!$this->sendHello('HELO', $host)) {
594 |                 return false;
595 |             }
596 |         }
597 | 
598 |         return true;
599 |     }
600 | 
601 |     /**
602 |      * Send an SMTP HELO or EHLO command.
603 |      * Low-level implementation used by hello()
604 |      * @see hello()
605 |      * @param string $hello The HELO string
606 |      * @param string $host  The hostname to say we are
607 |      * @access protected
608 |      * @return bool
609 |      */
610 |     protected function sendHello($hello, $host)
611 |     {
612 |         $noerror = $this->sendCommand($hello, $hello . ' ' . $host, 250);
613 |         $this->helo_rply = $this->last_reply;
614 |         return $noerror;
615 |     }
616 | 
617 |     /**
618 |      * Send an SMTP MAIL command.
619 |      * Starts a mail transaction from the email address specified in
620 |      * $from. Returns true if successful or false otherwise. If True
621 |      * the mail transaction is started and then one or more recipient
622 |      * commands may be called followed by a data command.
623 |      * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
624 |      * @param string $from Source address of this message
625 |      * @access public
626 |      * @return bool
627 |      */
628 |     public function mail($from)
629 |     {
630 |         $useVerp = ($this->do_verp ? ' XVERP' : '');
631 |         return $this->sendCommand(
632 |             'MAIL FROM',
633 |             'MAIL FROM:<' . $from . '>' . $useVerp,
634 |             250
635 |         );
636 |     }
637 | 
638 |     /**
639 |      * Send an SMTP QUIT command.
640 |      * Closes the socket if there is no error or the $close_on_error argument is true.
641 |      * Implements from rfc 821: QUIT <CRLF>
642 |      * @param bool $close_on_error Should the connection close if an error occurs?
643 |      * @access public
644 |      * @return bool
645 |      */
646 |     public function quit($close_on_error = true)
647 |     {
648 |         $noerror = $this->sendCommand('QUIT', 'QUIT', 221);
649 |         $e = $this->error; //Save any error
650 |         if ($noerror or $close_on_error) {
651 |             $this->close();
652 |             $this->error = $e; //Restore any error from the quit command
653 |         }
654 |         return $noerror;
655 |     }
656 | 
657 |     /**
658 |      * Send an SMTP RCPT command.
659 |      * Sets the TO argument to $to.
660 |      * Returns true if the recipient was accepted false if it was rejected.
661 |      * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
662 |      * @param string $to The address the message is being sent to
663 |      * @access public
664 |      * @return bool
665 |      */
666 |     public function recipient($to)
667 |     {
668 |         return $this->sendCommand(
669 |             'RCPT TO ',
670 |             'RCPT TO:<' . $to . '>',
671 |             array(250, 251)
672 |         );
673 |     }
674 | 
675 |     /**
676 |      * Send an SMTP RSET command.
677 |      * Abort any transaction that is currently in progress.
678 |      * Implements rfc 821: RSET <CRLF>
679 |      * @access public
680 |      * @return bool True on success.
681 |      */
682 |     public function reset()
683 |     {
684 |         return $this->sendCommand('RSET', 'RSET', 250);
685 |     }
686 | 
687 |     /**
688 |      * Send a command to an SMTP server and check its return code.
689 |      * @param string $command       The command name - not sent to the server
690 |      * @param string $commandstring The actual command to send
691 |      * @param int|array $expect     One or more expected integer success codes
692 |      * @access protected
693 |      * @return bool True on success.
694 |      */
695 |     protected function sendCommand($command, $commandstring, $expect)
696 |     {
697 |         if (!$this->connected()) {
698 |             $this->error = array(
699 |                 "error" => "Called $command without being connected"
700 |             );
701 |             return false;
702 |         }
703 |         $this->client_send($commandstring . self::CRLF);
704 | 
705 |         $reply = $this->get_lines();
706 |         $code = substr($reply, 0, 3);
707 | 
708 |         if ($this->do_debug >= 2) {
709 |             $this->edebug('SERVER -> CLIENT: ' . $reply);
710 |         }
711 | 
712 |         if (!in_array($code, (array)$expect)) {
713 |             $this->last_reply = null;
714 |             $this->error = array(
715 |                 "error" => "$command command failed",
716 |                 "smtp_code" => $code,
717 |                 "detail" => substr($reply, 4)
718 |             );
719 |             if ($this->do_debug >= 1) {
720 |                 $this->edebug(
721 |                     'SMTP ERROR: ' . $this->error['error'] . ': ' . $reply
722 |                 );
723 |             }
724 |             return false;
725 |         }
726 | 
727 |         $this->last_reply = $reply;
728 |         $this->error = null;
729 |         return true;
730 |     }
731 | 
732 |     /**
733 |      * Send an SMTP SAML command.
734 |      * Starts a mail transaction from the email address specified in $from.
735 |      * Returns true if successful or false otherwise. If True
736 |      * the mail transaction is started and then one or more recipient
737 |      * commands may be called followed by a data command. This command
738 |      * will send the message to the users terminal if they are logged
739 |      * in and send them an email.
740 |      * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
741 |      * @param string $from The address the message is from
742 |      * @access public
743 |      * @return bool
744 |      */
745 |     public function sendAndMail($from)
746 |     {
747 |         return $this->sendCommand("SAML", "SAML FROM:$from", 250);
748 |     }
749 | 
750 |     /**
751 |      * Send an SMTP VRFY command.
752 |      * @param string $name The name to verify
753 |      * @access public
754 |      * @return bool
755 |      */
756 |     public function verify($name)
757 |     {
758 |         return $this->sendCommand("VRFY", "VRFY $name", array(250, 251));
759 |     }
760 | 
761 |     /**
762 |      * Send an SMTP NOOP command.
763 |      * Used to keep keep-alives alive, doesn't actually do anything
764 |      * @access public
765 |      * @return bool
766 |      */
767 |     public function noop()
768 |     {
769 |         return $this->sendCommand("NOOP", "NOOP", 250);
770 |     }
771 | 
772 |     /**
773 |      * Send an SMTP TURN command.
774 |      * This is an optional command for SMTP that this class does not support.
775 |      * This method is here to make the RFC821 Definition
776 |      * complete for this class and __may__ be implemented in future
777 |      * Implements from rfc 821: TURN <CRLF>
778 |      * @access public
779 |      * @return bool
780 |      */
781 |     public function turn()
782 |     {
783 |         $this->error = array(
784 |             'error' => 'The SMTP TURN command is not implemented'
785 |         );
786 |         if ($this->do_debug >= 1) {
787 |             $this->edebug('SMTP NOTICE: ' . $this->error['error']);
788 |         }
789 |         return false;
790 |     }
791 | 
792 |     /**
793 |      * Send raw data to the server.
794 |      * @param string $data The data to send
795 |      * @access public
796 |      * @return int|bool The number of bytes sent to the server or FALSE on error
797 |      */
798 |     public function client_send($data)
799 |     {
800 |         if ($this->do_debug >= 1) {
801 |             $this->edebug("CLIENT -> SERVER: $data");
802 |         }
803 |         return fwrite($this->smtp_conn, $data);
804 |     }
805 | 
806 |     /**
807 |      * Get the latest error.
808 |      * @access public
809 |      * @return array
810 |      */
811 |     public function getError()
812 |     {
813 |         return $this->error;
814 |     }
815 | 
816 |     /**
817 |      * Get the last reply from the server.
818 |      * @access public
819 |      * @return string
820 |      */
821 |     public function getLastReply()
822 |     {
823 |         return $this->last_reply;
824 |     }
825 | 
826 |     /**
827 |      * Read the SMTP server's response.
828 |      * Either before eof or socket timeout occurs on the operation.
829 |      * With SMTP we can tell if we have more lines to read if the
830 |      * 4th character is '-' symbol. If it is a space then we don't
831 |      * need to read anything else.
832 |      * @access protected
833 |      * @return string
834 |      */
835 |     protected function get_lines()
836 |     {
837 |         $data = '';
838 |         $endtime = 0;
839 |         // If the connection is bad, give up now
840 |         if (!is_resource($this->smtp_conn)) {
841 |             return $data;
842 |         }
843 |         stream_set_timeout($this->smtp_conn, $this->Timeout);
844 |         if ($this->Timelimit > 0) {
845 |             $endtime = time() + $this->Timelimit;
846 |         }
847 |         while (is_resource($this->smtp_conn) && !feof($this->smtp_conn)) {
848 |             $str = @fgets($this->smtp_conn, 515);
849 |             if ($this->do_debug >= 4) {
850 |                 $this->edebug("SMTP -> get_lines(): \$data was \"$data\"");
851 |                 $this->edebug("SMTP -> get_lines(): \$str is \"$str\"");
852 |             }
853 |             $data .= $str;
854 |             if ($this->do_debug >= 4) {
855 |                 $this->edebug("SMTP -> get_lines(): \$data is \"$data\"");
856 |             }
857 |             // if 4th character is a space, we are done reading, break the loop
858 |             if (substr($str, 3, 1) == ' ') {
859 |                 break;
860 |             }
861 |             // Timed-out? Log and break
862 |             $info = stream_get_meta_data($this->smtp_conn);
863 |             if ($info['timed_out']) {
864 |                 if ($this->do_debug >= 4) {
865 |                     $this->edebug(
866 |                         'SMTP -> get_lines(): timed-out (' . $this->Timeout . ' sec)'
867 |                     );
868 |                 }
869 |                 break;
870 |             }
871 |             // Now check if reads took too long
872 |             if ($endtime) {
873 |                 if (time() > $endtime) {
874 |                     if ($this->do_debug >= 4) {
875 |                         $this->edebug(
876 |                             'SMTP -> get_lines(): timelimit reached ('
877 |                             . $this->Timelimit . ' sec)'
878 |                         );
879 |                     }
880 |                     break;
881 |                 }
882 |             }
883 |         }
884 |         return $data;
885 |     }
886 | 
887 |     /**
888 |      * Enable or disable VERP address generation.
889 |      * @param bool $enabled
890 |      */
891 |     public function setVerp($enabled = false)
892 |     {
893 |         $this->do_verp = $enabled;
894 |     }
895 | 
896 |     /**
897 |      * Get VERP address generation mode.
898 |      * @return bool
899 |      */
900 |     public function getVerp()
901 |     {
902 |         return $this->do_verp;
903 |     }
904 | 
905 |     /**
906 |      * Set debug output method.
907 |      * @param string $method The function/method to use for debugging output.
908 |      */
909 |     public function setDebugOutput($method = 'echo')
910 |     {
911 |         $this->Debugoutput = $method;
912 |     }
913 | 
914 |     /**
915 |      * Get debug output method.
916 |      * @return string
917 |      */
918 |     public function getDebugOutput()
919 |     {
920 |         return $this->Debugoutput;
921 |     }
922 | 
923 |     /**
924 |      * Set debug output level.
925 |      * @param int $level
926 |      */
927 |     public function setDebugLevel($level = 0)
928 |     {
929 |         $this->do_debug = $level;
930 |     }
931 | 
932 |     /**
933 |      * Get debug output level.
934 |      * @return int
935 |      */
936 |     public function getDebugLevel()
937 |     {
938 |         return $this->do_debug;
939 |     }
940 | 
941 |     /**
942 |      * Set SMTP timeout.
943 |      * @param int $timeout
944 |      */
945 |     public function setTimeout($timeout = 0)
946 |     {
947 |         $this->Timeout = $timeout;
948 |     }
949 | 
950 |     /**
951 |      * Get SMTP timeout.
952 |      * @return int
953 |      */
954 |     public function getTimeout()
955 |     {
956 |         return $this->Timeout;
957 |     }
958 | }
959 | 


--------------------------------------------------------------------------------
/lib/class.phpmailer.php:
--------------------------------------------------------------------------------
   1 | <?php
   2 | /**
   3 |  * PHPMailer - PHP email creation and transport class.
   4 |  * PHP Version 5.0.0
   5 |  * Version 5.2.7
   6 |  * @package PHPMailer
   7 |  * @link https://github.com/PHPMailer/PHPMailer/
   8 |  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
   9 |  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
  10 |  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
  11 |  * @author Brent R. Matzelle (original founder)
  12 |  * @copyright 2013 Marcus Bointon
  13 |  * @copyright 2010 - 2012 Jim Jagielski
  14 |  * @copyright 2004 - 2009 Andy Prevost
  15 |  * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
  16 |  * @note This program is distributed in the hope that it will be useful - WITHOUT
  17 |  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 |  * FITNESS FOR A PARTICULAR PURPOSE.
  19 |  */
  20 | 
  21 | if (version_compare(PHP_VERSION, '5.0.0', '<')) {
  22 |     exit("Sorry, PHPMailer will only run on PHP version 5 or greater!\n");
  23 | }
  24 | 
  25 | require_once 'class.smtp.php';
  26 | require_once 'class.pop3.php';
  27 | 
  28 | /**
  29 |  * PHPMailer - PHP email creation and transport class.
  30 |  * PHP Version 5.0.0
  31 |  * @package PHPMailer
  32 |  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
  33 |  * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
  34 |  * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
  35 |  * @author Brent R. Matzelle (original founder)
  36 |  * @copyright 2013 Marcus Bointon
  37 |  * @copyright 2010 - 2012 Jim Jagielski
  38 |  * @copyright 2004 - 2009 Andy Prevost
  39 |  */
  40 | class PHPMailer
  41 | {
  42 |     /**
  43 |      * The PHPMailer Version number.
  44 |      * @type string
  45 |      */
  46 |     public $Version = '5.2.7';
  47 | 
  48 |     /**
  49 |      * Email priority.
  50 |      * Options: 1 = High, 3 = Normal, 5 = low.
  51 |      * @type int
  52 |      */
  53 |     public $Priority = 3;
  54 | 
  55 |     /**
  56 |      * The character set of the message.
  57 |      * @type string
  58 |      */
  59 |     public $CharSet = 'iso-8859-1';
  60 | 
  61 |     /**
  62 |      * The MIME Content-type of the message.
  63 |      * @type string
  64 |      */
  65 |     public $ContentType = 'text/plain';
  66 | 
  67 |     /**
  68 |      * The message encoding.
  69 |      * Options: "8bit", "7bit", "binary", "base64", and "quoted-printable".
  70 |      * @type string
  71 |      */
  72 |     public $Encoding = '8bit';
  73 | 
  74 |     /**
  75 |      * Holds the most recent mailer error message.
  76 |      * @type string
  77 |      */
  78 |     public $ErrorInfo = '';
  79 | 
  80 |     /**
  81 |      * The From email address for the message.
  82 |      * @type string
  83 |      */
  84 |     public $From = 'root@localhost';
  85 | 
  86 |     /**
  87 |      * The From name of the message.
  88 |      * @type string
  89 |      */
  90 |     public $FromName = 'Root User';
  91 | 
  92 |     /**
  93 |      * The Sender email (Return-Path) of the message.
  94 |      * If not empty, will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.
  95 |      * @type string
  96 |      */
  97 |     public $Sender = '';
  98 | 
  99 |     /**
 100 |      * The Return-Path of the message.
 101 |      * If empty, it will be set to either From or Sender.
 102 |      * @type string
 103 |      */
 104 |     public $ReturnPath = '';
 105 | 
 106 |     /**
 107 |      * The Subject of the message.
 108 |      * @type string
 109 |      */
 110 |     public $Subject = '';
 111 | 
 112 |     /**
 113 |      * An HTML or plain text message body.
 114 |      * If HTML then call isHTML(true).
 115 |      * @type string
 116 |      */
 117 |     public $Body = '';
 118 | 
 119 |     /**
 120 |      * The plain-text message body.
 121 |      * This body can be read by mail clients that do not have HTML email
 122 |      * capability such as mutt & Eudora.
 123 |      * Clients that can read HTML will view the normal Body.
 124 |      * @type string
 125 |      */
 126 |     public $AltBody = '';
 127 | 
 128 |     /**
 129 |      * An iCal message part body.
 130 |      * Only supported in simple alt or alt_inline message types
 131 |      * To generate iCal events, use the bundled extras/EasyPeasyICS.php class or iCalcreator
 132 |      * @link http://sprain.ch/blog/downloads/php-class-easypeasyics-create-ical-files-with-php/
 133 |      * @link http://kigkonsult.se/iCalcreator/
 134 |      * @type string
 135 |      */
 136 |     public $Ical = '';
 137 | 
 138 |     /**
 139 |      * The complete compiled MIME message body.
 140 |      * @access protected
 141 |      * @type string
 142 |      */
 143 |     protected $MIMEBody = '';
 144 | 
 145 |     /**
 146 |      * The complete compiled MIME message headers.
 147 |      * @type string
 148 |      * @access protected
 149 |      */
 150 |     protected $MIMEHeader = '';
 151 | 
 152 |     /**
 153 |      * Extra headers that createHeader() doesn't fold in.
 154 |      * @type string
 155 |      * @access protected
 156 |      */
 157 |     protected $mailHeader = '';
 158 | 
 159 |     /**
 160 |      * Word-wrap the message body to this number of chars.
 161 |      * @type int
 162 |      */
 163 |     public $WordWrap = 0;
 164 | 
 165 |     /**
 166 |      * Which method to use to send mail.
 167 |      * Options: "mail", "sendmail", or "smtp".
 168 |      * @type string
 169 |      */
 170 |     public $Mailer = 'mail';
 171 | 
 172 |     /**
 173 |      * The path to the sendmail program.
 174 |      * @type string
 175 |      */
 176 |     public $Sendmail = '/usr/sbin/sendmail';
 177 | 
 178 |     /**
 179 |      * Whether mail() uses a fully sendmail-compatible MTA.
 180 |      * One which supports sendmail's "-oi -f" options.
 181 |      * @type bool
 182 |      */
 183 |     public $UseSendmailOptions = true;
 184 | 
 185 |     /**
 186 |      * Path to PHPMailer plugins.
 187 |      * Useful if the SMTP class is not in the PHP include path.
 188 |      * @type string
 189 |      * @deprecated Should not be needed now there is an autoloader.
 190 |      */
 191 |     public $PluginDir = '';
 192 | 
 193 |     /**
 194 |      * The email address that a reading confirmation should be sent to.
 195 |      * @type string
 196 |      */
 197 |     public $ConfirmReadingTo = '';
 198 | 
 199 |     /**
 200 |      * The hostname to use in Message-Id and Received headers
 201 |      * and as default HELO string.
 202 |      * If empty, the value returned
 203 |      * by SERVER_NAME is used or 'localhost.localdomain'.
 204 |      * @type string
 205 |      */
 206 |     public $Hostname = '';
 207 | 
 208 |     /**
 209 |      * An ID to be used in the Message-Id header.
 210 |      * If empty, a unique id will be generated.
 211 |      * @type string
 212 |      */
 213 |     public $MessageID = '';
 214 | 
 215 |     /**
 216 |      * The message Date to be used in the Date header.
 217 |      * If empty, the current date will be added.
 218 |      * @type string
 219 |      */
 220 |     public $MessageDate = '';
 221 | 
 222 |     /**
 223 |      * SMTP hosts.
 224 |      * Either a single hostname or multiple semicolon-delimited hostnames.
 225 |      * You can also specify a different port
 226 |      * for each host by using this format: [hostname:port]
 227 |      * (e.g. "smtp1.example.com:25;smtp2.example.com").
 228 |      * Hosts will be tried in order.
 229 |      * @type string
 230 |      */
 231 |     public $Host = 'localhost';
 232 | 
 233 |     /**
 234 |      * The default SMTP server port.
 235 |      * @type int
 236 |      * @Todo Why is this needed when the SMTP class takes care of it?
 237 |      */
 238 |     public $Port = 25;
 239 | 
 240 |     /**
 241 |      * The SMTP HELO of the message.
 242 |      * Default is $Hostname.
 243 |      * @type string
 244 |      * @see PHPMailer::$Hostname
 245 |      */
 246 |     public $Helo = '';
 247 | 
 248 |     /**
 249 |      * The secure connection prefix.
 250 |      * Options: "", "ssl" or "tls"
 251 |      * @type string
 252 |      */
 253 |     public $SMTPSecure = '';
 254 | 
 255 |     /**
 256 |      * Whether to use SMTP authentication.
 257 |      * Uses the Username and Password properties.
 258 |      * @type bool
 259 |      * @see PHPMailer::$Username
 260 |      * @see PHPMailer::$Password
 261 |      */
 262 |     public $SMTPAuth = false;
 263 | 
 264 |     /**
 265 |      * SMTP username.
 266 |      * @type string
 267 |      */
 268 |     public $Username = '';
 269 | 
 270 |     /**
 271 |      * SMTP password.
 272 |      * @type string
 273 |      */
 274 |     public $Password = '';
 275 | 
 276 |     /**
 277 |      * SMTP auth type.
 278 |      * Options are LOGIN (default), PLAIN, NTLM, CRAM-MD5
 279 |      * @type string
 280 |      */
 281 |     public $AuthType = '';
 282 | 
 283 |     /**
 284 |      * SMTP realm.
 285 |      * Used for NTLM auth
 286 |      * @type string
 287 |      */
 288 |     public $Realm = '';
 289 | 
 290 |     /**
 291 |      * SMTP workstation.
 292 |      * Used for NTLM auth
 293 |      * @type string
 294 |      */
 295 |     public $Workstation = '';
 296 | 
 297 |     /**
 298 |      * The SMTP server timeout in seconds.
 299 |      * @type int
 300 |      */
 301 |     public $Timeout = 10;
 302 | 
 303 |     /**
 304 |      * SMTP class debug output mode.
 305 |      * Options: 0 = off, 1 = commands, 2 = commands and data
 306 |      * @type int
 307 |      * @see SMTP::$do_debug
 308 |      */
 309 |     public $SMTPDebug = 0;
 310 | 
 311 |     /**
 312 |      * The function/method to use for debugging output.
 313 |      * Options: "echo" or "error_log"
 314 |      * @type string
 315 |      * @see SMTP::$Debugoutput
 316 |      */
 317 |     public $Debugoutput = "echo";
 318 | 
 319 |     /**
 320 |      * Whether to keep SMTP connection open after each message.
 321 |      * If this is set to true then to close the connection
 322 |      * requires an explicit call to smtpClose().
 323 |      * @type bool
 324 |      */
 325 |     public $SMTPKeepAlive = false;
 326 | 
 327 |     /**
 328 |      * Whether to split multiple to addresses into multiple messages
 329 |      * or send them all in one message.
 330 |      * @type bool
 331 |      */
 332 |     public $SingleTo = false;
 333 | 
 334 |     /**
 335 |      * Storage for addresses when SingleTo is enabled.
 336 |      * @type array
 337 |      * @todo This should really not be public
 338 |      */
 339 |     public $SingleToArray = array();
 340 | 
 341 |     /**
 342 |      * Whether to generate VERP addresses on send.
 343 |      * Only applicable when sending via SMTP.
 344 |      * @link http://en.wikipedia.org/wiki/Variable_envelope_return_path
 345 |      * @type bool
 346 |      */
 347 |     public $do_verp = false;
 348 | 
 349 |     /**
 350 |      * Whether to allow sending messages with an empty body.
 351 |      * @type bool
 352 |      */
 353 |     public $AllowEmpty = false;
 354 | 
 355 |     /**
 356 |      * The default line ending.
 357 |      * @note The default remains "\n". We force CRLF where we know
 358 |      *        it must be used via self::CRLF.
 359 |      * @type string
 360 |      */
 361 |     public $LE = "\n";
 362 | 
 363 |     /**
 364 |      * DKIM selector.
 365 |      * @type string
 366 |      */
 367 |     public $DKIM_selector = '';
 368 | 
 369 |     /**
 370 |      * DKIM Identity.
 371 |      * Usually the email address used as the source of the email
 372 |      * @type string
 373 |      */
 374 |     public $DKIM_identity = '';
 375 | 
 376 |     /**
 377 |      * DKIM passphrase.
 378 |      * Used if your key is encrypted.
 379 |      * @type string
 380 |      */
 381 |     public $DKIM_passphrase = '';
 382 | 
 383 |     /**
 384 |      * DKIM signing domain name.
 385 |      * @example 'example.com'
 386 |      * @type string
 387 |      */
 388 |     public $DKIM_domain = '';
 389 | 
 390 |     /**
 391 |      * DKIM private key file path.
 392 |      * @type string
 393 |      */
 394 |     public $DKIM_private = '';
 395 | 
 396 |     /**
 397 |      * Callback Action function name.
 398 |      *
 399 |      * The function that handles the result of the send email action.
 400 |      * It is called out by send() for each email sent.
 401 |      *
 402 |      * Value can be any php callable: http://www.php.net/is_callable
 403 |      *
 404 |      * Parameters:
 405 |      *   bool    $result        result of the send action
 406 |      *   string  $to            email address of the recipient
 407 |      *   string  $cc            cc email addresses
 408 |      *   string  $bcc           bcc email addresses
 409 |      *   string  $subject       the subject
 410 |      *   string  $body          the email body
 411 |      *   string  $from          email address of sender
 412 |      * @type string
 413 |      */
 414 |     public $action_function = '';
 415 | 
 416 |     /**
 417 |      * What to use in the X-Mailer header.
 418 |      * Options: null for default, whitespace for none, or a string to use
 419 |      * @type string
 420 |      */
 421 |     public $XMailer = '';
 422 | 
 423 |     /**
 424 |      * An instance of the SMTP sender class.
 425 |      * @type SMTP
 426 |      * @access protected
 427 |      */
 428 |     protected $smtp = null;
 429 | 
 430 |     /**
 431 |      * The array of 'to' addresses.
 432 |      * @type array
 433 |      * @access protected
 434 |      */
 435 |     protected $to = array();
 436 | 
 437 |     /**
 438 |      * The array of 'cc' addresses.
 439 |      * @type array
 440 |      * @access protected
 441 |      */
 442 |     protected $cc = array();
 443 | 
 444 |     /**
 445 |      * The array of 'bcc' addresses.
 446 |      * @type array
 447 |      * @access protected
 448 |      */
 449 |     protected $bcc = array();
 450 | 
 451 |     /**
 452 |      * The array of reply-to names and addresses.
 453 |      * @type array
 454 |      * @access protected
 455 |      */
 456 |     protected $ReplyTo = array();
 457 | 
 458 |     /**
 459 |      * An array of all kinds of addresses.
 460 |      * Includes all of $to, $cc, $bcc, $replyto
 461 |      * @type array
 462 |      * @access protected
 463 |      */
 464 |     protected $all_recipients = array();
 465 | 
 466 |     /**
 467 |      * The array of attachments.
 468 |      * @type array
 469 |      * @access protected
 470 |      */
 471 |     protected $attachment = array();
 472 | 
 473 |     /**
 474 |      * The array of custom headers.
 475 |      * @type array
 476 |      * @access protected
 477 |      */
 478 |     protected $CustomHeader = array();
 479 | 
 480 |     /**
 481 |      * The most recent Message-ID (including angular brackets).
 482 |      * @type string
 483 |      * @access protected
 484 |      */
 485 |     protected $lastMessageID = '';
 486 | 
 487 |     /**
 488 |      * The message's MIME type.
 489 |      * @type string
 490 |      * @access protected
 491 |      */
 492 |     protected $message_type = '';
 493 | 
 494 |     /**
 495 |      * The array of MIME boundary strings.
 496 |      * @type array
 497 |      * @access protected
 498 |      */
 499 |     protected $boundary = array();
 500 | 
 501 |     /**
 502 |      * The array of available languages.
 503 |      * @type array
 504 |      * @access protected
 505 |      */
 506 |     protected $language = array();
 507 | 
 508 |     /**
 509 |      * The number of errors encountered.
 510 |      * @type integer
 511 |      * @access protected
 512 |      */
 513 |     protected $error_count = 0;
 514 | 
 515 |     /**
 516 |      * The S/MIME certificate file path.
 517 |      * @type string
 518 |      * @access protected
 519 |      */
 520 |     protected $sign_cert_file = '';
 521 | 
 522 |     /**
 523 |      * The S/MIME key file path.
 524 |      * @type string
 525 |      * @access protected
 526 |      */
 527 |     protected $sign_key_file = '';
 528 | 
 529 |     /**
 530 |      * The S/MIME password for the key.
 531 |      * Used only if the key is encrypted.
 532 |      * @type string
 533 |      * @access protected
 534 |      */
 535 |     protected $sign_key_pass = '';
 536 | 
 537 |     /**
 538 |      * Whether to throw exceptions for errors.
 539 |      * @type bool
 540 |      * @access protected
 541 |      */
 542 |     protected $exceptions = false;
 543 | 
 544 |     /**
 545 |      * Error severity: message only, continue processing
 546 |      */
 547 |     const STOP_MESSAGE = 0;
 548 | 
 549 |     /**
 550 |      * Error severity: message, likely ok to continue processing
 551 |      */
 552 |     const STOP_CONTINUE = 1;
 553 | 
 554 |     /**
 555 |      * Error severity: message, plus full stop, critical error reached
 556 |      */
 557 |     const STOP_CRITICAL = 2;
 558 | 
 559 |     /**
 560 |      * SMTP RFC standard line ending
 561 |      */
 562 |     const CRLF = "\r\n";
 563 | 
 564 |     /**
 565 |      * Constructor
 566 |      * @param bool $exceptions Should we throw external exceptions?
 567 |      */
 568 |     public function __construct($exceptions = false)
 569 |     {
 570 |         $this->exceptions = ($exceptions == true);
 571 |     }
 572 | 
 573 |     /**
 574 |      * Destructor.
 575 |      */
 576 |     public function __destruct()
 577 |     {
 578 |         if ($this->Mailer == 'smtp') { //close any open SMTP connection nicely
 579 |             $this->smtpClose();
 580 |         }
 581 |     }
 582 | 
 583 |     /**
 584 |      * Call mail() in a safe_mode-aware fashion.
 585 |      * Also, unless sendmail_path points to sendmail (or something that
 586 |      * claims to be sendmail), don't pass params (not a perfect fix,
 587 |      * but it will do)
 588 |      * @param string $to To
 589 |      * @param string $subject Subject
 590 |      * @param string $body Message Body
 591 |      * @param string $header Additional Header(s)
 592 |      * @param string $params Params
 593 |      * @access private
 594 |      * @return bool
 595 |      */
 596 |     private function mailPassthru($to, $subject, $body, $header, $params)
 597 |     {
 598 |         //Check overloading of mail function to avoid double-encoding
 599 |         if (ini_get('mbstring.func_overload') & 1) {
 600 |             $subject = $this->secureHeader($subject);
 601 |         } else {
 602 |             $subject = $this->encodeHeader($this->secureHeader($subject));
 603 |         }
 604 |         if (ini_get('safe_mode') || !($this->UseSendmailOptions)) {
 605 |             $rt = @mail($to, $subject, $body, $header);
 606 |         } else {
 607 |             $rt = @mail($to, $subject, $body, $header, $params);
 608 |         }
 609 |         return $rt;
 610 |     }
 611 | 
 612 |     /**
 613 |      * Output debugging info via user-defined method.
 614 |      * Only if debug output is enabled.
 615 |      * @see PHPMailer::$Debugoutput
 616 |      * @see PHPMailer::$SMTPDebug
 617 |      * @param string $str
 618 |      */
 619 |     protected function edebug($str)
 620 |     {
 621 |         if (!$this->SMTPDebug) {
 622 |             return;
 623 |         }
 624 |         switch ($this->Debugoutput) {
 625 |             case 'error_log':
 626 |                 error_log($str);
 627 |                 break;
 628 |             case 'html':
 629 |                 //Cleans up output a bit for a better looking display that's HTML-safe
 630 |                 echo htmlentities(preg_replace('/[\r\n]+/', '', $str), ENT_QUOTES, $this->CharSet) . "<br>\n";
 631 |                 break;
 632 |             case 'echo':
 633 |             default:
 634 |                 echo $str."\n";
 635 |         }
 636 |     }
 637 | 
 638 |     /**
 639 |      * Sets message type to HTML or plain.
 640 |      * @param bool $ishtml True for HTML mode.
 641 |      * @return void
 642 |      */
 643 |     public function isHTML($ishtml = true)
 644 |     {
 645 |         if ($ishtml) {
 646 |             $this->ContentType = 'text/html';
 647 |         } else {
 648 |             $this->ContentType = 'text/plain';
 649 |         }
 650 |     }
 651 | 
 652 |     /**
 653 |      * Send messages using SMTP.
 654 |      * @return void
 655 |      */
 656 |     public function isSMTP()
 657 |     {
 658 |         $this->Mailer = 'smtp';
 659 |     }
 660 | 
 661 |     /**
 662 |      * Send messages using PHP's mail() function.
 663 |      * @return void
 664 |      */
 665 |     public function isMail()
 666 |     {
 667 |         $this->Mailer = 'mail';
 668 |     }
 669 | 
 670 |     /**
 671 |      * Send messages using $Sendmail.
 672 |      * @return void
 673 |      */
 674 |     public function isSendmail()
 675 |     {
 676 |         if (!stristr(ini_get('sendmail_path'), 'sendmail')) {
 677 |             $this->Sendmail = '/usr/sbin/sendmail';
 678 |         }
 679 |         $this->Mailer = 'sendmail';
 680 |     }
 681 | 
 682 |     /**
 683 |      * Send messages using qmail.
 684 |      * @return void
 685 |      */
 686 |     public function isQmail()
 687 |     {
 688 |         if (!stristr(ini_get('sendmail_path'), 'qmail')) {
 689 |             $this->Sendmail = '/var/qmail/bin/qmail-inject';
 690 |         }
 691 |         $this->Mailer = 'qmail';
 692 |     }
 693 | 
 694 |     /**
 695 |      * Add a "To" address.
 696 |      * @param string $address
 697 |      * @param string $name
 698 |      * @return bool true on success, false if address already used
 699 |      */
 700 |     public function addAddress($address, $name = '')
 701 |     {
 702 |         return $this->addAnAddress('to', $address, $name);
 703 |     }
 704 | 
 705 |     /**
 706 |      * Add a "CC" address.
 707 |      * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
 708 |      * @param string $address
 709 |      * @param string $name
 710 |      * @return bool true on success, false if address already used
 711 |      */
 712 |     public function addCC($address, $name = '')
 713 |     {
 714 |         return $this->addAnAddress('cc', $address, $name);
 715 |     }
 716 | 
 717 |     /**
 718 |      * Add a "BCC" address.
 719 |      * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
 720 |      * @param string $address
 721 |      * @param string $name
 722 |      * @return bool true on success, false if address already used
 723 |      */
 724 |     public function addBCC($address, $name = '')
 725 |     {
 726 |         return $this->addAnAddress('bcc', $address, $name);
 727 |     }
 728 | 
 729 |     /**
 730 |      * Add a "Reply-to" address.
 731 |      * @param string $address
 732 |      * @param string $name
 733 |      * @return bool
 734 |      */
 735 |     public function addReplyTo($address, $name = '')
 736 |     {
 737 |         return $this->addAnAddress('Reply-To', $address, $name);
 738 |     }
 739 | 
 740 |     /**
 741 |      * Add an address to one of the recipient arrays.
 742 |      * Addresses that have been added already return false, but do not throw exceptions
 743 |      * @param string $kind One of 'to', 'cc', 'bcc', 'ReplyTo'
 744 |      * @param string $address The email address to send to
 745 |      * @param string $name
 746 |      * @throws phpmailerException
 747 |      * @return bool true on success, false if address already used or invalid in some way
 748 |      * @access protected
 749 |      */
 750 |     protected function addAnAddress($kind, $address, $name = '')
 751 |     {
 752 |         if (!preg_match('/^(to|cc|bcc|Reply-To)$/', $kind)) {
 753 |             $this->setError($this->lang('Invalid recipient array') . ': ' . $kind);
 754 |             $this->edebug($this->lang('Invalid recipient array') . ': ' . $kind);
 755 |             if ($this->exceptions) {
 756 |                 throw new phpmailerException('Invalid recipient array: ' . $kind);
 757 |             }
 758 |             return false;
 759 |         }
 760 |         $address = trim($address);
 761 |         $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
 762 |         if (!$this->validateAddress($address)) {
 763 |             $this->setError($this->lang('invalid_address') . ': ' . $address);
 764 |             $this->edebug($this->lang('invalid_address') . ': ' . $address);
 765 |             if ($this->exceptions) {
 766 |                 throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
 767 |             }
 768 |             return false;
 769 |         }
 770 |         if ($kind != 'Reply-To') {
 771 |             if (!isset($this->all_recipients[strtolower($address)])) {
 772 |                 array_push($this->$kind, array($address, $name));
 773 |                 $this->all_recipients[strtolower($address)] = true;
 774 |                 return true;
 775 |             }
 776 |         } else {
 777 |             if (!array_key_exists(strtolower($address), $this->ReplyTo)) {
 778 |                 $this->ReplyTo[strtolower($address)] = array($address, $name);
 779 |                 return true;
 780 |             }
 781 |         }
 782 |         return false;
 783 |     }
 784 | 
 785 |     /**
 786 |      * Set the From and FromName properties.
 787 |      * @param string $address
 788 |      * @param string $name
 789 |      * @param bool $auto Whether to also set the Sender address, defaults to true
 790 |      * @throws phpmailerException
 791 |      * @return bool
 792 |      */
 793 |     public function setFrom($address, $name = '', $auto = true)
 794 |     {
 795 |         $address = trim($address);
 796 |         $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
 797 |         if (!$this->validateAddress($address)) {
 798 |             $this->setError($this->lang('invalid_address') . ': ' . $address);
 799 |             $this->edebug($this->lang('invalid_address') . ': ' . $address);
 800 |             if ($this->exceptions) {
 801 |                 throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
 802 |             }
 803 |             return false;
 804 |         }
 805 |         $this->From = $address;
 806 |         $this->FromName = $name;
 807 |         if ($auto) {
 808 |             if (empty($this->Sender)) {
 809 |                 $this->Sender = $address;
 810 |             }
 811 |         }
 812 |         return true;
 813 |     }
 814 | 
 815 |     /**
 816 |      * Return the Message-ID header of the last email.
 817 |      * Technically this is the value from the last time the headers were created,
 818 |      * but it's also the message ID of the last sent message except in
 819 |      * pathological cases.
 820 |      * @return string
 821 |      */
 822 |     public function getLastMessageID()
 823 |     {
 824 |         return $this->lastMessageID;
 825 |     }
 826 | 
 827 |     /**
 828 |      * Check that a string looks like an email address.
 829 |      * @param string $address The email address to check
 830 |      * @param string $patternselect A selector for the validation pattern to use :
 831 |      *   'auto' - pick best one automatically;
 832 |      *   'pcre8' - use the squiloople.com pattern, requires PCRE > 8.0, PHP >= 5.3.2, 5.2.14;
 833 |      *   'pcre' - use old PCRE implementation;
 834 |      *   'php' - use PHP built-in FILTER_VALIDATE_EMAIL; faster, less thorough;
 835 |      *   'noregex' - super fast, really dumb.
 836 |      * @return bool
 837 |      * @static
 838 |      * @access public
 839 |      */
 840 |     public static function validateAddress($address, $patternselect = 'auto')
 841 |     {
 842 |         if ($patternselect == 'auto') {
 843 |             if (defined(
 844 |                 'PCRE_VERSION'
 845 |             )
 846 |             ) { //Check this instead of extension_loaded so it works when that function is disabled
 847 |                 if (version_compare(PCRE_VERSION, '8.0') >= 0) {
 848 |                     $patternselect = 'pcre8';
 849 |                 } else {
 850 |                     $patternselect = 'pcre';
 851 |                 }
 852 |             } else {
 853 |                 //Filter_var appeared in PHP 5.2.0 and does not require the PCRE extension
 854 |                 if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
 855 |                     $patternselect = 'php';
 856 |                 } else {
 857 |                     $patternselect = 'noregex';
 858 |                 }
 859 |             }
 860 |         }
 861 |         switch ($patternselect) {
 862 |             case 'pcre8':
 863 |                 /**
 864 |                  * Conforms to RFC5322: Uses *correct* regex on which FILTER_VALIDATE_EMAIL is
 865 |                  * based; So why not use FILTER_VALIDATE_EMAIL? Because it was broken to
 866 |                  * not allow a@b type valid addresses :(
 867 |                  * @link http://squiloople.com/2009/12/20/email-address-validation/
 868 |                  * @copyright 2009-2010 Michael Rushton
 869 |                  * Feel free to use and redistribute this code. But please keep this copyright notice.
 870 |                  */
 871 |                 return (bool)preg_match(
 872 |                     '/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
 873 |                     '((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
 874 |                     '(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
 875 |                     '([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*' .
 876 |                     '(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)' .
 877 |                     '(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}' .
 878 |                     '|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:' .
 879 |                     '|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
 880 |                     '|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
 881 |                     $address
 882 |                 );
 883 |                 break;
 884 |             case 'pcre':
 885 |                 //An older regex that doesn't need a recent PCRE
 886 |                 return (bool)preg_match(
 887 |                     '/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!(?>"?(?>\\\[ -~]|[^"])"?){65,}@)(?>' .
 888 |                     '[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*")' .
 889 |                     '(?>\.(?>[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*"))*' .
 890 |                     '@(?>(?![a-z0-9-]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>\.(?![a-z0-9-]{64,})' .
 891 |                     '(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)){0,126}|\[(?:(?>IPv6:(?>(?>[a-f0-9]{1,4})(?>:' .
 892 |                     '[a-f0-9]{1,4}){7}|(?!(?:.*[a-f0-9][:\]]){8,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?' .
 893 |                     '::(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?))|(?>(?>IPv6:(?>[a-f0-9]{1,4}(?>:' .
 894 |                     '[a-f0-9]{1,4}){5}:|(?!(?:.*[a-f0-9]:){6,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4})?' .
 895 |                     '::(?>(?:[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4}):)?))?(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
 896 |                     '|[1-9]?[0-9])(?>\.(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}))\])$/isD',
 897 |                     $address
 898 |                 );
 899 |                 break;
 900 |             case 'php':
 901 |             default:
 902 |                 return (bool)filter_var($address, FILTER_VALIDATE_EMAIL);
 903 |                 break;
 904 |             case 'noregex':
 905 |                 //No PCRE! Do something _very_ approximate!
 906 |                 //Check the address is 3 chars or longer and contains an @ that's not the first or last char
 907 |                 return (strlen($address) >= 3
 908 |                     and strpos($address, '@') >= 1
 909 |                     and strpos($address, '@') != strlen($address) - 1);
 910 |                 break;
 911 |         }
 912 |     }
 913 | 
 914 |     /**
 915 |      * Create a message and send it.
 916 |      * Uses the sending method specified by $Mailer.
 917 |      * @throws phpmailerException
 918 |      * @return bool false on error - See the ErrorInfo property for details of the error.
 919 |      */
 920 |     public function send()
 921 |     {
 922 |         try {
 923 |             if (!$this->preSend()) {
 924 |                 return false;
 925 |             }
 926 |             return $this->postSend();
 927 |         } catch (phpmailerException $e) {
 928 |             $this->mailHeader = '';
 929 |             $this->setError($e->getMessage());
 930 |             if ($this->exceptions) {
 931 |                 throw $e;
 932 |             }
 933 |             return false;
 934 |         }
 935 |     }
 936 | 
 937 |     /**
 938 |      * Prepare a message for sending.
 939 |      * @throws phpmailerException
 940 |      * @return bool
 941 |      */
 942 |     public function preSend()
 943 |     {
 944 |         try {
 945 |             $this->mailHeader = "";
 946 |             if ((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {
 947 |                 throw new phpmailerException($this->lang('provide_address'), self::STOP_CRITICAL);
 948 |             }
 949 | 
 950 |             // Set whether the message is multipart/alternative
 951 |             if (!empty($this->AltBody)) {
 952 |                 $this->ContentType = 'multipart/alternative';
 953 |             }
 954 | 
 955 |             $this->error_count = 0; // reset errors
 956 |             $this->setMessageType();
 957 |             // Refuse to send an empty message unless we are specifically allowing it
 958 |             if (!$this->AllowEmpty and empty($this->Body)) {
 959 |                 throw new phpmailerException($this->lang('empty_message'), self::STOP_CRITICAL);
 960 |             }
 961 | 
 962 |             $this->MIMEHeader = $this->createHeader();
 963 |             $this->MIMEBody = $this->createBody();
 964 | 
 965 |             // To capture the complete message when using mail(), create
 966 |             // an extra header list which createHeader() doesn't fold in
 967 |             if ($this->Mailer == 'mail') {
 968 |                 if (count($this->to) > 0) {
 969 |                     $this->mailHeader .= $this->addrAppend("To", $this->to);
 970 |                 } else {
 971 |                     $this->mailHeader .= $this->headerLine("To", "undisclosed-recipients:;");
 972 |                 }
 973 |                 $this->mailHeader .= $this->headerLine(
 974 |                     'Subject',
 975 |                     $this->encodeHeader($this->secureHeader(trim($this->Subject)))
 976 |                 );
 977 |             }
 978 | 
 979 |             // Sign with DKIM if enabled
 980 |             if (!empty($this->DKIM_domain)
 981 |                 && !empty($this->DKIM_private)
 982 |                 && !empty($this->DKIM_selector)
 983 |                 && !empty($this->DKIM_domain)
 984 |                 && file_exists($this->DKIM_private)) {
 985 |                 $header_dkim = $this->DKIM_Add(
 986 |                     $this->MIMEHeader . $this->mailHeader,
 987 |                     $this->encodeHeader($this->secureHeader($this->Subject)),
 988 |                     $this->MIMEBody
 989 |                 );
 990 |                 $this->MIMEHeader = rtrim($this->MIMEHeader, "\r\n ") . self::CRLF .
 991 |                     str_replace("\r\n", "\n", $header_dkim) . self::CRLF;
 992 |             }
 993 |             return true;
 994 | 
 995 |         } catch (phpmailerException $e) {
 996 |             $this->setError($e->getMessage());
 997 |             if ($this->exceptions) {
 998 |                 throw $e;
 999 |             }
1000 |             return false;
1001 |         }
1002 |     }
1003 | 
1004 |     /**
1005 |      * Actually send a message.
1006 |      * Send the email via the selected mechanism
1007 |      * @throws phpmailerException
1008 |      * @return bool
1009 |      */
1010 |     public function postSend()
1011 |     {
1012 |         try {
1013 |             // Choose the mailer and send through it
1014 |             switch ($this->Mailer) {
1015 |                 case 'sendmail':
1016 |                 case 'qmail':
1017 |                     return $this->sendmailSend($this->MIMEHeader, $this->MIMEBody);
1018 |                 case 'smtp':
1019 |                     return $this->smtpSend($this->MIMEHeader, $this->MIMEBody);
1020 |                 case 'mail':
1021 |                     return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
1022 |                 default:
1023 |                     if (method_exists($this, $this->Mailer.'Send')) {
1024 |                         $sendMethod = $this->Mailer.'Send';
1025 |                         return $this->$sendMethod($this->MIMEHeader, $this->MIMEBody);
1026 |                     } else {
1027 |                         return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
1028 |                     }
1029 |             }
1030 |         } catch (phpmailerException $e) {
1031 |             $this->setError($e->getMessage());
1032 |             $this->edebug($e->getMessage());
1033 |             if ($this->exceptions) {
1034 |                 throw $e;
1035 |             }
1036 |         }
1037 |         return false;
1038 |     }
1039 | 
1040 |     /**
1041 |      * Send mail using the $Sendmail program.
1042 |      * @param string $header The message headers
1043 |      * @param string $body The message body
1044 |      * @see PHPMailer::$Sendmail
1045 |      * @throws phpmailerException
1046 |      * @access protected
1047 |      * @return bool
1048 |      */
1049 |     protected function sendmailSend($header, $body)
1050 |     {
1051 |         if ($this->Sender != '') {
1052 |             if ($this->Mailer == 'qmail') {
1053 |                 $sendmail = sprintf("%s -f%s", escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
1054 |             } else {
1055 |                 $sendmail = sprintf("%s -oi -f%s -t", escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
1056 |             }
1057 |         } else {
1058 |             if ($this->Mailer == 'qmail') {
1059 |                 $sendmail = sprintf("%s", escapeshellcmd($this->Sendmail));
1060 |             } else {
1061 |                 $sendmail = sprintf("%s -oi -t", escapeshellcmd($this->Sendmail));
1062 |             }
1063 |         }
1064 |         if ($this->SingleTo === true) {
1065 |             foreach ($this->SingleToArray as $val) {
1066 |                 if (!@$mail = popen($sendmail, 'w')) {
1067 |                     throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1068 |                 }
1069 |                 fputs($mail, "To: " . $val . "\n");
1070 |                 fputs($mail, $header);
1071 |                 fputs($mail, $body);
1072 |                 $result = pclose($mail);
1073 |                 // implement call back function if it exists
1074 |                 $isSent = ($result == 0) ? 1 : 0;
1075 |                 $this->doCallback($isSent, $val, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1076 |                 if ($result != 0) {
1077 |                     throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1078 |                 }
1079 |             }
1080 |         } else {
1081 |             if (!@$mail = popen($sendmail, 'w')) {
1082 |                 throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1083 |             }
1084 |             fputs($mail, $header);
1085 |             fputs($mail, $body);
1086 |             $result = pclose($mail);
1087 |             // implement call back function if it exists
1088 |             $isSent = ($result == 0) ? 1 : 0;
1089 |             $this->doCallback($isSent, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1090 |             if ($result != 0) {
1091 |                 throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1092 |             }
1093 |         }
1094 |         return true;
1095 |     }
1096 | 
1097 |     /**
1098 |      * Send mail using the PHP mail() function.
1099 |      * @param string $header The message headers
1100 |      * @param string $body The message body
1101 |      * @link http://www.php.net/manual/en/book.mail.php
1102 |      * @throws phpmailerException
1103 |      * @access protected
1104 |      * @return bool
1105 |      */
1106 |     protected function mailSend($header, $body)
1107 |     {
1108 |         $toArr = array();
1109 |         foreach ($this->to as $t) {
1110 |             $toArr[] = $this->addrFormat($t);
1111 |         }
1112 |         $to = implode(', ', $toArr);
1113 | 
1114 |         if (empty($this->Sender)) {
1115 |             $params = " ";
1116 |         } else {
1117 |             $params = sprintf("-f%s", $this->Sender);
1118 |         }
1119 |         if ($this->Sender != '' and !ini_get('safe_mode')) {
1120 |             $old_from = ini_get('sendmail_from');
1121 |             ini_set('sendmail_from', $this->Sender);
1122 |         }
1123 |         $rt = false;
1124 |         if ($this->SingleTo === true && count($toArr) > 1) {
1125 |             foreach ($toArr as $val) {
1126 |                 $rt = $this->mailPassthru($val, $this->Subject, $body, $header, $params);
1127 |                 // implement call back function if it exists
1128 |                 $isSent = ($rt == 1) ? 1 : 0;
1129 |                 $this->doCallback($isSent, $val, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1130 |             }
1131 |         } else {
1132 |             $rt = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
1133 |             // implement call back function if it exists
1134 |             $isSent = ($rt == 1) ? 1 : 0;
1135 |             $this->doCallback($isSent, $to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1136 |         }
1137 |         if (isset($old_from)) {
1138 |             ini_set('sendmail_from', $old_from);
1139 |         }
1140 |         if (!$rt) {
1141 |             throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
1142 |         }
1143 |         return true;
1144 |     }
1145 | 
1146 |     /**
1147 |      * Get an instance to use for SMTP operations.
1148 |      * Override this function to load your own SMTP implementation
1149 |      * @return SMTP
1150 |      */
1151 |     public function getSMTPInstance()
1152 |     {
1153 |         if (!is_object($this->smtp)) {
1154 |             $this->smtp = new SMTP;
1155 |         }
1156 |         return $this->smtp;
1157 |     }
1158 | 
1159 |     /**
1160 |      * Send mail via SMTP.
1161 |      * Returns false if there is a bad MAIL FROM, RCPT, or DATA input.
1162 |      * Uses the PHPMailerSMTP class by default.
1163 |      * @see PHPMailer::getSMTPInstance() to use a different class.
1164 |      * @param string $header The message headers
1165 |      * @param string $body The message body
1166 |      * @throws phpmailerException
1167 |      * @uses SMTP
1168 |      * @access protected
1169 |      * @return bool
1170 |      */
1171 |     protected function smtpSend($header, $body)
1172 |     {
1173 |         $bad_rcpt = array();
1174 | 
1175 |         if (!$this->smtpConnect()) {
1176 |             throw new phpmailerException($this->lang('smtp_connect_failed'), self::STOP_CRITICAL);
1177 |         }
1178 |         $smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;
1179 |         if (!$this->smtp->mail($smtp_from)) {
1180 |             $this->setError($this->lang('from_failed') . $smtp_from . ' : ' . implode(',', $this->smtp->getError()));
1181 |             throw new phpmailerException($this->ErrorInfo, self::STOP_CRITICAL);
1182 |         }
1183 | 
1184 |         // Attempt to send to all recipients
1185 |         foreach ($this->to as $to) {
1186 |             if (!$this->smtp->recipient($to[0])) {
1187 |                 $bad_rcpt[] = $to[0];
1188 |                 $isSent = 0;
1189 |             } else {
1190 |                 $isSent = 1;
1191 |             }
1192 |             $this->doCallback($isSent, $to[0], '', '', $this->Subject, $body, $this->From);
1193 |         }
1194 |         foreach ($this->cc as $cc) {
1195 |             if (!$this->smtp->recipient($cc[0])) {
1196 |                 $bad_rcpt[] = $cc[0];
1197 |                 $isSent = 0;
1198 |             } else {
1199 |                 $isSent = 1;
1200 |             }
1201 |             $this->doCallback($isSent, '', $cc[0], '', $this->Subject, $body, $this->From);
1202 |         }
1203 |         foreach ($this->bcc as $bcc) {
1204 |             if (!$this->smtp->recipient($bcc[0])) {
1205 |                 $bad_rcpt[] = $bcc[0];
1206 |                 $isSent = 0;
1207 |             } else {
1208 |                 $isSent = 1;
1209 |             }
1210 |             $this->doCallback($isSent, '', '', $bcc[0], $this->Subject, $body, $this->From);
1211 |         }
1212 | 
1213 |         //Only send the DATA command if we have viable recipients
1214 |         if ((count($this->all_recipients) > count($bad_rcpt)) and !$this->smtp->data($header . $body)) {
1215 |             throw new phpmailerException($this->lang('data_not_accepted'), self::STOP_CRITICAL);
1216 |         }
1217 |         if ($this->SMTPKeepAlive == true) {
1218 |             $this->smtp->reset();
1219 |         } else {
1220 |             $this->smtp->quit();
1221 |             $this->smtp->close();
1222 |         }
1223 |         if (count($bad_rcpt) > 0) { //Create error message for any bad addresses
1224 |             throw new phpmailerException(
1225 |                 $this->lang('recipients_failed') . implode(', ', $bad_rcpt),
1226 |                 self::STOP_CONTINUE
1227 |             );
1228 |         }
1229 |         return true;
1230 |     }
1231 | 
1232 |     /**
1233 |      * Initiate a connection to an SMTP server.
1234 |      * Returns false if the operation failed.
1235 |      * @param array $options An array of options compatible with stream_context_create()
1236 |      * @uses SMTP
1237 |      * @access public
1238 |      * @throws phpmailerException
1239 |      * @return bool
1240 |      */
1241 |     public function smtpConnect($options = array())
1242 |     {
1243 |         if (is_null($this->smtp)) {
1244 |             $this->smtp = $this->getSMTPInstance();
1245 |         }
1246 | 
1247 |         //Already connected?
1248 |         if ($this->smtp->connected()) {
1249 |             return true;
1250 |         }
1251 | 
1252 |         $this->smtp->setTimeout($this->Timeout);
1253 |         $this->smtp->setDebugLevel($this->SMTPDebug);
1254 |         $this->smtp->setDebugOutput($this->Debugoutput);
1255 |         $this->smtp->setVerp($this->do_verp);
1256 |         $hosts = explode(';', $this->Host);
1257 |         $lastexception = null;
1258 | 
1259 |         foreach ($hosts as $hostentry) {
1260 |             $hostinfo = array();
1261 |             if (!preg_match('/^((ssl|tls):\/\/)*([a-zA-Z0-9\.-]*):?([0-9]*)$/', trim($hostentry), $hostinfo)) {
1262 |                 //Not a valid host entry
1263 |                 continue;
1264 |             }
1265 |             //$hostinfo[2]: optional ssl or tls prefix
1266 |             //$hostinfo[3]: the hostname
1267 |             //$hostinfo[4]: optional port number
1268 |             //The host string prefix can temporarily override the current setting for SMTPSecure
1269 |             //If it's not specified, the default value is used
1270 |             $prefix = '';
1271 |             $tls = ($this->SMTPSecure == 'tls');
1272 |             if ($hostinfo[2] == 'ssl' or ($hostinfo[2] == '' and $this->SMTPSecure == 'ssl')) {
1273 |                 $prefix = 'ssl://';
1274 |                 $tls = false; //Can't have SSL and TLS at once
1275 |             } elseif ($hostinfo[2] == 'tls') {
1276 |                 $tls = true;
1277 |                 //tls doesn't use a prefix
1278 |             }
1279 |             $host = $hostinfo[3];
1280 |             $port = $this->Port;
1281 |             $tport = (integer)$hostinfo[4];
1282 |             if ($tport > 0 and $tport < 65536) {
1283 |                 $port = $tport;
1284 |             }
1285 |             if ($this->smtp->connect($prefix . $host, $port, $this->Timeout, $options)) {
1286 |                 try {
1287 |                     if ($this->Helo) {
1288 |                         $hello = $this->Helo;
1289 |                     } else {
1290 |                         $hello = $this->serverHostname();
1291 |                     }
1292 |                     $this->smtp->hello($hello);
1293 | 
1294 |                     if ($tls) {
1295 |                         if (!$this->smtp->startTLS()) {
1296 |                             throw new phpmailerException($this->lang('connect_host'));
1297 |                         }
1298 |                         //We must resend HELO after tls negotiation
1299 |                         $this->smtp->hello($hello);
1300 |                     }
1301 |                     if ($this->SMTPAuth) {
1302 |                         if (!$this->smtp->authenticate(
1303 |                             $this->Username,
1304 |                             $this->Password,
1305 |                             $this->AuthType,
1306 |                             $this->Realm,
1307 |                             $this->Workstation
1308 |                         )
1309 |                         ) {
1310 |                             throw new phpmailerException($this->lang('authenticate'));
1311 |                         }
1312 |                     }
1313 |                     return true;
1314 |                 } catch (phpmailerException $e) {
1315 |                     $lastexception = $e;
1316 |                     //We must have connected, but then failed TLS or Auth, so close connection nicely
1317 |                     $this->smtp->quit();
1318 |                 }
1319 |             }
1320 |         }
1321 |         //If we get here, all connection attempts have failed, so close connection hard
1322 |         $this->smtp->close();
1323 |         //As we've caught all exceptions, just report whatever the last one was
1324 |         if ($this->exceptions and !is_null($lastexception)) {
1325 |             throw $lastexception;
1326 |         }
1327 |         return false;
1328 |     }
1329 | 
1330 |     /**
1331 |      * Close the active SMTP session if one exists.
1332 |      * @return void
1333 |      */
1334 |     public function smtpClose()
1335 |     {
1336 |         if ($this->smtp !== null) {
1337 |             if ($this->smtp->connected()) {
1338 |                 $this->smtp->quit();
1339 |                 $this->smtp->close();
1340 |             }
1341 |         }
1342 |     }
1343 | 
1344 |     /**
1345 |      * Set the language for error messages.
1346 |      * Returns false if it cannot load the language file.
1347 |      * The default language is English.
1348 |      * @param string $langcode ISO 639-1 2-character language code (e.g. French is "fr")
1349 |      * @param string $lang_path Path to the language file directory, with trailing separator (slash)
1350 |      * @return bool
1351 |      * @access public
1352 |      */
1353 |     public function setLanguage($langcode = 'en', $lang_path = 'language/')
1354 |     {
1355 |         //Define full set of translatable strings
1356 |         $PHPMAILER_LANG = array(
1357 |             'authenticate' => 'SMTP Error: Could not authenticate.',
1358 |             'connect_host' => 'SMTP Error: Could not connect to SMTP host.',
1359 |             'data_not_accepted' => 'SMTP Error: data not accepted.',
1360 |             'empty_message' => 'Message body empty',
1361 |             'encoding' => 'Unknown encoding: ',
1362 |             'execute' => 'Could not execute: ',
1363 |             'file_access' => 'Could not access file: ',
1364 |             'file_open' => 'File Error: Could not open file: ',
1365 |             'from_failed' => 'The following From address failed: ',
1366 |             'instantiate' => 'Could not instantiate mail function.',
1367 |             'invalid_address' => 'Invalid address',
1368 |             'mailer_not_supported' => ' mailer is not supported.',
1369 |             'provide_address' => 'You must provide at least one recipient email address.',
1370 |             'recipients_failed' => 'SMTP Error: The following recipients failed: ',
1371 |             'signing' => 'Signing Error: ',
1372 |             'smtp_connect_failed' => 'SMTP connect() failed.',
1373 |             'smtp_error' => 'SMTP server error: ',
1374 |             'variable_set' => 'Cannot set or reset variable: '
1375 |         );
1376 |         //Overwrite language-specific strings.
1377 |         //This way we'll never have missing translations - no more "language string failed to load"!
1378 |         $l = true;
1379 |         $lang_file = $lang_path . 'phpmailer.lang-' . $langcode . '.php';
1380 |         if ($langcode != 'en') { //There is no English translation file
1381 |             //Make sure language file path is readable
1382 |             if (!is_readable($lang_file)) {
1383 |                 $l = false;
1384 |             } else {
1385 |                 $l = include $lang_file;
1386 |             }
1387 |         }
1388 |         $this->language = $PHPMAILER_LANG;
1389 |         return ($l == true); //Returns false if language not found
1390 |     }
1391 | 
1392 |     /**
1393 |      * Get the array of strings for the current language.
1394 |      * @return array
1395 |      */
1396 |     public function getTranslations()
1397 |     {
1398 |         return $this->language;
1399 |     }
1400 | 
1401 |     /**
1402 |      * Create recipient headers.
1403 |      * @access public
1404 |      * @param string $type
1405 |      * @param array $addr An array of recipient,
1406 |      * where each recipient is a 2-element indexed array with element 0 containing an address
1407 |      * and element 1 containing a name, like:
1408 |      * array(array('joe@example.com', 'Joe User'), array('zoe@example.com', 'Zoe User'))
1409 |      * @return string
1410 |      */
1411 |     public function addrAppend($type, $addr)
1412 |     {
1413 |         $addresses = array();
1414 |         foreach ($addr as $a) {
1415 |             $addresses[] = $this->addrFormat($a);
1416 |         }
1417 |         return $type . ': ' . implode(', ', $addresses) . $this->LE;
1418 |     }
1419 | 
1420 |     /**
1421 |      * Format an address for use in a message header.
1422 |      * @access public
1423 |      * @param array $addr A 2-element indexed array, element 0 containing an address, element 1 containing a name
1424 |      *      like array('joe@example.com', 'Joe User')
1425 |      * @return string
1426 |      */
1427 |     public function addrFormat($addr)
1428 |     {
1429 |         if (empty($addr[1])) { // No name provided
1430 |             return $this->secureHeader($addr[0]);
1431 |         } else {
1432 |             return $this->encodeHeader($this->secureHeader($addr[1]), 'phrase') . " <" . $this->secureHeader(
1433 |                 $addr[0]
1434 |             ) . ">";
1435 |         }
1436 |     }
1437 | 
1438 |     /**
1439 |      * Word-wrap message.
1440 |      * For use with mailers that do not automatically perform wrapping
1441 |      * and for quoted-printable encoded messages.
1442 |      * Original written by philippe.
1443 |      * @param string $message The message to wrap
1444 |      * @param integer $length The line length to wrap to
1445 |      * @param bool $qp_mode Whether to run in Quoted-Printable mode
1446 |      * @access public
1447 |      * @return string
1448 |      */
1449 |     public function wrapText($message, $length, $qp_mode = false)
1450 |     {
1451 |         $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
1452 |         // If utf-8 encoding is used, we will need to make sure we don't
1453 |         // split multibyte characters when we wrap
1454 |         $is_utf8 = (strtolower($this->CharSet) == "utf-8");
1455 |         $lelen = strlen($this->LE);
1456 |         $crlflen = strlen(self::CRLF);
1457 | 
1458 |         $message = $this->fixEOL($message);
1459 |         if (substr($message, -$lelen) == $this->LE) {
1460 |             $message = substr($message, 0, -$lelen);
1461 |         }
1462 | 
1463 |         $line = explode($this->LE, $message); // Magic. We know fixEOL uses $LE
1464 |         $message = '';
1465 |         for ($i = 0; $i < count($line); $i++) {
1466 |             $line_part = explode(' ', $line[$i]);
1467 |             $buf = '';
1468 |             for ($e = 0; $e < count($line_part); $e++) {
1469 |                 $word = $line_part[$e];
1470 |                 if ($qp_mode and (strlen($word) > $length)) {
1471 |                     $space_left = $length - strlen($buf) - $crlflen;
1472 |                     if ($e != 0) {
1473 |                         if ($space_left > 20) {
1474 |                             $len = $space_left;
1475 |                             if ($is_utf8) {
1476 |                                 $len = $this->utf8CharBoundary($word, $len);
1477 |                             } elseif (substr($word, $len - 1, 1) == "=") {
1478 |                                 $len--;
1479 |                             } elseif (substr($word, $len - 2, 1) == "=") {
1480 |                                 $len -= 2;
1481 |                             }
1482 |                             $part = substr($word, 0, $len);
1483 |                             $word = substr($word, $len);
1484 |                             $buf .= ' ' . $part;
1485 |                             $message .= $buf . sprintf("=%s", self::CRLF);
1486 |                         } else {
1487 |                             $message .= $buf . $soft_break;
1488 |                         }
1489 |                         $buf = '';
1490 |                     }
1491 |                     while (strlen($word) > 0) {
1492 |                         if ($length <= 0) {
1493 |                             break;
1494 |                         }
1495 |                         $len = $length;
1496 |                         if ($is_utf8) {
1497 |                             $len = $this->utf8CharBoundary($word, $len);
1498 |                         } elseif (substr($word, $len - 1, 1) == "=") {
1499 |                             $len--;
1500 |                         } elseif (substr($word, $len - 2, 1) == "=") {
1501 |                             $len -= 2;
1502 |                         }
1503 |                         $part = substr($word, 0, $len);
1504 |                         $word = substr($word, $len);
1505 | 
1506 |                         if (strlen($word) > 0) {
1507 |                             $message .= $part . sprintf("=%s", self::CRLF);
1508 |                         } else {
1509 |                             $buf = $part;
1510 |                         }
1511 |                     }
1512 |                 } else {
1513 |                     $buf_o = $buf;
1514 |                     $buf .= ($e == 0) ? $word : (' ' . $word);
1515 | 
1516 |                     if (strlen($buf) > $length and $buf_o != '') {
1517 |                         $message .= $buf_o . $soft_break;
1518 |                         $buf = $word;
1519 |                     }
1520 |                 }
1521 |             }
1522 |             $message .= $buf . self::CRLF;
1523 |         }
1524 | 
1525 |         return $message;
1526 |     }
1527 | 
1528 |     /**
1529 |      * Find the last character boundary prior to $maxLength in a utf-8
1530 |      * quoted (printable) encoded string.
1531 |      * Original written by Colin Brown.
1532 |      * @access public
1533 |      * @param string $encodedText utf-8 QP text
1534 |      * @param int $maxLength   find last character boundary prior to this length
1535 |      * @return int
1536 |      */
1537 |     public function utf8CharBoundary($encodedText, $maxLength)
1538 |     {
1539 |         $foundSplitPos = false;
1540 |         $lookBack = 3;
1541 |         while (!$foundSplitPos) {
1542 |             $lastChunk = substr($encodedText, $maxLength - $lookBack, $lookBack);
1543 |             $encodedCharPos = strpos($lastChunk, "=");
1544 |             if ($encodedCharPos !== false) {
1545 |                 // Found start of encoded character byte within $lookBack block.
1546 |                 // Check the encoded byte value (the 2 chars after the '=')
1547 |                 $hex = substr($encodedText, $maxLength - $lookBack + $encodedCharPos + 1, 2);
1548 |                 $dec = hexdec($hex);
1549 |                 if ($dec < 128) { // Single byte character.
1550 |                     // If the encoded char was found at pos 0, it will fit
1551 |                     // otherwise reduce maxLength to start of the encoded char
1552 |                     $maxLength = ($encodedCharPos == 0) ? $maxLength :
1553 |                         $maxLength - ($lookBack - $encodedCharPos);
1554 |                     $foundSplitPos = true;
1555 |                 } elseif ($dec >= 192) { // First byte of a multi byte character
1556 |                     // Reduce maxLength to split at start of character
1557 |                     $maxLength = $maxLength - ($lookBack - $encodedCharPos);
1558 |                     $foundSplitPos = true;
1559 |                 } elseif ($dec < 192) { // Middle byte of a multi byte character, look further back
1560 |                     $lookBack += 3;
1561 |                 }
1562 |             } else {
1563 |                 // No encoded character found
1564 |                 $foundSplitPos = true;
1565 |             }
1566 |         }
1567 |         return $maxLength;
1568 |     }
1569 | 
1570 | 
1571 |     /**
1572 |      * Set the body wrapping.
1573 |      * @access public
1574 |      * @return void
1575 |      */
1576 |     public function setWordWrap()
1577 |     {
1578 |         if ($this->WordWrap < 1) {
1579 |             return;
1580 |         }
1581 | 
1582 |         switch ($this->message_type) {
1583 |             case 'alt':
1584 |             case 'alt_inline':
1585 |             case 'alt_attach':
1586 |             case 'alt_inline_attach':
1587 |                 $this->AltBody = $this->wrapText($this->AltBody, $this->WordWrap);
1588 |                 break;
1589 |             default:
1590 |                 $this->Body = $this->wrapText($this->Body, $this->WordWrap);
1591 |                 break;
1592 |         }
1593 |     }
1594 | 
1595 |     /**
1596 |      * Assemble message headers.
1597 |      * @access public
1598 |      * @return string The assembled headers
1599 |      */
1600 |     public function createHeader()
1601 |     {
1602 |         $result = '';
1603 | 
1604 |         // Set the boundaries
1605 |         $uniq_id = md5(uniqid(time()));
1606 |         $this->boundary[1] = 'b1_' . $uniq_id;
1607 |         $this->boundary[2] = 'b2_' . $uniq_id;
1608 |         $this->boundary[3] = 'b3_' . $uniq_id;
1609 | 
1610 |         if ($this->MessageDate == '') {
1611 |             $result .= $this->headerLine('Date', self::rfcDate());
1612 |         } else {
1613 |             $result .= $this->headerLine('Date', $this->MessageDate);
1614 |         }
1615 | 
1616 |         if ($this->ReturnPath) {
1617 |             $result .= $this->headerLine('Return-Path', '<' . trim($this->ReturnPath) . '>');
1618 |         } elseif ($this->Sender == '') {
1619 |             $result .= $this->headerLine('Return-Path', '<' . trim($this->From) . '>');
1620 |         } else {
1621 |             $result .= $this->headerLine('Return-Path', '<' . trim($this->Sender) . '>');
1622 |         }
1623 | 
1624 |         // To be created automatically by mail()
1625 |         if ($this->Mailer != 'mail') {
1626 |             if ($this->SingleTo === true) {
1627 |                 foreach ($this->to as $t) {
1628 |                     $this->SingleToArray[] = $this->addrFormat($t);
1629 |                 }
1630 |             } else {
1631 |                 if (count($this->to) > 0) {
1632 |                     $result .= $this->addrAppend('To', $this->to);
1633 |                 } elseif (count($this->cc) == 0) {
1634 |                     $result .= $this->headerLine('To', 'undisclosed-recipients:;');
1635 |                 }
1636 |             }
1637 |         }
1638 | 
1639 |         $result .= $this->addrAppend('From', array(array(trim($this->From), $this->FromName)));
1640 | 
1641 |         // sendmail and mail() extract Cc from the header before sending
1642 |         if (count($this->cc) > 0) {
1643 |             $result .= $this->addrAppend('Cc', $this->cc);
1644 |         }
1645 | 
1646 |         // sendmail and mail() extract Bcc from the header before sending
1647 |         if ((
1648 |                 $this->Mailer == 'sendmail' or $this->Mailer == 'qmail' or $this->Mailer == 'mail'
1649 |             )
1650 |             and count($this->bcc) > 0
1651 |         ) {
1652 |             $result .= $this->addrAppend('Bcc', $this->bcc);
1653 |         }
1654 | 
1655 |         if (count($this->ReplyTo) > 0) {
1656 |             $result .= $this->addrAppend('Reply-To', $this->ReplyTo);
1657 |         }
1658 | 
1659 |         // mail() sets the subject itself
1660 |         if ($this->Mailer != 'mail') {
1661 |             $result .= $this->headerLine('Subject', $this->encodeHeader($this->secureHeader($this->Subject)));
1662 |         }
1663 | 
1664 |         if ($this->MessageID != '') {
1665 |             $this->lastMessageID = $this->MessageID;
1666 |         } else {
1667 |             $this->lastMessageID = sprintf("<%s@%s>", $uniq_id, $this->ServerHostname());
1668 |         }
1669 |         $result .= $this->HeaderLine('Message-ID', $this->lastMessageID);
1670 |         $result .= $this->headerLine('X-Priority', $this->Priority);
1671 |         if ($this->XMailer == '') {
1672 |             $result .= $this->headerLine(
1673 |                 'X-Mailer',
1674 |                 'PHPMailer ' . $this->Version . ' (https://github.com/PHPMailer/PHPMailer/)'
1675 |             );
1676 |         } else {
1677 |             $myXmailer = trim($this->XMailer);
1678 |             if ($myXmailer) {
1679 |                 $result .= $this->headerLine('X-Mailer', $myXmailer);
1680 |             }
1681 |         }
1682 | 
1683 |         if ($this->ConfirmReadingTo != '') {
1684 |             $result .= $this->headerLine('Disposition-Notification-To', '<' . trim($this->ConfirmReadingTo) . '>');
1685 |         }
1686 | 
1687 |         // Add custom headers
1688 |         for ($index = 0; $index < count($this->CustomHeader); $index++) {
1689 |             $result .= $this->headerLine(
1690 |                 trim($this->CustomHeader[$index][0]),
1691 |                 $this->encodeHeader(trim($this->CustomHeader[$index][1]))
1692 |             );
1693 |         }
1694 |         if (!$this->sign_key_file) {
1695 |             $result .= $this->headerLine('MIME-Version', '1.0');
1696 |             $result .= $this->getMailMIME();
1697 |         }
1698 | 
1699 |         return $result;
1700 |     }
1701 | 
1702 |     /**
1703 |      * Get the message MIME type headers.
1704 |      * @access public
1705 |      * @return string
1706 |      */
1707 |     public function getMailMIME()
1708 |     {
1709 |         $result = '';
1710 |         switch ($this->message_type) {
1711 |             case 'inline':
1712 |                 $result .= $this->headerLine('Content-Type', 'multipart/related;');
1713 |                 $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1714 |                 break;
1715 |             case 'attach':
1716 |             case 'inline_attach':
1717 |             case 'alt_attach':
1718 |             case 'alt_inline_attach':
1719 |                 $result .= $this->headerLine('Content-Type', 'multipart/mixed;');
1720 |                 $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1721 |                 break;
1722 |             case 'alt':
1723 |             case 'alt_inline':
1724 |                 $result .= $this->headerLine('Content-Type', 'multipart/alternative;');
1725 |                 $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1726 |                 break;
1727 |             default:
1728 |                 // Catches case 'plain': and case '':
1729 |                 $result .= $this->textLine('Content-Type: ' . $this->ContentType . '; charset=' . $this->CharSet);
1730 |                 break;
1731 |         }
1732 |         //RFC1341 part 5 says 7bit is assumed if not specified
1733 |         if ($this->Encoding != '7bit') {
1734 |             $result .= $this->headerLine('Content-Transfer-Encoding', $this->Encoding);
1735 |         }
1736 | 
1737 |         if ($this->Mailer != 'mail') {
1738 |             $result .= $this->LE;
1739 |         }
1740 | 
1741 |         return $result;
1742 |     }
1743 | 
1744 |     /**
1745 |      * Returns the whole MIME message.
1746 |      * Includes complete headers and body.
1747 |      * Only valid post PreSend().
1748 |      * @see PHPMailer::PreSend()
1749 |      * @access public
1750 |      * @return string
1751 |      */
1752 |     public function getSentMIMEMessage()
1753 |     {
1754 |         return $this->MIMEHeader . $this->mailHeader . self::CRLF . $this->MIMEBody;
1755 |     }
1756 | 
1757 | 
1758 |     /**
1759 |      * Assemble the message body.
1760 |      * Returns an empty string on failure.
1761 |      * @access public
1762 |      * @throws phpmailerException
1763 |      * @return string The assembled message body
1764 |      */
1765 |     public function createBody()
1766 |     {
1767 |         $body = '';
1768 | 
1769 |         if ($this->sign_key_file) {
1770 |             $body .= $this->getMailMIME() . $this->LE;
1771 |         }
1772 | 
1773 |         $this->setWordWrap();
1774 | 
1775 |         switch ($this->message_type) {
1776 |             case 'inline':
1777 |                 $body .= $this->getBoundary($this->boundary[1], '', '', '');
1778 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1779 |                 $body .= $this->LE . $this->LE;
1780 |                 $body .= $this->attachAll('inline', $this->boundary[1]);
1781 |                 break;
1782 |             case 'attach':
1783 |                 $body .= $this->getBoundary($this->boundary[1], '', '', '');
1784 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1785 |                 $body .= $this->LE . $this->LE;
1786 |                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1787 |                 break;
1788 |             case 'inline_attach':
1789 |                 $body .= $this->textLine('--' . $this->boundary[1]);
1790 |                 $body .= $this->headerLine('Content-Type', 'multipart/related;');
1791 |                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1792 |                 $body .= $this->LE;
1793 |                 $body .= $this->getBoundary($this->boundary[2], '', '', '');
1794 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1795 |                 $body .= $this->LE . $this->LE;
1796 |                 $body .= $this->attachAll('inline', $this->boundary[2]);
1797 |                 $body .= $this->LE;
1798 |                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1799 |                 break;
1800 |             case 'alt':
1801 |                 $body .= $this->getBoundary($this->boundary[1], '', 'text/plain', '');
1802 |                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
1803 |                 $body .= $this->LE . $this->LE;
1804 |                 $body .= $this->getBoundary($this->boundary[1], '', 'text/html', '');
1805 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1806 |                 $body .= $this->LE . $this->LE;
1807 |                 if (!empty($this->Ical)) {
1808 |                     $body .= $this->getBoundary($this->boundary[1], '', 'text/calendar; method=REQUEST', '');
1809 |                     $body .= $this->encodeString($this->Ical, $this->Encoding);
1810 |                     $body .= $this->LE . $this->LE;
1811 |                 }
1812 |                 $body .= $this->endBoundary($this->boundary[1]);
1813 |                 break;
1814 |             case 'alt_inline':
1815 |                 $body .= $this->getBoundary($this->boundary[1], '', 'text/plain', '');
1816 |                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
1817 |                 $body .= $this->LE . $this->LE;
1818 |                 $body .= $this->textLine('--' . $this->boundary[1]);
1819 |                 $body .= $this->headerLine('Content-Type', 'multipart/related;');
1820 |                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1821 |                 $body .= $this->LE;
1822 |                 $body .= $this->getBoundary($this->boundary[2], '', 'text/html', '');
1823 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1824 |                 $body .= $this->LE . $this->LE;
1825 |                 $body .= $this->attachAll('inline', $this->boundary[2]);
1826 |                 $body .= $this->LE;
1827 |                 $body .= $this->endBoundary($this->boundary[1]);
1828 |                 break;
1829 |             case 'alt_attach':
1830 |                 $body .= $this->textLine('--' . $this->boundary[1]);
1831 |                 $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
1832 |                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1833 |                 $body .= $this->LE;
1834 |                 $body .= $this->getBoundary($this->boundary[2], '', 'text/plain', '');
1835 |                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
1836 |                 $body .= $this->LE . $this->LE;
1837 |                 $body .= $this->getBoundary($this->boundary[2], '', 'text/html', '');
1838 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1839 |                 $body .= $this->LE . $this->LE;
1840 |                 $body .= $this->endBoundary($this->boundary[2]);
1841 |                 $body .= $this->LE;
1842 |                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1843 |                 break;
1844 |             case 'alt_inline_attach':
1845 |                 $body .= $this->textLine('--' . $this->boundary[1]);
1846 |                 $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
1847 |                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1848 |                 $body .= $this->LE;
1849 |                 $body .= $this->getBoundary($this->boundary[2], '', 'text/plain', '');
1850 |                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
1851 |                 $body .= $this->LE . $this->LE;
1852 |                 $body .= $this->textLine('--' . $this->boundary[2]);
1853 |                 $body .= $this->headerLine('Content-Type', 'multipart/related;');
1854 |                 $body .= $this->textLine("\tboundary=\"" . $this->boundary[3] . '"');
1855 |                 $body .= $this->LE;
1856 |                 $body .= $this->getBoundary($this->boundary[3], '', 'text/html', '');
1857 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1858 |                 $body .= $this->LE . $this->LE;
1859 |                 $body .= $this->attachAll('inline', $this->boundary[3]);
1860 |                 $body .= $this->LE;
1861 |                 $body .= $this->endBoundary($this->boundary[2]);
1862 |                 $body .= $this->LE;
1863 |                 $body .= $this->attachAll('attachment', $this->boundary[1]);
1864 |                 break;
1865 |             default:
1866 |                 // catch case 'plain' and case ''
1867 |                 $body .= $this->encodeString($this->Body, $this->Encoding);
1868 |                 break;
1869 |         }
1870 | 
1871 |         if ($this->isError()) {
1872 |             $body = '';
1873 |         } elseif ($this->sign_key_file) {
1874 |             try {
1875 |                 if (!defined('PKCS7_TEXT')) {
1876 |                     throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
1877 |                 }
1878 |                 //TODO would be nice to use php://temp streams here, but need to wrap for PHP < 5.1
1879 |                 $file = tempnam(sys_get_temp_dir(), 'mail');
1880 |                 file_put_contents($file, $body); //TODO check this worked
1881 |                 $signed = tempnam(sys_get_temp_dir(), 'signed');
1882 |                 if (@openssl_pkcs7_sign(
1883 |                     $file,
1884 |                     $signed,
1885 |                     'file://' . realpath($this->sign_cert_file),
1886 |                     array('file://' . realpath($this->sign_key_file), $this->sign_key_pass),
1887 |                     null
1888 |                 )
1889 |                 ) {
1890 |                     @unlink($file);
1891 |                     $body = file_get_contents($signed);
1892 |                     @unlink($signed);
1893 |                 } else {
1894 |                     @unlink($file);
1895 |                     @unlink($signed);
1896 |                     throw new phpmailerException($this->lang('signing') . openssl_error_string());
1897 |                 }
1898 |             } catch (phpmailerException $e) {
1899 |                 $body = '';
1900 |                 if ($this->exceptions) {
1901 |                     throw $e;
1902 |                 }
1903 |             }
1904 |         }
1905 |         return $body;
1906 |     }
1907 | 
1908 |     /**
1909 |      * Return the start of a message boundary.
1910 |      * @access protected
1911 |      * @param string $boundary
1912 |      * @param string $charSet
1913 |      * @param string $contentType
1914 |      * @param string $encoding
1915 |      * @return string
1916 |      */
1917 |     protected function getBoundary($boundary, $charSet, $contentType, $encoding)
1918 |     {
1919 |         $result = '';
1920 |         if ($charSet == '') {
1921 |             $charSet = $this->CharSet;
1922 |         }
1923 |         if ($contentType == '') {
1924 |             $contentType = $this->ContentType;
1925 |         }
1926 |         if ($encoding == '') {
1927 |             $encoding = $this->Encoding;
1928 |         }
1929 |         $result .= $this->textLine('--' . $boundary);
1930 |         $result .= sprintf("Content-Type: %s; charset=%s", $contentType, $charSet);
1931 |         $result .= $this->LE;
1932 |         $result .= $this->headerLine('Content-Transfer-Encoding', $encoding);
1933 |         $result .= $this->LE;
1934 | 
1935 |         return $result;
1936 |     }
1937 | 
1938 |     /**
1939 |      * Return the end of a message boundary.
1940 |      * @access protected
1941 |      * @param string $boundary
1942 |      * @return string
1943 |      */
1944 |     protected function endBoundary($boundary)
1945 |     {
1946 |         return $this->LE . '--' . $boundary . '--' . $this->LE;
1947 |     }
1948 | 
1949 |     /**
1950 |      * Set the message type.
1951 |      * PHPMailer only supports some preset message types,
1952 |      * not arbitrary MIME structures.
1953 |      * @access protected
1954 |      * @return void
1955 |      */
1956 |     protected function setMessageType()
1957 |     {
1958 |         $this->message_type = array();
1959 |         if ($this->alternativeExists()) {
1960 |             $this->message_type[] = "alt";
1961 |         }
1962 |         if ($this->inlineImageExists()) {
1963 |             $this->message_type[] = "inline";
1964 |         }
1965 |         if ($this->attachmentExists()) {
1966 |             $this->message_type[] = "attach";
1967 |         }
1968 |         $this->message_type = implode("_", $this->message_type);
1969 |         if ($this->message_type == "") {
1970 |             $this->message_type = "plain";
1971 |         }
1972 |     }
1973 | 
1974 |     /**
1975 |      * Format a header line.
1976 |      * @access public
1977 |      * @param string $name
1978 |      * @param string $value
1979 |      * @return string
1980 |      */
1981 |     public function headerLine($name, $value)
1982 |     {
1983 |         return $name . ': ' . $value . $this->LE;
1984 |     }
1985 | 
1986 |     /**
1987 |      * Return a formatted mail line.
1988 |      * @access public
1989 |      * @param string $value
1990 |      * @return string
1991 |      */
1992 |     public function textLine($value)
1993 |     {
1994 |         return $value . $this->LE;
1995 |     }
1996 | 
1997 |     /**
1998 |      * Add an attachment from a path on the filesystem.
1999 |      * Returns false if the file could not be found or read.
2000 |      * @param string $path Path to the attachment.
2001 |      * @param string $name Overrides the attachment name.
2002 |      * @param string $encoding File encoding (see $Encoding).
2003 |      * @param string $type File extension (MIME) type.
2004 |      * @param string $disposition Disposition to use
2005 |      * @throws phpmailerException
2006 |      * @return bool
2007 |      */
2008 |     public function addAttachment($path, $name = '', $encoding = 'base64', $type = '', $disposition = 'attachment')
2009 |     {
2010 |         try {
2011 |             if (!@is_file($path)) {
2012 |                 throw new phpmailerException($this->lang('file_access') . $path, self::STOP_CONTINUE);
2013 |             }
2014 | 
2015 |             //If a MIME type is not specified, try to work it out from the file name
2016 |             if ($type == '') {
2017 |                 $type = self::filenameToType($path);
2018 |             }
2019 | 
2020 |             $filename = basename($path);
2021 |             if ($name == '') {
2022 |                 $name = $filename;
2023 |             }
2024 | 
2025 |             $this->attachment[] = array(
2026 |                 0 => $path,
2027 |                 1 => $filename,
2028 |                 2 => $name,
2029 |                 3 => $encoding,
2030 |                 4 => $type,
2031 |                 5 => false, // isStringAttachment
2032 |                 6 => $disposition,
2033 |                 7 => 0
2034 |             );
2035 | 
2036 |         } catch (phpmailerException $e) {
2037 |             $this->setError($e->getMessage());
2038 |             $this->edebug($e->getMessage());
2039 |             if ($this->exceptions) {
2040 |                 throw $e;
2041 |             }
2042 |             return false;
2043 |         }
2044 |         return true;
2045 |     }
2046 | 
2047 |     /**
2048 |      * Return the array of attachments.
2049 |      * @return array
2050 |      */
2051 |     public function getAttachments()
2052 |     {
2053 |         return $this->attachment;
2054 |     }
2055 | 
2056 |     /**
2057 |      * Attach all file, string, and binary attachments to the message.
2058 |      * Returns an empty string on failure.
2059 |      * @access protected
2060 |      * @param string $disposition_type
2061 |      * @param string $boundary
2062 |      * @return string
2063 |      */
2064 |     protected function attachAll($disposition_type, $boundary)
2065 |     {
2066 |         // Return text of body
2067 |         $mime = array();
2068 |         $cidUniq = array();
2069 |         $incl = array();
2070 | 
2071 |         // Add all attachments
2072 |         foreach ($this->attachment as $attachment) {
2073 |             // Check if it is a valid disposition_filter
2074 |             if ($attachment[6] == $disposition_type) {
2075 |                 // Check for string attachment
2076 |                 $string = '';
2077 |                 $path = '';
2078 |                 $bString = $attachment[5];
2079 |                 if ($bString) {
2080 |                     $string = $attachment[0];
2081 |                 } else {
2082 |                     $path = $attachment[0];
2083 |                 }
2084 | 
2085 |                 $inclhash = md5(serialize($attachment));
2086 |                 if (in_array($inclhash, $incl)) {
2087 |                     continue;
2088 |                 }
2089 |                 $incl[] = $inclhash;
2090 |                 $name = $attachment[2];
2091 |                 $encoding = $attachment[3];
2092 |                 $type = $attachment[4];
2093 |                 $disposition = $attachment[6];
2094 |                 $cid = $attachment[7];
2095 |                 if ($disposition == 'inline' && isset($cidUniq[$cid])) {
2096 |                     continue;
2097 |                 }
2098 |                 $cidUniq[$cid] = true;
2099 | 
2100 |                 $mime[] = sprintf("--%s%s", $boundary, $this->LE);
2101 |                 $mime[] = sprintf(
2102 |                     "Content-Type: %s; name=\"%s\"%s",
2103 |                     $type,
2104 |                     $this->encodeHeader($this->secureHeader($name)),
2105 |                     $this->LE
2106 |                 );
2107 |                 $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
2108 | 
2109 |                 if ($disposition == 'inline') {
2110 |                     $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
2111 |                 }
2112 | 
2113 |                 // If a filename contains any of these chars, it should be quoted,
2114 |                 // but not otherwise: RFC2183 & RFC2045 5.1
2115 |                 // Fixes a warning in IETF's msglint MIME checker
2116 |                 // Allow for bypassing the Content-Disposition header totally
2117 |                 if (!(empty($disposition))) {
2118 |                     if (preg_match('/[ \(\)<>@,;:\\"\/\[\]\?=]/', $name)) {
2119 |                         $mime[] = sprintf(
2120 |                             "Content-Disposition: %s; filename=\"%s\"%s",
2121 |                             $disposition,
2122 |                             $this->encodeHeader($this->secureHeader($name)),
2123 |                             $this->LE . $this->LE
2124 |                         );
2125 |                     } else {
2126 |                         $mime[] = sprintf(
2127 |                             "Content-Disposition: %s; filename=%s%s",
2128 |                             $disposition,
2129 |                             $this->encodeHeader($this->secureHeader($name)),
2130 |                             $this->LE . $this->LE
2131 |                         );
2132 |                     }
2133 |                 } else {
2134 |                     $mime[] = $this->LE;
2135 |                 }
2136 | 
2137 |                 // Encode as string attachment
2138 |                 if ($bString) {
2139 |                     $mime[] = $this->encodeString($string, $encoding);
2140 |                     if ($this->isError()) {
2141 |                         return '';
2142 |                     }
2143 |                     $mime[] = $this->LE . $this->LE;
2144 |                 } else {
2145 |                     $mime[] = $this->encodeFile($path, $encoding);
2146 |                     if ($this->isError()) {
2147 |                         return '';
2148 |                     }
2149 |                     $mime[] = $this->LE . $this->LE;
2150 |                 }
2151 |             }
2152 |         }
2153 | 
2154 |         $mime[] = sprintf("--%s--%s", $boundary, $this->LE);
2155 | 
2156 |         return implode("", $mime);
2157 |     }
2158 | 
2159 |     /**
2160 |      * Encode a file attachment in requested format.
2161 |      * Returns an empty string on failure.
2162 |      * @param string $path The full path to the file
2163 |      * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
2164 |      * @throws phpmailerException
2165 |      * @see EncodeFile(encodeFile
2166 |      * @access protected
2167 |      * @return string
2168 |      */
2169 |     protected function encodeFile($path, $encoding = 'base64')
2170 |     {
2171 |         try {
2172 |             if (!is_readable($path)) {
2173 |                 throw new phpmailerException($this->lang('file_open') . $path, self::STOP_CONTINUE);
2174 |             }
2175 |             $magic_quotes = get_magic_quotes_runtime();
2176 |             if ($magic_quotes) {
2177 |                 if (version_compare(PHP_VERSION, '5.3.0', '<')) {
2178 |                     set_magic_quotes_runtime(0);
2179 |                 } else {
2180 |                     ini_set('magic_quotes_runtime', 0);
2181 |                 }
2182 |             }
2183 |             $file_buffer = file_get_contents($path);
2184 |             $file_buffer = $this->encodeString($file_buffer, $encoding);
2185 |             if ($magic_quotes) {
2186 |                 if (version_compare(PHP_VERSION, '5.3.0', '<')) {
2187 |                     set_magic_quotes_runtime($magic_quotes);
2188 |                 } else {
2189 |                     ini_set('magic_quotes_runtime', $magic_quotes);
2190 |                 }
2191 |             }
2192 |             return $file_buffer;
2193 |         } catch (Exception $e) {
2194 |             $this->setError($e->getMessage());
2195 |             return '';
2196 |         }
2197 |     }
2198 | 
2199 |     /**
2200 |      * Encode a string in requested format.
2201 |      * Returns an empty string on failure.
2202 |      * @param string $str The text to encode
2203 |      * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
2204 |      * @access public
2205 |      * @return string
2206 |      */
2207 |     public function encodeString($str, $encoding = 'base64')
2208 |     {
2209 |         $encoded = '';
2210 |         switch (strtolower($encoding)) {
2211 |             case 'base64':
2212 |                 $encoded = chunk_split(base64_encode($str), 76, $this->LE);
2213 |                 break;
2214 |             case '7bit':
2215 |             case '8bit':
2216 |                 $encoded = $this->fixEOL($str);
2217 |                 //Make sure it ends with a line break
2218 |                 if (substr($encoded, -(strlen($this->LE))) != $this->LE) {
2219 |                     $encoded .= $this->LE;
2220 |                 }
2221 |                 break;
2222 |             case 'binary':
2223 |                 $encoded = $str;
2224 |                 break;
2225 |             case 'quoted-printable':
2226 |                 $encoded = $this->encodeQP($str);
2227 |                 break;
2228 |             default:
2229 |                 $this->setError($this->lang('encoding') . $encoding);
2230 |                 break;
2231 |         }
2232 |         return $encoded;
2233 |     }
2234 | 
2235 |     /**
2236 |      * Encode a header string optimally.
2237 |      * Picks shortest of Q, B, quoted-printable or none.
2238 |      * @access public
2239 |      * @param string $str
2240 |      * @param string $position
2241 |      * @return string
2242 |      */
2243 |     public function encodeHeader($str, $position = 'text')
2244 |     {
2245 |         $x = 0;
2246 |         switch (strtolower($position)) {
2247 |             case 'phrase':
2248 |                 if (!preg_match('/[\200-\377]/', $str)) {
2249 |                     // Can't use addslashes as we don't know what value has magic_quotes_sybase
2250 |                     $encoded = addcslashes($str, "\0..\37\177\\\"");
2251 |                     if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str)) {
2252 |                         return ($encoded);
2253 |                     } else {
2254 |                         return ("\"$encoded\"");
2255 |                     }
2256 |                 }
2257 |                 $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
2258 |                 break;
2259 |             /** @noinspection PhpMissingBreakStatementInspection */
2260 |             case 'comment':
2261 |                 $x = preg_match_all('/[()"]/', $str, $matches);
2262 |                 // Intentional fall-through
2263 |             case 'text':
2264 |             default:
2265 |                 $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
2266 |                 break;
2267 |         }
2268 | 
2269 |         if ($x == 0) { //There are no chars that need encoding
2270 |             return ($str);
2271 |         }
2272 | 
2273 |         $maxlen = 75 - 7 - strlen($this->CharSet);
2274 |         // Try to select the encoding which should produce the shortest output
2275 |         if ($x > strlen($str) / 3) {
2276 |             //More than a third of the content will need encoding, so B encoding will be most efficient
2277 |             $encoding = 'B';
2278 |             if (function_exists('mb_strlen') && $this->hasMultiBytes($str)) {
2279 |                 // Use a custom function which correctly encodes and wraps long
2280 |                 // multibyte strings without breaking lines within a character
2281 |                 $encoded = $this->base64EncodeWrapMB($str, "\n");
2282 |             } else {
2283 |                 $encoded = base64_encode($str);
2284 |                 $maxlen -= $maxlen % 4;
2285 |                 $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
2286 |             }
2287 |         } else {
2288 |             $encoding = 'Q';
2289 |             $encoded = $this->encodeQ($str, $position);
2290 |             $encoded = $this->wrapText($encoded, $maxlen, true);
2291 |             $encoded = str_replace('=' . self::CRLF, "\n", trim($encoded));
2292 |         }
2293 | 
2294 |         $encoded = preg_replace('/^(.*)$/m', " =?" . $this->CharSet . "?$encoding?\\1?=", $encoded);
2295 |         $encoded = trim(str_replace("\n", $this->LE, $encoded));
2296 | 
2297 |         return $encoded;
2298 |     }
2299 | 
2300 |     /**
2301 |      * Check if a string contains multi-byte characters.
2302 |      * @access public
2303 |      * @param string $str multi-byte text to wrap encode
2304 |      * @return bool
2305 |      */
2306 |     public function hasMultiBytes($str)
2307 |     {
2308 |         if (function_exists('mb_strlen')) {
2309 |             return (strlen($str) > mb_strlen($str, $this->CharSet));
2310 |         } else { // Assume no multibytes (we can't handle without mbstring functions anyway)
2311 |             return false;
2312 |         }
2313 |     }
2314 | 
2315 |     /**
2316 |      * Encode and wrap long multibyte strings for mail headers
2317 |      * without breaking lines within a character.
2318 |      * Adapted from a function by paravoid at http://uk.php.net/manual/en/function.mb-encode-mimeheader.php
2319 |      * @access public
2320 |      * @param string $str multi-byte text to wrap encode
2321 |      * @param string $lf string to use as linefeed/end-of-line
2322 |      * @return string
2323 |      */
2324 |     public function base64EncodeWrapMB($str, $lf = null)
2325 |     {
2326 |         $start = "=?" . $this->CharSet . "?B?";
2327 |         $end = "?=";
2328 |         $encoded = "";
2329 |         if ($lf === null) {
2330 |             $lf = $this->LE;
2331 |         }
2332 | 
2333 |         $mb_length = mb_strlen($str, $this->CharSet);
2334 |         // Each line must have length <= 75, including $start and $end
2335 |         $length = 75 - strlen($start) - strlen($end);
2336 |         // Average multi-byte ratio
2337 |         $ratio = $mb_length / strlen($str);
2338 |         // Base64 has a 4:3 ratio
2339 |         $avgLength = floor($length * $ratio * .75);
2340 | 
2341 |         for ($i = 0; $i < $mb_length; $i += $offset) {
2342 |             $lookBack = 0;
2343 |             do {
2344 |                 $offset = $avgLength - $lookBack;
2345 |                 $chunk = mb_substr($str, $i, $offset, $this->CharSet);
2346 |                 $chunk = base64_encode($chunk);
2347 |                 $lookBack++;
2348 |             } while (strlen($chunk) > $length);
2349 |             $encoded .= $chunk . $lf;
2350 |         }
2351 | 
2352 |         // Chomp the last linefeed
2353 |         $encoded = substr($encoded, 0, -strlen($lf));
2354 |         return $encoded;
2355 |     }
2356 | 
2357 |     /**
2358 |      * Encode a string in quoted-printable format.
2359 |      * According to RFC2045 section 6.7.
2360 |      * @access public
2361 |      * @param string $string The text to encode
2362 |      * @param integer $line_max Number of chars allowed on a line before wrapping
2363 |      * @return string
2364 |      * @link PHP version adapted from http://www.php.net/manual/en/function.quoted-printable-decode.php#89417
2365 |      */
2366 |     public function encodeQP($string, $line_max = 76)
2367 |     {
2368 |         if (function_exists('quoted_printable_encode')) { //Use native function if it's available (>= PHP5.3)
2369 |             return $this->fixEOL(quoted_printable_encode($string));
2370 |         }
2371 |         //Fall back to a pure PHP implementation
2372 |         $string = str_replace(
2373 |             array('%20', '%0D%0A.', '%0D%0A', '%'),
2374 |             array(' ', "\r\n=2E", "\r\n", '='),
2375 |             rawurlencode($string)
2376 |         );
2377 |         $string = preg_replace('/[^\r\n]{' . ($line_max - 3) . '}[^=\r\n]{2}/', "$0=\r\n", $string);
2378 |         return $this->fixEOL($string);
2379 |     }
2380 | 
2381 |     /**
2382 |      * Backward compatibility wrapper for an old QP encoding function that was removed.
2383 |      * @see PHPMailer::encodeQP()
2384 |      * @access public
2385 |      * @param string $string
2386 |      * @param integer $line_max
2387 |      * @param bool $space_conv
2388 |      * @return string
2389 |      * @deprecated Use encodeQP instead.
2390 |      */
2391 |     public function encodeQPphp(
2392 |         $string,
2393 |         $line_max = 76,
2394 |         /** @noinspection PhpUnusedParameterInspection */ $space_conv = false
2395 |     ) {
2396 |         return $this->encodeQP($string, $line_max);
2397 |     }
2398 | 
2399 |     /**
2400 |      * Encode a string using Q encoding.
2401 |      * @link http://tools.ietf.org/html/rfc2047
2402 |      * @param string $str the text to encode
2403 |      * @param string $position Where the text is going to be used, see the RFC for what that means
2404 |      * @access public
2405 |      * @return string
2406 |      */
2407 |     public function encodeQ($str, $position = 'text')
2408 |     {
2409 |         //There should not be any EOL in the string
2410 |         $pattern = '';
2411 |         $encoded = str_replace(array("\r", "\n"), '', $str);
2412 |         switch (strtolower($position)) {
2413 |             case 'phrase':
2414 |                 //RFC 2047 section 5.3
2415 |                 $pattern = '^A-Za-z0-9!*+\/ -';
2416 |                 break;
2417 |             /** @noinspection PhpMissingBreakStatementInspection */
2418 |             case 'comment':
2419 |                 //RFC 2047 section 5.2
2420 |                 $pattern = '\(\)"';
2421 |                 //intentional fall-through
2422 |                 //for this reason we build the $pattern without including delimiters and []
2423 |             case 'text':
2424 |             default:
2425 |                 //RFC 2047 section 5.1
2426 |                 //Replace every high ascii, control, =, ? and _ characters
2427 |                 $pattern = '\000-\011\013\014\016-\037\075\077\137\177-\377' . $pattern;
2428 |                 break;
2429 |         }
2430 |         $matches = array();
2431 |         if (preg_match_all("/[{$pattern}]/", $encoded, $matches)) {
2432 |             //If the string contains an '=', make sure it's the first thing we replace
2433 |             //so as to avoid double-encoding
2434 |             $s = array_search('=', $matches[0]);
2435 |             if ($s !== false) {
2436 |                 unset($matches[0][$s]);
2437 |                 array_unshift($matches[0], '=');
2438 |             }
2439 |             foreach (array_unique($matches[0]) as $char) {
2440 |                 $encoded = str_replace($char, '=' . sprintf('%02X', ord($char)), $encoded);
2441 |             }
2442 |         }
2443 |         //Replace every spaces to _ (more readable than =20)
2444 |         return str_replace(' ', '_', $encoded);
2445 |     }
2446 | 
2447 | 
2448 |     /**
2449 |      * Add a string or binary attachment (non-filesystem).
2450 |      * This method can be used to attach ascii or binary data,
2451 |      * such as a BLOB record from a database.
2452 |      * @param string $string String attachment data.
2453 |      * @param string $filename Name of the attachment.
2454 |      * @param string $encoding File encoding (see $Encoding).
2455 |      * @param string $type File extension (MIME) type.
2456 |      * @param string $disposition Disposition to use
2457 |      * @return void
2458 |      */
2459 |     public function addStringAttachment(
2460 |         $string,
2461 |         $filename,
2462 |         $encoding = 'base64',
2463 |         $type = '',
2464 |         $disposition = 'attachment'
2465 |     ) {
2466 |         //If a MIME type is not specified, try to work it out from the file name
2467 |         if ($type == '') {
2468 |             $type = self::filenameToType($filename);
2469 |         }
2470 |         // Append to $attachment array
2471 |         $this->attachment[] = array(
2472 |             0 => $string,
2473 |             1 => $filename,
2474 |             2 => basename($filename),
2475 |             3 => $encoding,
2476 |             4 => $type,
2477 |             5 => true, // isStringAttachment
2478 |             6 => $disposition,
2479 |             7 => 0
2480 |         );
2481 |     }
2482 | 
2483 |     /**
2484 |      * Add an embedded (inline) attachment from a file.
2485 |      * This can include images, sounds, and just about any other document type.
2486 |      * These differ from 'regular' attachmants in that they are intended to be
2487 |      * displayed inline with the message, not just attached for download.
2488 |      * This is used in HTML messages that embed the images
2489 |      * the HTML refers to using the $cid value.
2490 |      * @param string $path Path to the attachment.
2491 |      * @param string $cid Content ID of the attachment; Use this to reference
2492 |      *        the content when using an embedded image in HTML.
2493 |      * @param string $name Overrides the attachment name.
2494 |      * @param string $encoding File encoding (see $Encoding).
2495 |      * @param string $type File MIME type.
2496 |      * @param string $disposition Disposition to use
2497 |      * @return bool True on successfully adding an attachment
2498 |      */
2499 |     public function addEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = '', $disposition = 'inline')
2500 |     {
2501 |         if (!@is_file($path)) {
2502 |             $this->setError($this->lang('file_access') . $path);
2503 |             return false;
2504 |         }
2505 | 
2506 |         //If a MIME type is not specified, try to work it out from the file name
2507 |         if ($type == '') {
2508 |             $type = self::filenameToType($path);
2509 |         }
2510 | 
2511 |         $filename = basename($path);
2512 |         if ($name == '') {
2513 |             $name = $filename;
2514 |         }
2515 | 
2516 |         // Append to $attachment array
2517 |         $this->attachment[] = array(
2518 |             0 => $path,
2519 |             1 => $filename,
2520 |             2 => $name,
2521 |             3 => $encoding,
2522 |             4 => $type,
2523 |             5 => false, // isStringAttachment
2524 |             6 => $disposition,
2525 |             7 => $cid
2526 |         );
2527 |         return true;
2528 |     }
2529 | 
2530 |     /**
2531 |      * Add an embedded stringified attachment.
2532 |      * This can include images, sounds, and just about any other document type.
2533 |      * Be sure to set the $type to an image type for images:
2534 |      * JPEG images use 'image/jpeg', GIF uses 'image/gif', PNG uses 'image/png'.
2535 |      * @param string $string The attachment binary data.
2536 |      * @param string $cid Content ID of the attachment; Use this to reference
2537 |      *        the content when using an embedded image in HTML.
2538 |      * @param string $name
2539 |      * @param string $encoding File encoding (see $Encoding).
2540 |      * @param string $type MIME type.
2541 |      * @param string $disposition Disposition to use
2542 |      * @return bool True on successfully adding an attachment
2543 |      */
2544 |     public function addStringEmbeddedImage(
2545 |         $string,
2546 |         $cid,
2547 |         $name = '',
2548 |         $encoding = 'base64',
2549 |         $type = '',
2550 |         $disposition = 'inline'
2551 |     ) {
2552 |         //If a MIME type is not specified, try to work it out from the name
2553 |         if ($type == '') {
2554 |             $type = self::filenameToType($name);
2555 |         }
2556 | 
2557 |         // Append to $attachment array
2558 |         $this->attachment[] = array(
2559 |             0 => $string,
2560 |             1 => $name,
2561 |             2 => $name,
2562 |             3 => $encoding,
2563 |             4 => $type,
2564 |             5 => true, // isStringAttachment
2565 |             6 => $disposition,
2566 |             7 => $cid
2567 |         );
2568 |         return true;
2569 |     }
2570 | 
2571 |     /**
2572 |      * Check if an inline attachment is present.
2573 |      * @access public
2574 |      * @return bool
2575 |      */
2576 |     public function inlineImageExists()
2577 |     {
2578 |         foreach ($this->attachment as $attachment) {
2579 |             if ($attachment[6] == 'inline') {
2580 |                 return true;
2581 |             }
2582 |         }
2583 |         return false;
2584 |     }
2585 | 
2586 |     /**
2587 |      * Check if an attachment (non-inline) is present.
2588 |      * @return bool
2589 |      */
2590 |     public function attachmentExists()
2591 |     {
2592 |         foreach ($this->attachment as $attachment) {
2593 |             if ($attachment[6] == 'attachment') {
2594 |                 return true;
2595 |             }
2596 |         }
2597 |         return false;
2598 |     }
2599 | 
2600 |     /**
2601 |      * Check if this message has an alternative body set.
2602 |      * @return bool
2603 |      */
2604 |     public function alternativeExists()
2605 |     {
2606 |         return !empty($this->AltBody);
2607 |     }
2608 | 
2609 |     /**
2610 |      * Clear all To recipients.
2611 |      * @return void
2612 |      */
2613 |     public function clearAddresses()
2614 |     {
2615 |         foreach ($this->to as $to) {
2616 |             unset($this->all_recipients[strtolower($to[0])]);
2617 |         }
2618 |         $this->to = array();
2619 |     }
2620 | 
2621 |     /**
2622 |      * Clear all CC recipients.
2623 |      * @return void
2624 |      */
2625 |     public function clearCCs()
2626 |     {
2627 |         foreach ($this->cc as $cc) {
2628 |             unset($this->all_recipients[strtolower($cc[0])]);
2629 |         }
2630 |         $this->cc = array();
2631 |     }
2632 | 
2633 |     /**
2634 |      * Clear all BCC recipients.
2635 |      * @return void
2636 |      */
2637 |     public function clearBCCs()
2638 |     {
2639 |         foreach ($this->bcc as $bcc) {
2640 |             unset($this->all_recipients[strtolower($bcc[0])]);
2641 |         }
2642 |         $this->bcc = array();
2643 |     }
2644 | 
2645 |     /**
2646 |      * Clear all ReplyTo recipients.
2647 |      * @return void
2648 |      */
2649 |     public function clearReplyTos()
2650 |     {
2651 |         $this->ReplyTo = array();
2652 |     }
2653 | 
2654 |     /**
2655 |      * Clear all recipient types.
2656 |      * @return void
2657 |      */
2658 |     public function clearAllRecipients()
2659 |     {
2660 |         $this->to = array();
2661 |         $this->cc = array();
2662 |         $this->bcc = array();
2663 |         $this->all_recipients = array();
2664 |     }
2665 | 
2666 |     /**
2667 |      * Clear all filesystem, string, and binary attachments.
2668 |      * @return void
2669 |      */
2670 |     public function clearAttachments()
2671 |     {
2672 |         $this->attachment = array();
2673 |     }
2674 | 
2675 |     /**
2676 |      * Clear all custom headers.
2677 |      * @return void
2678 |      */
2679 |     public function clearCustomHeaders()
2680 |     {
2681 |         $this->CustomHeader = array();
2682 |     }
2683 | 
2684 |     /**
2685 |      * Add an error message to the error container.
2686 |      * @access protected
2687 |      * @param string $msg
2688 |      * @return void
2689 |      */
2690 |     protected function setError($msg)
2691 |     {
2692 |         $this->error_count++;
2693 |         if ($this->Mailer == 'smtp' and !is_null($this->smtp)) {
2694 |             $lasterror = $this->smtp->getError();
2695 |             if (!empty($lasterror) and array_key_exists('smtp_msg', $lasterror)) {
2696 |                 $msg .= '<p>' . $this->lang('smtp_error') . $lasterror['smtp_msg'] . "</p>\n";
2697 |             }
2698 |         }
2699 |         $this->ErrorInfo = $msg;
2700 |     }
2701 | 
2702 |     /**
2703 |      * Return an RFC 822 formatted date.
2704 |      * @access public
2705 |      * @return string
2706 |      * @static
2707 |      */
2708 |     public static function rfcDate()
2709 |     {
2710 |         //Set the time zone to whatever the default is to avoid 500 errors
2711 |         //Will default to UTC if it's not set properly in php.ini
2712 |         date_default_timezone_set(@date_default_timezone_get());
2713 |         return date('D, j M Y H:i:s O');
2714 |     }
2715 | 
2716 |     /**
2717 |      * Get the server hostname.
2718 |      * Returns 'localhost.localdomain' if unknown.
2719 |      * @access protected
2720 |      * @return string
2721 |      */
2722 |     protected function serverHostname()
2723 |     {
2724 |         $result = 'localhost.localdomain';
2725 |         if (!empty($this->Hostname)) {
2726 |             $result = $this->Hostname;
2727 |         } elseif (isset($_SERVER) and array_key_exists('SERVER_NAME', $_SERVER) and !empty($_SERVER['SERVER_NAME'])) {
2728 |             $result = $_SERVER['SERVER_NAME'];
2729 |         } elseif (function_exists('gethostname') && gethostname() !== false) {
2730 |             $result = gethostname();
2731 |         } elseif (php_uname('n') !== false) {
2732 |             $result = php_uname('n');
2733 |         }
2734 |         return $result;
2735 |     }
2736 | 
2737 |     /**
2738 |      * Get an error message in the current language.
2739 |      * @access protected
2740 |      * @param string $key
2741 |      * @return string
2742 |      */
2743 |     protected function lang($key)
2744 |     {
2745 |         if (count($this->language) < 1) {
2746 |             $this->setLanguage('en'); // set the default language
2747 |         }
2748 | 
2749 |         if (isset($this->language[$key])) {
2750 |             return $this->language[$key];
2751 |         } else {
2752 |             return 'Language string failed to load: ' . $key;
2753 |         }
2754 |     }
2755 | 
2756 |     /**
2757 |      * Check if an error occurred.
2758 |      * @access public
2759 |      * @return bool True if an error did occur.
2760 |      */
2761 |     public function isError()
2762 |     {
2763 |         return ($this->error_count > 0);
2764 |     }
2765 | 
2766 |     /**
2767 |      * Ensure consistent line endings in a string.
2768 |      * Changes every end of line from CRLF, CR or LF to $this->LE.
2769 |      * @access public
2770 |      * @param string $str String to fixEOL
2771 |      * @return string
2772 |      */
2773 |     public function fixEOL($str)
2774 |     {
2775 |         // Normalise to \n
2776 |         $nstr = str_replace(array("\r\n", "\r"), "\n", $str);
2777 |         // Now convert LE as needed
2778 |         if ($this->LE !== "\n") {
2779 |             $nstr = str_replace("\n", $this->LE, $nstr);
2780 |         }
2781 |         return $nstr;
2782 |     }
2783 | 
2784 |     /**
2785 |      * Add a custom header.
2786 |      * $name value can be overloaded to contain
2787 |      * both header name and value (name:value)
2788 |      * @access public
2789 |      * @param string $name Custom header name
2790 |      * @param string $value Header value
2791 |      * @return void
2792 |      */
2793 |     public function addCustomHeader($name, $value = null)
2794 |     {
2795 |         if ($value === null) {
2796 |             // Value passed in as name:value
2797 |             $this->CustomHeader[] = explode(':', $name, 2);
2798 |         } else {
2799 |             $this->CustomHeader[] = array($name, $value);
2800 |         }
2801 |     }
2802 | 
2803 |     /**
2804 |      * Create a message from an HTML string.
2805 |      * Automatically makes modifications for inline images and backgrounds
2806 |      * and creates a plain-text version by converting the HTML.
2807 |      * Overwrites any existing values in $this->Body and $this->AltBody
2808 |      * @access public
2809 |      * @param string $message HTML message string
2810 |      * @param string $basedir baseline directory for path
2811 |      * @param bool $advanced Whether to use the advanced HTML to text converter
2812 |      * @return string $message
2813 |      */
2814 |     public function msgHTML($message, $basedir = '', $advanced = false)
2815 |     {
2816 |         preg_match_all("/(src|background)=[\"'](.*)[\"']/Ui", $message, $images);
2817 |         if (isset($images[2])) {
2818 |             foreach ($images[2] as $i => $url) {
2819 |                 // do not change urls for absolute images (thanks to corvuscorax)
2820 |                 if (!preg_match('#^[A-z]+://#', $url)) {
2821 |                     $filename = basename($url);
2822 |                     $directory = dirname($url);
2823 |                     if ($directory == '.') {
2824 |                         $directory = '';
2825 |                     }
2826 |                     $cid = md5($url) . '@phpmailer.0'; //RFC2392 S 2
2827 |                     if (strlen($basedir) > 1 && substr($basedir, -1) != '/') {
2828 |                         $basedir .= '/';
2829 |                     }
2830 |                     if (strlen($directory) > 1 && substr($directory, -1) != '/') {
2831 |                         $directory .= '/';
2832 |                     }
2833 |                     if ($this->addEmbeddedImage(
2834 |                         $basedir . $directory . $filename,
2835 |                         $cid,
2836 |                         $filename,
2837 |                         'base64',
2838 |                         self::_mime_types(self::mb_pathinfo($filename, PATHINFO_EXTENSION))
2839 |                     )
2840 |                     ) {
2841 |                         $message = preg_replace(
2842 |                             "/" . $images[1][$i] . "=[\"']" . preg_quote($url, '/') . "[\"']/Ui",
2843 |                             $images[1][$i] . "=\"cid:" . $cid . "\"",
2844 |                             $message
2845 |                         );
2846 |                     }
2847 |                 }
2848 |             }
2849 |         }
2850 |         $this->isHTML(true);
2851 |         //Convert all message body line breaks to CRLF, makes quoted-printable encoding work much better
2852 |         $this->Body = $this->normalizeBreaks($message);
2853 |         $this->AltBody = $this->normalizeBreaks($this->html2text($message, $advanced));
2854 |         if (empty($this->AltBody)) {
2855 |             $this->AltBody = 'To view this email message, open it in a program that understands HTML!' .
2856 |                 self::CRLF . self::CRLF;
2857 |         }
2858 |         return $this->Body;
2859 |     }
2860 | 
2861 |     /**
2862 |      * Convert an HTML string into plain text.
2863 |      * @param string $html The HTML text to convert
2864 |      * @param bool $advanced Should this use the more complex html2text converter or just a simple one?
2865 |      * @return string
2866 |      */
2867 |     public function html2text($html, $advanced = false)
2868 |     {
2869 |         if ($advanced) {
2870 |             require_once 'extras/class.html2text.php';
2871 |             $h = new html2text($html);
2872 |             return $h->get_text();
2873 |         }
2874 |         return html_entity_decode(
2875 |             trim(strip_tags(preg_replace('/<(head|title|style|script)[^>]*>.*?<\/\\1>/si', '', $html))),
2876 |             ENT_QUOTES,
2877 |             $this->CharSet
2878 |         );
2879 |     }
2880 | 
2881 |     /**
2882 |      * Get the MIME type for a file extension.
2883 |      * @param string $ext File extension
2884 |      * @access public
2885 |      * @return string MIME type of file.
2886 |      * @static
2887 |      */
2888 |     public static function _mime_types($ext = '')
2889 |     {
2890 |         $mimes = array(
2891 |             'xl' => 'application/excel',
2892 |             'hqx' => 'application/mac-binhex40',
2893 |             'cpt' => 'application/mac-compactpro',
2894 |             'bin' => 'application/macbinary',
2895 |             'doc' => 'application/msword',
2896 |             'word' => 'application/msword',
2897 |             'class' => 'application/octet-stream',
2898 |             'dll' => 'application/octet-stream',
2899 |             'dms' => 'application/octet-stream',
2900 |             'exe' => 'application/octet-stream',
2901 |             'lha' => 'application/octet-stream',
2902 |             'lzh' => 'application/octet-stream',
2903 |             'psd' => 'application/octet-stream',
2904 |             'sea' => 'application/octet-stream',
2905 |             'so' => 'application/octet-stream',
2906 |             'oda' => 'application/oda',
2907 |             'pdf' => 'application/pdf',
2908 |             'ai' => 'application/postscript',
2909 |             'eps' => 'application/postscript',
2910 |             'ps' => 'application/postscript',
2911 |             'smi' => 'application/smil',
2912 |             'smil' => 'application/smil',
2913 |             'mif' => 'application/vnd.mif',
2914 |             'xls' => 'application/vnd.ms-excel',
2915 |             'ppt' => 'application/vnd.ms-powerpoint',
2916 |             'wbxml' => 'application/vnd.wap.wbxml',
2917 |             'wmlc' => 'application/vnd.wap.wmlc',
2918 |             'dcr' => 'application/x-director',
2919 |             'dir' => 'application/x-director',
2920 |             'dxr' => 'application/x-director',
2921 |             'dvi' => 'application/x-dvi',
2922 |             'gtar' => 'application/x-gtar',
2923 |             'php3' => 'application/x-httpd-php',
2924 |             'php4' => 'application/x-httpd-php',
2925 |             'php' => 'application/x-httpd-php',
2926 |             'phtml' => 'application/x-httpd-php',
2927 |             'phps' => 'application/x-httpd-php-source',
2928 |             'js' => 'application/x-javascript',
2929 |             'swf' => 'application/x-shockwave-flash',
2930 |             'sit' => 'application/x-stuffit',
2931 |             'tar' => 'application/x-tar',
2932 |             'tgz' => 'application/x-tar',
2933 |             'xht' => 'application/xhtml+xml',
2934 |             'xhtml' => 'application/xhtml+xml',
2935 |             'zip' => 'application/zip',
2936 |             'mid' => 'audio/midi',
2937 |             'midi' => 'audio/midi',
2938 |             'mp2' => 'audio/mpeg',
2939 |             'mp3' => 'audio/mpeg',
2940 |             'mpga' => 'audio/mpeg',
2941 |             'aif' => 'audio/x-aiff',
2942 |             'aifc' => 'audio/x-aiff',
2943 |             'aiff' => 'audio/x-aiff',
2944 |             'ram' => 'audio/x-pn-realaudio',
2945 |             'rm' => 'audio/x-pn-realaudio',
2946 |             'rpm' => 'audio/x-pn-realaudio-plugin',
2947 |             'ra' => 'audio/x-realaudio',
2948 |             'wav' => 'audio/x-wav',
2949 |             'bmp' => 'image/bmp',
2950 |             'gif' => 'image/gif',
2951 |             'jpeg' => 'image/jpeg',
2952 |             'jpe' => 'image/jpeg',
2953 |             'jpg' => 'image/jpeg',
2954 |             'png' => 'image/png',
2955 |             'tiff' => 'image/tiff',
2956 |             'tif' => 'image/tiff',
2957 |             'eml' => 'message/rfc822',
2958 |             'css' => 'text/css',
2959 |             'html' => 'text/html',
2960 |             'htm' => 'text/html',
2961 |             'shtml' => 'text/html',
2962 |             'log' => 'text/plain',
2963 |             'text' => 'text/plain',
2964 |             'txt' => 'text/plain',
2965 |             'rtx' => 'text/richtext',
2966 |             'rtf' => 'text/rtf',
2967 |             'xml' => 'text/xml',
2968 |             'xsl' => 'text/xml',
2969 |             'mpeg' => 'video/mpeg',
2970 |             'mpe' => 'video/mpeg',
2971 |             'mpg' => 'video/mpeg',
2972 |             'mov' => 'video/quicktime',
2973 |             'qt' => 'video/quicktime',
2974 |             'rv' => 'video/vnd.rn-realvideo',
2975 |             'avi' => 'video/x-msvideo',
2976 |             'movie' => 'video/x-sgi-movie'
2977 |         );
2978 |         return (array_key_exists(strtolower($ext), $mimes) ? $mimes[strtolower($ext)]: 'application/octet-stream');
2979 |     }
2980 | 
2981 |     /**
2982 |      * Map a file name to a MIME type.
2983 |      * Defaults to 'application/octet-stream', i.e.. arbitrary binary data.
2984 |      * @param string $filename A file name or full path, does not need to exist as a file
2985 |      * @return string
2986 |      * @static
2987 |      */
2988 |     public static function filenameToType($filename)
2989 |     {
2990 |         //In case the path is a URL, strip any query string before getting extension
2991 |         $qpos = strpos($filename, '?');
2992 |         if ($qpos !== false) {
2993 |             $filename = substr($filename, 0, $qpos);
2994 |         }
2995 |         $pathinfo = self::mb_pathinfo($filename);
2996 |         return self::_mime_types($pathinfo['extension']);
2997 |     }
2998 | 
2999 |     /**
3000 |      * Multi-byte-safe pathinfo replacement.
3001 |      * Drop-in replacement for pathinfo(), but multibyte-safe, cross-platform-safe, old-version-safe.
3002 |      * Works similarly to the one in PHP >= 5.2.0
3003 |      * @link http://www.php.net/manual/en/function.pathinfo.php#107461
3004 |      * @param string $path A filename or path, does not need to exist as a file
3005 |      * @param integer|string $options Either a PATHINFO_* constant,
3006 |      *      or a string name to return only the specified piece, allows 'filename' to work on PHP < 5.2
3007 |      * @return string|array
3008 |      * @static
3009 |      */
3010 |     public static function mb_pathinfo($path, $options = null)
3011 |     {
3012 |         $ret = array('dirname' => '', 'basename' => '', 'extension' => '', 'filename' => '');
3013 |         $m = array();
3014 |         preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^\.\\\\/]+?)|))[\\\\/\.]*$%im', $path, $m);
3015 |         if (array_key_exists(1, $m)) {
3016 |             $ret['dirname'] = $m[1];
3017 |         }
3018 |         if (array_key_exists(2, $m)) {
3019 |             $ret['basename'] = $m[2];
3020 |         }
3021 |         if (array_key_exists(5, $m)) {
3022 |             $ret['extension'] = $m[5];
3023 |         }
3024 |         if (array_key_exists(3, $m)) {
3025 |             $ret['filename'] = $m[3];
3026 |         }
3027 |         switch ($options) {
3028 |             case PATHINFO_DIRNAME:
3029 |             case 'dirname':
3030 |                 return $ret['dirname'];
3031 |                 break;
3032 |             case PATHINFO_BASENAME:
3033 |             case 'basename':
3034 |                 return $ret['basename'];
3035 |                 break;
3036 |             case PATHINFO_EXTENSION:
3037 |             case 'extension':
3038 |                 return $ret['extension'];
3039 |                 break;
3040 |             case PATHINFO_FILENAME:
3041 |             case 'filename':
3042 |                 return $ret['filename'];
3043 |                 break;
3044 |             default:
3045 |                 return $ret;
3046 |         }
3047 |     }
3048 | 
3049 |     /**
3050 |      * Set or reset instance properties.
3051 |      *
3052 |      * Usage Example:
3053 |      * $page->set('X-Priority', '3');
3054 |      *
3055 |      * @access public
3056 |      * @param string $name
3057 |      * @param mixed $value
3058 |      * NOTE: will not work with arrays, there are no arrays to set/reset
3059 |      * @throws phpmailerException
3060 |      * @return bool
3061 |      * @todo Should this not be using __set() magic function?
3062 |      */
3063 |     public function set($name, $value = '')
3064 |     {
3065 |         try {
3066 |             if (isset($this->$name)) {
3067 |                 $this->$name = $value;
3068 |             } else {
3069 |                 throw new phpmailerException($this->lang('variable_set') . $name, self::STOP_CRITICAL);
3070 |             }
3071 |         } catch (Exception $e) {
3072 |             $this->setError($e->getMessage());
3073 |             if ($e->getCode() == self::STOP_CRITICAL) {
3074 |                 return false;
3075 |             }
3076 |         }
3077 |         return true;
3078 |     }
3079 | 
3080 |     /**
3081 |      * Strip newlines to prevent header injection.
3082 |      * @access public
3083 |      * @param string $str
3084 |      * @return string
3085 |      */
3086 |     public function secureHeader($str)
3087 |     {
3088 |         return trim(str_replace(array("\r", "\n"), '', $str));
3089 |     }
3090 | 
3091 |     /**
3092 |      * Normalize line breaks in a string.
3093 |      * Converts UNIX LF, Mac CR and Windows CRLF line breaks into a single line break format.
3094 |      * Defaults to CRLF (for message bodies) and preserves consecutive breaks.
3095 |      * @param string $text
3096 |      * @param string $breaktype What kind of line break to use, defaults to CRLF
3097 |      * @return string
3098 |      * @access public
3099 |      * @static
3100 |      */
3101 |     public static function normalizeBreaks($text, $breaktype = "\r\n")
3102 |     {
3103 |         return preg_replace('/(\r\n|\r|\n)/ms', $breaktype, $text);
3104 |     }
3105 | 
3106 | 
3107 |     /**
3108 |      * Set the public and private key files and password for S/MIME signing.
3109 |      * @access public
3110 |      * @param string $cert_filename
3111 |      * @param string $key_filename
3112 |      * @param string $key_pass Password for private key
3113 |      */
3114 |     public function sign($cert_filename, $key_filename, $key_pass)
3115 |     {
3116 |         $this->sign_cert_file = $cert_filename;
3117 |         $this->sign_key_file = $key_filename;
3118 |         $this->sign_key_pass = $key_pass;
3119 |     }
3120 | 
3121 |     /**
3122 |      * Quoted-Printable-encode a DKIM header.
3123 |      * @access public
3124 |      * @param string $txt
3125 |      * @return string
3126 |      */
3127 |     public function DKIM_QP($txt)
3128 |     {
3129 |         $line = '';
3130 |         for ($i = 0; $i < strlen($txt); $i++) {
3131 |             $ord = ord($txt[$i]);
3132 |             if (((0x21 <= $ord) && ($ord <= 0x3A)) || $ord == 0x3C || ((0x3E <= $ord) && ($ord <= 0x7E))) {
3133 |                 $line .= $txt[$i];
3134 |             } else {
3135 |                 $line .= "=" . sprintf("%02X", $ord);
3136 |             }
3137 |         }
3138 |         return $line;
3139 |     }
3140 | 
3141 |     /**
3142 |      * Generate a DKIM signature.
3143 |      * @access public
3144 |      * @param string $s Header
3145 |      * @throws phpmailerException
3146 |      * @return string
3147 |      */
3148 |     public function DKIM_Sign($s)
3149 |     {
3150 |         if (!defined('PKCS7_TEXT')) {
3151 |             if ($this->exceptions) {
3152 |                 throw new phpmailerException($this->lang("signing") . ' OpenSSL extension missing.');
3153 |             }
3154 |             return '';
3155 |         }
3156 |         $privKeyStr = file_get_contents($this->DKIM_private);
3157 |         if ($this->DKIM_passphrase != '') {
3158 |             $privKey = openssl_pkey_get_private($privKeyStr, $this->DKIM_passphrase);
3159 |         } else {
3160 |             $privKey = $privKeyStr;
3161 |         }
3162 |         if (openssl_sign($s, $signature, $privKey)) {
3163 |             return base64_encode($signature);
3164 |         }
3165 |         return '';
3166 |     }
3167 | 
3168 |     /**
3169 |      * Generate a DKIM canonicalization header.
3170 |      * @access public
3171 |      * @param string $s Header
3172 |      * @return string
3173 |      */
3174 |     public function DKIM_HeaderC($s)
3175 |     {
3176 |         $s = preg_replace("/\r\n\s+/", " ", $s);
3177 |         $lines = explode("\r\n", $s);
3178 |         foreach ($lines as $key => $line) {
3179 |             list($heading, $value) = explode(":", $line, 2);
3180 |             $heading = strtolower($heading);
3181 |             $value = preg_replace("/\s+/", " ", $value); // Compress useless spaces
3182 |             $lines[$key] = $heading . ":" . trim($value); // Don't forget to remove WSP around the value
3183 |         }
3184 |         $s = implode("\r\n", $lines);
3185 |         return $s;
3186 |     }
3187 | 
3188 |     /**
3189 |      * Generate a DKIM canonicalization body.
3190 |      * @access public
3191 |      * @param string $body Message Body
3192 |      * @return string
3193 |      */
3194 |     public function DKIM_BodyC($body)
3195 |     {
3196 |         if ($body == '') {
3197 |             return "\r\n";
3198 |         }
3199 |         // stabilize line endings
3200 |         $body = str_replace("\r\n", "\n", $body);
3201 |         $body = str_replace("\n", "\r\n", $body);
3202 |         // END stabilize line endings
3203 |         while (substr($body, strlen($body) - 4, 4) == "\r\n\r\n") {
3204 |             $body = substr($body, 0, strlen($body) - 2);
3205 |         }
3206 |         return $body;
3207 |     }
3208 | 
3209 |     /**
3210 |      * Create the DKIM header and body in a new message header.
3211 |      * @access public
3212 |      * @param string $headers_line Header lines
3213 |      * @param string $subject Subject
3214 |      * @param string $body Body
3215 |      * @return string
3216 |      */
3217 |     public function DKIM_Add($headers_line, $subject, $body)
3218 |     {
3219 |         $DKIMsignatureType = 'rsa-sha1'; // Signature & hash algorithms
3220 |         $DKIMcanonicalization = 'relaxed/simple'; // Canonicalization of header/body
3221 |         $DKIMquery = 'dns/txt'; // Query method
3222 |         $DKIMtime = time(); // Signature Timestamp = seconds since 00:00:00 - Jan 1, 1970 (UTC time zone)
3223 |         $subject_header = "Subject: $subject";
3224 |         $headers = explode($this->LE, $headers_line);
3225 |         $from_header = '';
3226 |         $to_header = '';
3227 |         $current = '';
3228 |         foreach ($headers as $header) {
3229 |             if (strpos($header, 'From:') === 0) {
3230 |                 $from_header = $header;
3231 |                 $current = 'from_header';
3232 |             } elseif (strpos($header, 'To:') === 0) {
3233 |                 $to_header = $header;
3234 |                 $current = 'to_header';
3235 |             } else {
3236 |                 if ($current && strpos($header, ' =?') === 0) {
3237 |                     $current .= $header;
3238 |                 } else {
3239 |                     $current = '';
3240 |                 }
3241 |             }
3242 |         }
3243 |         $from = str_replace('|', '=7C', $this->DKIM_QP($from_header));
3244 |         $to = str_replace('|', '=7C', $this->DKIM_QP($to_header));
3245 |         $subject = str_replace(
3246 |             '|',
3247 |             '=7C',
3248 |             $this->DKIM_QP($subject_header)
3249 |         ); // Copied header fields (dkim-quoted-printable)
3250 |         $body = $this->DKIM_BodyC($body);
3251 |         $DKIMlen = strlen($body); // Length of body
3252 |         $DKIMb64 = base64_encode(pack("H*", sha1($body))); // Base64 of packed binary SHA-1 hash of body
3253 |         $ident = ($this->DKIM_identity == '') ? '' : " i=" . $this->DKIM_identity . ";";
3254 |         $dkimhdrs = "DKIM-Signature: v=1; a=" .
3255 |             $DKIMsignatureType . "; q=" .
3256 |             $DKIMquery . "; l=" .
3257 |             $DKIMlen . "; s=" .
3258 |             $this->DKIM_selector .
3259 |             ";\r\n" .
3260 |             "\tt=" . $DKIMtime . "; c=" . $DKIMcanonicalization . ";\r\n" .
3261 |             "\th=From:To:Subject;\r\n" .
3262 |             "\td=" . $this->DKIM_domain . ";" . $ident . "\r\n" .
3263 |             "\tz=$from\r\n" .
3264 |             "\t|$to\r\n" .
3265 |             "\t|$subject;\r\n" .
3266 |             "\tbh=" . $DKIMb64 . ";\r\n" .
3267 |             "\tb=";
3268 |         $toSign = $this->DKIM_HeaderC(
3269 |             $from_header . "\r\n" . $to_header . "\r\n" . $subject_header . "\r\n" . $dkimhdrs
3270 |         );
3271 |         $signed = $this->DKIM_Sign($toSign);
3272 |         return $dkimhdrs . $signed . "\r\n";
3273 |     }
3274 | 
3275 |     /**
3276 |      * Allows for public read access to 'to' property.
3277 |      * @access public
3278 |      * @return array
3279 |      */
3280 |     public function getToAddresses()
3281 |     {
3282 |         return $this->to;
3283 |     }
3284 | 
3285 |     /**
3286 |      * Allows for public read access to 'cc' property.
3287 |      * @access public
3288 |      * @return array
3289 |      */
3290 |     public function getCcAddresses()
3291 |     {
3292 |         return $this->cc;
3293 |     }
3294 | 
3295 |     /**
3296 |      * Allows for public read access to 'bcc' property.
3297 |      * @access public
3298 |      * @return array
3299 |      */
3300 |     public function getBccAddresses()
3301 |     {
3302 |         return $this->bcc;
3303 |     }
3304 | 
3305 |     /**
3306 |      * Allows for public read access to 'ReplyTo' property.
3307 |      * @access public
3308 |      * @return array
3309 |      */
3310 |     public function getReplyToAddresses()
3311 |     {
3312 |         return $this->ReplyTo;
3313 |     }
3314 | 
3315 |     /**
3316 |      * Allows for public read access to 'all_recipients' property.
3317 |      * @access public
3318 |      * @return array
3319 |      */
3320 |     public function getAllRecipientAddresses()
3321 |     {
3322 |         return $this->all_recipients;
3323 |     }
3324 | 
3325 |     /**
3326 |      * Perform a callback.
3327 |      * @param bool $isSent
3328 |      * @param string $to
3329 |      * @param string $cc
3330 |      * @param string $bcc
3331 |      * @param string $subject
3332 |      * @param string $body
3333 |      * @param string $from
3334 |      */
3335 |     protected function doCallback($isSent, $to, $cc, $bcc, $subject, $body, $from = null)
3336 |     {
3337 |         if (!empty($this->action_function) && is_callable($this->action_function)) {
3338 |             $params = array($isSent, $to, $cc, $bcc, $subject, $body, $from);
3339 |             call_user_func_array($this->action_function, $params);
3340 |         }
3341 |     }
3342 | }
3343 | 
3344 | /**
3345 |  * PHPMailer exception handler
3346 |  * @package PHPMailer
3347 |  */
3348 | class phpmailerException extends Exception
3349 | {
3350 |     /**
3351 |      * Prettify error message output
3352 |      * @return string
3353 |      */
3354 |     public function errorMessage()
3355 |     {
3356 |         $errorMsg = '<strong>' . $this->getMessage() . "</strong><br />\n";
3357 |         return $errorMsg;
3358 |     }
3359 | }
3360 | 


--------------------------------------------------------------------------------