/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/system/libraries/Email.php

  • Committer: galaxyAbstractor
  • Date: 2013-04-04 16:19:07 UTC
  • mto: (12.2.4 lenasys) (19.1.4 lenasys)
  • mto: This revision was merged to the branch mainline in revision 17.
  • Revision ID: galaxyabstractor@gmail.com-20130404161907-eo1wnb7ac2rnizg8
Started implementation of a new codeviewer using Ace

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
2
 
/**
3
 
 * CodeIgniter
4
 
 *
5
 
 * An open source application development framework for PHP 5.1.6 or newer
6
 
 *
7
 
 * @package             CodeIgniter
8
 
 * @author              ExpressionEngine Dev Team
9
 
 * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
10
 
 * @license             http://codeigniter.com/user_guide/license.html
11
 
 * @link                http://codeigniter.com
12
 
 * @since               Version 1.0
13
 
 * @filesource
14
 
 */
15
 
 
16
 
// ------------------------------------------------------------------------
17
 
 
18
 
/**
19
 
 * CodeIgniter Email Class
20
 
 *
21
 
 * Permits email to be sent using Mail, Sendmail, or SMTP.
22
 
 *
23
 
 * @package             CodeIgniter
24
 
 * @subpackage  Libraries
25
 
 * @category    Libraries
26
 
 * @author              ExpressionEngine Dev Team
27
 
 * @link                http://codeigniter.com/user_guide/libraries/email.html
28
 
 */
29
 
class CI_Email {
30
 
 
31
 
        var     $useragent              = "CodeIgniter";
32
 
        var     $mailpath               = "/usr/sbin/sendmail"; // Sendmail path
33
 
        var     $protocol               = "mail";       // mail/sendmail/smtp
34
 
        var     $smtp_host              = "";           // SMTP Server.  Example: mail.earthlink.net
35
 
        var     $smtp_user              = "";           // SMTP Username
36
 
        var     $smtp_pass              = "";           // SMTP Password
37
 
        var     $smtp_port              = "25";         // SMTP Port
38
 
        var     $smtp_timeout   = 5;            // SMTP Timeout in seconds
39
 
        var     $smtp_crypto    = "";           // SMTP Encryption. Can be null, tls or ssl.
40
 
        var     $wordwrap               = TRUE;         // TRUE/FALSE  Turns word-wrap on/off
41
 
        var     $wrapchars              = "76";         // Number of characters to wrap at.
42
 
        var     $mailtype               = "text";       // text/html  Defines email formatting
43
 
        var     $charset                = "utf-8";      // Default char set: iso-8859-1 or us-ascii
44
 
        var     $multipart              = "mixed";      // "mixed" (in the body) or "related" (separate)
45
 
        var $alt_message        = '';           // Alternative message for HTML emails
46
 
        var     $validate               = FALSE;        // TRUE/FALSE.  Enables email validation
47
 
        var     $priority               = "3";          // Default priority (1 - 5)
48
 
        var     $newline                = "\n";         // Default newline. "\r\n" or "\n" (Use "\r\n" to comply with RFC 822)
49
 
        var $crlf                       = "\n";         // The RFC 2045 compliant CRLF for quoted-printable is "\r\n".  Apparently some servers,
50
 
                                                                        // even on the receiving end think they need to muck with CRLFs, so using "\n", while
51
 
                                                                        // distasteful, is the only thing that seems to work for all environments.
52
 
        var $send_multipart     = TRUE;         // TRUE/FALSE - Yahoo does not like multipart alternative, so this is an override.  Set to FALSE for Yahoo.
53
 
        var     $bcc_batch_mode = FALSE;        // TRUE/FALSE  Turns on/off Bcc batch feature
54
 
        var     $bcc_batch_size = 200;          // If bcc_batch_mode = TRUE, sets max number of Bccs in each batch
55
 
        var $_safe_mode         = FALSE;
56
 
        var     $_subject               = "";
57
 
        var     $_body                  = "";
58
 
        var     $_finalbody             = "";
59
 
        var     $_alt_boundary  = "";
60
 
        var     $_atc_boundary  = "";
61
 
        var     $_header_str    = "";
62
 
        var     $_smtp_connect  = "";
63
 
        var     $_encoding              = "8bit";
64
 
        var $_IP                        = FALSE;
65
 
        var     $_smtp_auth             = FALSE;
66
 
        var $_replyto_flag      = FALSE;
67
 
        var     $_debug_msg             = array();
68
 
        var     $_recipients    = array();
69
 
        var     $_cc_array              = array();
70
 
        var     $_bcc_array             = array();
71
 
        var     $_headers               = array();
72
 
        var     $_attach_name   = array();
73
 
        var     $_attach_type   = array();
74
 
        var     $_attach_disp   = array();
75
 
        var     $_protocols             = array('mail', 'sendmail', 'smtp');
76
 
        var     $_base_charsets = array('us-ascii', 'iso-2022-');       // 7-bit charsets (excluding language suffix)
77
 
        var     $_bit_depths    = array('7bit', '8bit');
78
 
        var     $_priorities    = array('1 (Highest)', '2 (High)', '3 (Normal)', '4 (Low)', '5 (Lowest)');
79
 
 
80
 
 
81
 
        /**
82
 
         * Constructor - Sets Email Preferences
83
 
         *
84
 
         * The constructor can be passed an array of config values
85
 
         */
86
 
        public function __construct($config = array())
87
 
        {
88
 
                if (count($config) > 0)
89
 
                {
90
 
                        $this->initialize($config);
91
 
                }
92
 
                else
93
 
                {
94
 
                        $this->_smtp_auth = ($this->smtp_user == '' AND $this->smtp_pass == '') ? FALSE : TRUE;
95
 
                        $this->_safe_mode = ((boolean)@ini_get("safe_mode") === FALSE) ? FALSE : TRUE;
96
 
                }
97
 
 
98
 
                log_message('debug', "Email Class Initialized");
99
 
        }
100
 
 
101
 
        // --------------------------------------------------------------------
102
 
 
103
 
        /**
104
 
         * Initialize preferences
105
 
         *
106
 
         * @access      public
107
 
         * @param       array
108
 
         * @return      void
109
 
         */
110
 
        public function initialize($config = array())
111
 
        {
112
 
                foreach ($config as $key => $val)
113
 
                {
114
 
                        if (isset($this->$key))
115
 
                        {
116
 
                                $method = 'set_'.$key;
117
 
 
118
 
                                if (method_exists($this, $method))
119
 
                                {
120
 
                                        $this->$method($val);
121
 
                                }
122
 
                                else
123
 
                                {
124
 
                                        $this->$key = $val;
125
 
                                }
126
 
                        }
127
 
                }
128
 
                $this->clear();
129
 
 
130
 
                $this->_smtp_auth = ($this->smtp_user == '' AND $this->smtp_pass == '') ? FALSE : TRUE;
131
 
                $this->_safe_mode = ((boolean)@ini_get("safe_mode") === FALSE) ? FALSE : TRUE;
132
 
 
133
 
                return $this;
134
 
        }
135
 
 
136
 
        // --------------------------------------------------------------------
137
 
 
138
 
        /**
139
 
         * Initialize the Email Data
140
 
         *
141
 
         * @access      public
142
 
         * @return      void
143
 
         */
144
 
        public function clear($clear_attachments = FALSE)
145
 
        {
146
 
                $this->_subject         = "";
147
 
                $this->_body            = "";
148
 
                $this->_finalbody       = "";
149
 
                $this->_header_str      = "";
150
 
                $this->_replyto_flag = FALSE;
151
 
                $this->_recipients      = array();
152
 
                $this->_cc_array        = array();
153
 
                $this->_bcc_array       = array();
154
 
                $this->_headers         = array();
155
 
                $this->_debug_msg       = array();
156
 
 
157
 
                $this->_set_header('User-Agent', $this->useragent);
158
 
                $this->_set_header('Date', $this->_set_date());
159
 
 
160
 
                if ($clear_attachments !== FALSE)
161
 
                {
162
 
                        $this->_attach_name = array();
163
 
                        $this->_attach_type = array();
164
 
                        $this->_attach_disp = array();
165
 
                }
166
 
 
167
 
                return $this;
168
 
        }
169
 
 
170
 
        // --------------------------------------------------------------------
171
 
 
172
 
        /**
173
 
         * Set FROM
174
 
         *
175
 
         * @access      public
176
 
         * @param       string
177
 
         * @param       string
178
 
         * @return      void
179
 
         */
180
 
        public function from($from, $name = '')
181
 
        {
182
 
                if (preg_match( '/\<(.*)\>/', $from, $match))
183
 
                {
184
 
                        $from = $match['1'];
185
 
                }
186
 
 
187
 
                if ($this->validate)
188
 
                {
189
 
                        $this->validate_email($this->_str_to_array($from));
190
 
                }
191
 
 
192
 
                // prepare the display name
193
 
                if ($name != '')
194
 
                {
195
 
                        // only use Q encoding if there are characters that would require it
196
 
                        if ( ! preg_match('/[\200-\377]/', $name))
197
 
                        {
198
 
                                // add slashes for non-printing characters, slashes, and double quotes, and surround it in double quotes
199
 
                                $name = '"'.addcslashes($name, "\0..\37\177'\"\\").'"';
200
 
                        }
201
 
                        else
202
 
                        {
203
 
                                $name = $this->_prep_q_encoding($name, TRUE);
204
 
                        }
205
 
                }
206
 
 
207
 
                $this->_set_header('From', $name.' <'.$from.'>');
208
 
                $this->_set_header('Return-Path', '<'.$from.'>');
209
 
 
210
 
                return $this;
211
 
        }
212
 
 
213
 
        // --------------------------------------------------------------------
214
 
 
215
 
        /**
216
 
         * Set Reply-to
217
 
         *
218
 
         * @access      public
219
 
         * @param       string
220
 
         * @param       string
221
 
         * @return      void
222
 
         */
223
 
        public function reply_to($replyto, $name = '')
224
 
        {
225
 
                if (preg_match( '/\<(.*)\>/', $replyto, $match))
226
 
                {
227
 
                        $replyto = $match['1'];
228
 
                }
229
 
 
230
 
                if ($this->validate)
231
 
                {
232
 
                        $this->validate_email($this->_str_to_array($replyto));
233
 
                }
234
 
 
235
 
                if ($name == '')
236
 
                {
237
 
                        $name = $replyto;
238
 
                }
239
 
 
240
 
                if (strncmp($name, '"', 1) != 0)
241
 
                {
242
 
                        $name = '"'.$name.'"';
243
 
                }
244
 
 
245
 
                $this->_set_header('Reply-To', $name.' <'.$replyto.'>');
246
 
                $this->_replyto_flag = TRUE;
247
 
 
248
 
                return $this;
249
 
        }
250
 
 
251
 
        // --------------------------------------------------------------------
252
 
 
253
 
        /**
254
 
         * Set Recipients
255
 
         *
256
 
         * @access      public
257
 
         * @param       string
258
 
         * @return      void
259
 
         */
260
 
        public function to($to)
261
 
        {
262
 
                $to = $this->_str_to_array($to);
263
 
                $to = $this->clean_email($to);
264
 
 
265
 
                if ($this->validate)
266
 
                {
267
 
                        $this->validate_email($to);
268
 
                }
269
 
 
270
 
                if ($this->_get_protocol() != 'mail')
271
 
                {
272
 
                        $this->_set_header('To', implode(", ", $to));
273
 
                }
274
 
 
275
 
                switch ($this->_get_protocol())
276
 
                {
277
 
                        case 'smtp'             :
278
 
                                $this->_recipients = $to;
279
 
                        break;
280
 
                        case 'sendmail' :
281
 
                        case 'mail'             :
282
 
                                $this->_recipients = implode(", ", $to);
283
 
                        break;
284
 
                }
285
 
 
286
 
                return $this;
287
 
        }
288
 
 
289
 
        // --------------------------------------------------------------------
290
 
 
291
 
        /**
292
 
         * Set CC
293
 
         *
294
 
         * @access      public
295
 
         * @param       string
296
 
         * @return      void
297
 
         */
298
 
        public function cc($cc)
299
 
        {
300
 
                $cc = $this->_str_to_array($cc);
301
 
                $cc = $this->clean_email($cc);
302
 
 
303
 
                if ($this->validate)
304
 
                {
305
 
                        $this->validate_email($cc);
306
 
                }
307
 
 
308
 
                $this->_set_header('Cc', implode(", ", $cc));
309
 
 
310
 
                if ($this->_get_protocol() == "smtp")
311
 
                {
312
 
                        $this->_cc_array = $cc;
313
 
                }
314
 
 
315
 
                return $this;
316
 
        }
317
 
 
318
 
        // --------------------------------------------------------------------
319
 
 
320
 
        /**
321
 
         * Set BCC
322
 
         *
323
 
         * @access      public
324
 
         * @param       string
325
 
         * @param       string
326
 
         * @return      void
327
 
         */
328
 
        public function bcc($bcc, $limit = '')
329
 
        {
330
 
                if ($limit != '' && is_numeric($limit))
331
 
                {
332
 
                        $this->bcc_batch_mode = TRUE;
333
 
                        $this->bcc_batch_size = $limit;
334
 
                }
335
 
 
336
 
                $bcc = $this->_str_to_array($bcc);
337
 
                $bcc = $this->clean_email($bcc);
338
 
 
339
 
                if ($this->validate)
340
 
                {
341
 
                        $this->validate_email($bcc);
342
 
                }
343
 
 
344
 
                if (($this->_get_protocol() == "smtp") OR ($this->bcc_batch_mode && count($bcc) > $this->bcc_batch_size))
345
 
                {
346
 
                        $this->_bcc_array = $bcc;
347
 
                }
348
 
                else
349
 
                {
350
 
                        $this->_set_header('Bcc', implode(", ", $bcc));
351
 
                }
352
 
 
353
 
                return $this;
354
 
        }
355
 
 
356
 
        // --------------------------------------------------------------------
357
 
 
358
 
        /**
359
 
         * Set Email Subject
360
 
         *
361
 
         * @access      public
362
 
         * @param       string
363
 
         * @return      void
364
 
         */
365
 
        public function subject($subject)
366
 
        {
367
 
                $subject = $this->_prep_q_encoding($subject);
368
 
                $this->_set_header('Subject', $subject);
369
 
                return $this;
370
 
        }
371
 
 
372
 
        // --------------------------------------------------------------------
373
 
 
374
 
        /**
375
 
         * Set Body
376
 
         *
377
 
         * @access      public
378
 
         * @param       string
379
 
         * @return      void
380
 
         */
381
 
        public function message($body)
382
 
        {
383
 
                $this->_body = rtrim(str_replace("\r", "", $body));
384
 
 
385
 
                /* strip slashes only if magic quotes is ON
386
 
                   if we do it with magic quotes OFF, it strips real, user-inputted chars.
387
 
 
388
 
                   NOTE: In PHP 5.4 get_magic_quotes_gpc() will always return 0 and
389
 
                         it will probably not exist in future versions at all.
390
 
                */
391
 
                if ( ! is_php('5.4') && get_magic_quotes_gpc())
392
 
                {
393
 
                        $this->_body = stripslashes($this->_body);
394
 
                }
395
 
 
396
 
                return $this;
397
 
        }
398
 
 
399
 
        // --------------------------------------------------------------------
400
 
 
401
 
        /**
402
 
         * Assign file attachments
403
 
         *
404
 
         * @access      public
405
 
         * @param       string
406
 
         * @return      void
407
 
         */
408
 
        public function attach($filename, $disposition = 'attachment')
409
 
        {
410
 
                $this->_attach_name[] = $filename;
411
 
                $this->_attach_type[] = $this->_mime_types(pathinfo($filename, PATHINFO_EXTENSION));
412
 
                $this->_attach_disp[] = $disposition; // Can also be 'inline'  Not sure if it matters
413
 
                return $this;
414
 
        }
415
 
 
416
 
        // --------------------------------------------------------------------
417
 
 
418
 
        /**
419
 
         * Add a Header Item
420
 
         *
421
 
         * @access      protected
422
 
         * @param       string
423
 
         * @param       string
424
 
         * @return      void
425
 
         */
426
 
        protected function _set_header($header, $value)
427
 
        {
428
 
                $this->_headers[$header] = $value;
429
 
        }
430
 
 
431
 
        // --------------------------------------------------------------------
432
 
 
433
 
        /**
434
 
         * Convert a String to an Array
435
 
         *
436
 
         * @access      protected
437
 
         * @param       string
438
 
         * @return      array
439
 
         */
440
 
        protected function _str_to_array($email)
441
 
        {
442
 
                if ( ! is_array($email))
443
 
                {
444
 
                        if (strpos($email, ',') !== FALSE)
445
 
                        {
446
 
                                $email = preg_split('/[\s,]/', $email, -1, PREG_SPLIT_NO_EMPTY);
447
 
                        }
448
 
                        else
449
 
                        {
450
 
                                $email = trim($email);
451
 
                                settype($email, "array");
452
 
                        }
453
 
                }
454
 
                return $email;
455
 
        }
456
 
 
457
 
        // --------------------------------------------------------------------
458
 
 
459
 
        /**
460
 
         * Set Multipart Value
461
 
         *
462
 
         * @access      public
463
 
         * @param       string
464
 
         * @return      void
465
 
         */
466
 
        public function set_alt_message($str = '')
467
 
        {
468
 
                $this->alt_message = $str;
469
 
                return $this;
470
 
        }
471
 
 
472
 
        // --------------------------------------------------------------------
473
 
 
474
 
        /**
475
 
         * Set Mailtype
476
 
         *
477
 
         * @access      public
478
 
         * @param       string
479
 
         * @return      void
480
 
         */
481
 
        public function set_mailtype($type = 'text')
482
 
        {
483
 
                $this->mailtype = ($type == 'html') ? 'html' : 'text';
484
 
                return $this;
485
 
        }
486
 
 
487
 
        // --------------------------------------------------------------------
488
 
 
489
 
        /**
490
 
         * Set Wordwrap
491
 
         *
492
 
         * @access      public
493
 
         * @param       string
494
 
         * @return      void
495
 
         */
496
 
        public function set_wordwrap($wordwrap = TRUE)
497
 
        {
498
 
                $this->wordwrap = ($wordwrap === FALSE) ? FALSE : TRUE;
499
 
                return $this;
500
 
        }
501
 
 
502
 
        // --------------------------------------------------------------------
503
 
 
504
 
        /**
505
 
         * Set Protocol
506
 
         *
507
 
         * @access      public
508
 
         * @param       string
509
 
         * @return      void
510
 
         */
511
 
        public function set_protocol($protocol = 'mail')
512
 
        {
513
 
                $this->protocol = ( ! in_array($protocol, $this->_protocols, TRUE)) ? 'mail' : strtolower($protocol);
514
 
                return $this;
515
 
        }
516
 
 
517
 
        // --------------------------------------------------------------------
518
 
 
519
 
        /**
520
 
         * Set Priority
521
 
         *
522
 
         * @access      public
523
 
         * @param       integer
524
 
         * @return      void
525
 
         */
526
 
        public function set_priority($n = 3)
527
 
        {
528
 
                if ( ! is_numeric($n))
529
 
                {
530
 
                        $this->priority = 3;
531
 
                        return;
532
 
                }
533
 
 
534
 
                if ($n < 1 OR $n > 5)
535
 
                {
536
 
                        $this->priority = 3;
537
 
                        return;
538
 
                }
539
 
 
540
 
                $this->priority = $n;
541
 
                return $this;
542
 
        }
543
 
 
544
 
        // --------------------------------------------------------------------
545
 
 
546
 
        /**
547
 
         * Set Newline Character
548
 
         *
549
 
         * @access      public
550
 
         * @param       string
551
 
         * @return      void
552
 
         */
553
 
        public function set_newline($newline = "\n")
554
 
        {
555
 
                if ($newline != "\n" AND $newline != "\r\n" AND $newline != "\r")
556
 
                {
557
 
                        $this->newline  = "\n";
558
 
                        return;
559
 
                }
560
 
 
561
 
                $this->newline  = $newline;
562
 
 
563
 
                return $this;
564
 
        }
565
 
 
566
 
        // --------------------------------------------------------------------
567
 
 
568
 
        /**
569
 
         * Set CRLF
570
 
         *
571
 
         * @access      public
572
 
         * @param       string
573
 
         * @return      void
574
 
         */
575
 
        public function set_crlf($crlf = "\n")
576
 
        {
577
 
                if ($crlf != "\n" AND $crlf != "\r\n" AND $crlf != "\r")
578
 
                {
579
 
                        $this->crlf     = "\n";
580
 
                        return;
581
 
                }
582
 
 
583
 
                $this->crlf     = $crlf;
584
 
 
585
 
                return $this;
586
 
        }
587
 
 
588
 
        // --------------------------------------------------------------------
589
 
 
590
 
        /**
591
 
         * Set Message Boundary
592
 
         *
593
 
         * @access      protected
594
 
         * @return      void
595
 
         */
596
 
        protected function _set_boundaries()
597
 
        {
598
 
                $this->_alt_boundary = "B_ALT_".uniqid(''); // multipart/alternative
599
 
                $this->_atc_boundary = "B_ATC_".uniqid(''); // attachment boundary
600
 
        }
601
 
 
602
 
        // --------------------------------------------------------------------
603
 
 
604
 
        /**
605
 
         * Get the Message ID
606
 
         *
607
 
         * @access      protected
608
 
         * @return      string
609
 
         */
610
 
        protected function _get_message_id()
611
 
        {
612
 
                $from = $this->_headers['Return-Path'];
613
 
                $from = str_replace(">", "", $from);
614
 
                $from = str_replace("<", "", $from);
615
 
 
616
 
                return  "<".uniqid('').strstr($from, '@').">";
617
 
        }
618
 
 
619
 
        // --------------------------------------------------------------------
620
 
 
621
 
        /**
622
 
         * Get Mail Protocol
623
 
         *
624
 
         * @access      protected
625
 
         * @param       bool
626
 
         * @return      string
627
 
         */
628
 
        protected function _get_protocol($return = TRUE)
629
 
        {
630
 
                $this->protocol = strtolower($this->protocol);
631
 
                $this->protocol = ( ! in_array($this->protocol, $this->_protocols, TRUE)) ? 'mail' : $this->protocol;
632
 
 
633
 
                if ($return == TRUE)
634
 
                {
635
 
                        return $this->protocol;
636
 
                }
637
 
        }
638
 
 
639
 
        // --------------------------------------------------------------------
640
 
 
641
 
        /**
642
 
         * Get Mail Encoding
643
 
         *
644
 
         * @access      protected
645
 
         * @param       bool
646
 
         * @return      string
647
 
         */
648
 
        protected function _get_encoding($return = TRUE)
649
 
        {
650
 
                $this->_encoding = ( ! in_array($this->_encoding, $this->_bit_depths)) ? '8bit' : $this->_encoding;
651
 
 
652
 
                foreach ($this->_base_charsets as $charset)
653
 
                {
654
 
                        if (strncmp($charset, $this->charset, strlen($charset)) == 0)
655
 
                        {
656
 
                                $this->_encoding = '7bit';
657
 
                        }
658
 
                }
659
 
 
660
 
                if ($return == TRUE)
661
 
                {
662
 
                        return $this->_encoding;
663
 
                }
664
 
        }
665
 
 
666
 
        // --------------------------------------------------------------------
667
 
 
668
 
        /**
669
 
         * Get content type (text/html/attachment)
670
 
         *
671
 
         * @access      protected
672
 
         * @return      string
673
 
         */
674
 
        protected function _get_content_type()
675
 
        {
676
 
                if      ($this->mailtype == 'html' &&  count($this->_attach_name) == 0)
677
 
                {
678
 
                        return 'html';
679
 
                }
680
 
                elseif  ($this->mailtype == 'html' &&  count($this->_attach_name)  > 0)
681
 
                {
682
 
                        return 'html-attach';
683
 
                }
684
 
                elseif  ($this->mailtype == 'text' &&  count($this->_attach_name)  > 0)
685
 
                {
686
 
                        return 'plain-attach';
687
 
                }
688
 
                else
689
 
                {
690
 
                        return 'plain';
691
 
                }
692
 
        }
693
 
 
694
 
        // --------------------------------------------------------------------
695
 
 
696
 
        /**
697
 
         * Set RFC 822 Date
698
 
         *
699
 
         * @access      protected
700
 
         * @return      string
701
 
         */
702
 
        protected function _set_date()
703
 
        {
704
 
                $timezone = date("Z");
705
 
                $operator = (strncmp($timezone, '-', 1) == 0) ? '-' : '+';
706
 
                $timezone = abs($timezone);
707
 
                $timezone = floor($timezone/3600) * 100 + ($timezone % 3600 ) / 60;
708
 
 
709
 
                return sprintf("%s %s%04d", date("D, j M Y H:i:s"), $operator, $timezone);
710
 
        }
711
 
 
712
 
        // --------------------------------------------------------------------
713
 
 
714
 
        /**
715
 
         * Mime message
716
 
         *
717
 
         * @access      protected
718
 
         * @return      string
719
 
         */
720
 
        protected function _get_mime_message()
721
 
        {
722
 
                return "This is a multi-part message in MIME format.".$this->newline."Your email application may not support this format.";
723
 
        }
724
 
 
725
 
        // --------------------------------------------------------------------
726
 
 
727
 
        /**
728
 
         * Validate Email Address
729
 
         *
730
 
         * @access      public
731
 
         * @param       string
732
 
         * @return      bool
733
 
         */
734
 
        public function validate_email($email)
735
 
        {
736
 
                if ( ! is_array($email))
737
 
                {
738
 
                        $this->_set_error_message('lang:email_must_be_array');
739
 
                        return FALSE;
740
 
                }
741
 
 
742
 
                foreach ($email as $val)
743
 
                {
744
 
                        if ( ! $this->valid_email($val))
745
 
                        {
746
 
                                $this->_set_error_message('lang:email_invalid_address', $val);
747
 
                                return FALSE;
748
 
                        }
749
 
                }
750
 
 
751
 
                return TRUE;
752
 
        }
753
 
 
754
 
        // --------------------------------------------------------------------
755
 
 
756
 
        /**
757
 
         * Email Validation
758
 
         *
759
 
         * @access      public
760
 
         * @param       string
761
 
         * @return      bool
762
 
         */
763
 
        public function valid_email($address)
764
 
        {
765
 
                return ( ! preg_match("/^([a-z0-9\+_\-]+)(\.[a-z0-9\+_\-]+)*@([a-z0-9\-]+\.)+[a-z]{2,6}$/ix", $address)) ? FALSE : TRUE;
766
 
        }
767
 
 
768
 
        // --------------------------------------------------------------------
769
 
 
770
 
        /**
771
 
         * Clean Extended Email Address: Joe Smith <joe@smith.com>
772
 
         *
773
 
         * @access      public
774
 
         * @param       string
775
 
         * @return      string
776
 
         */
777
 
        public function clean_email($email)
778
 
        {
779
 
                if ( ! is_array($email))
780
 
                {
781
 
                        if (preg_match('/\<(.*)\>/', $email, $match))
782
 
                        {
783
 
                                return $match['1'];
784
 
                        }
785
 
                        else
786
 
                        {
787
 
                                return $email;
788
 
                        }
789
 
                }
790
 
 
791
 
                $clean_email = array();
792
 
 
793
 
                foreach ($email as $addy)
794
 
                {
795
 
                        if (preg_match( '/\<(.*)\>/', $addy, $match))
796
 
                        {
797
 
                                $clean_email[] = $match['1'];
798
 
                        }
799
 
                        else
800
 
                        {
801
 
                                $clean_email[] = $addy;
802
 
                        }
803
 
                }
804
 
 
805
 
                return $clean_email;
806
 
        }
807
 
 
808
 
        // --------------------------------------------------------------------
809
 
 
810
 
        /**
811
 
         * Build alternative plain text message
812
 
         *
813
 
         * This public function provides the raw message for use
814
 
         * in plain-text headers of HTML-formatted emails.
815
 
         * If the user hasn't specified his own alternative message
816
 
         * it creates one by stripping the HTML
817
 
         *
818
 
         * @access      protected
819
 
         * @return      string
820
 
         */
821
 
        protected function _get_alt_message()
822
 
        {
823
 
                if ($this->alt_message != "")
824
 
                {
825
 
                        return $this->word_wrap($this->alt_message, '76');
826
 
                }
827
 
 
828
 
                if (preg_match('/\<body.*?\>(.*)\<\/body\>/si', $this->_body, $match))
829
 
                {
830
 
                        $body = $match['1'];
831
 
                }
832
 
                else
833
 
                {
834
 
                        $body = $this->_body;
835
 
                }
836
 
 
837
 
                $body = trim(strip_tags($body));
838
 
                $body = preg_replace( '#<!--(.*)--\>#', "", $body);
839
 
                $body = str_replace("\t", "", $body);
840
 
 
841
 
                for ($i = 20; $i >= 3; $i--)
842
 
                {
843
 
                        $n = "";
844
 
 
845
 
                        for ($x = 1; $x <= $i; $x ++)
846
 
                        {
847
 
                                $n .= "\n";
848
 
                        }
849
 
 
850
 
                        $body = str_replace($n, "\n\n", $body);
851
 
                }
852
 
 
853
 
                return $this->word_wrap($body, '76');
854
 
        }
855
 
 
856
 
        // --------------------------------------------------------------------
857
 
 
858
 
        /**
859
 
         * Word Wrap
860
 
         *
861
 
         * @access      public
862
 
         * @param       string
863
 
         * @param       integer
864
 
         * @return      string
865
 
         */
866
 
        public function word_wrap($str, $charlim = '')
867
 
        {
868
 
                // Se the character limit
869
 
                if ($charlim == '')
870
 
                {
871
 
                        $charlim = ($this->wrapchars == "") ? "76" : $this->wrapchars;
872
 
                }
873
 
 
874
 
                // Reduce multiple spaces
875
 
                $str = preg_replace("| +|", " ", $str);
876
 
 
877
 
                // Standardize newlines
878
 
                if (strpos($str, "\r") !== FALSE)
879
 
                {
880
 
                        $str = str_replace(array("\r\n", "\r"), "\n", $str);
881
 
                }
882
 
 
883
 
                // If the current word is surrounded by {unwrap} tags we'll
884
 
                // strip the entire chunk and replace it with a marker.
885
 
                $unwrap = array();
886
 
                if (preg_match_all("|(\{unwrap\}.+?\{/unwrap\})|s", $str, $matches))
887
 
                {
888
 
                        for ($i = 0; $i < count($matches['0']); $i++)
889
 
                        {
890
 
                                $unwrap[] = $matches['1'][$i];
891
 
                                $str = str_replace($matches['1'][$i], "{{unwrapped".$i."}}", $str);
892
 
                        }
893
 
                }
894
 
 
895
 
                // Use PHP's native public function to do the initial wordwrap.
896
 
                // We set the cut flag to FALSE so that any individual words that are
897
 
                // too long get left alone.  In the next step we'll deal with them.
898
 
                $str = wordwrap($str, $charlim, "\n", FALSE);
899
 
 
900
 
                // Split the string into individual lines of text and cycle through them
901
 
                $output = "";
902
 
                foreach (explode("\n", $str) as $line)
903
 
                {
904
 
                        // Is the line within the allowed character count?
905
 
                        // If so we'll join it to the output and continue
906
 
                        if (strlen($line) <= $charlim)
907
 
                        {
908
 
                                $output .= $line.$this->newline;
909
 
                                continue;
910
 
                        }
911
 
 
912
 
                        $temp = '';
913
 
                        while ((strlen($line)) > $charlim)
914
 
                        {
915
 
                                // If the over-length word is a URL we won't wrap it
916
 
                                if (preg_match("!\[url.+\]|://|wwww.!", $line))
917
 
                                {
918
 
                                        break;
919
 
                                }
920
 
 
921
 
                                // Trim the word down
922
 
                                $temp .= substr($line, 0, $charlim-1);
923
 
                                $line = substr($line, $charlim-1);
924
 
                        }
925
 
 
926
 
                        // If $temp contains data it means we had to split up an over-length
927
 
                        // word into smaller chunks so we'll add it back to our current line
928
 
                        if ($temp != '')
929
 
                        {
930
 
                                $output .= $temp.$this->newline.$line;
931
 
                        }
932
 
                        else
933
 
                        {
934
 
                                $output .= $line;
935
 
                        }
936
 
 
937
 
                        $output .= $this->newline;
938
 
                }
939
 
 
940
 
                // Put our markers back
941
 
                if (count($unwrap) > 0)
942
 
                {
943
 
                        foreach ($unwrap as $key => $val)
944
 
                        {
945
 
                                $output = str_replace("{{unwrapped".$key."}}", $val, $output);
946
 
                        }
947
 
                }
948
 
 
949
 
                return $output;
950
 
        }
951
 
 
952
 
        // --------------------------------------------------------------------
953
 
 
954
 
        /**
955
 
         * Build final headers
956
 
         *
957
 
         * @access      protected
958
 
         * @param       string
959
 
         * @return      string
960
 
         */
961
 
        protected function _build_headers()
962
 
        {
963
 
                $this->_set_header('X-Sender', $this->clean_email($this->_headers['From']));
964
 
                $this->_set_header('X-Mailer', $this->useragent);
965
 
                $this->_set_header('X-Priority', $this->_priorities[$this->priority - 1]);
966
 
                $this->_set_header('Message-ID', $this->_get_message_id());
967
 
                $this->_set_header('Mime-Version', '1.0');
968
 
        }
969
 
 
970
 
        // --------------------------------------------------------------------
971
 
 
972
 
        /**
973
 
         * Write Headers as a string
974
 
         *
975
 
         * @access      protected
976
 
         * @return      void
977
 
         */
978
 
        protected function _write_headers()
979
 
        {
980
 
                if ($this->protocol == 'mail')
981
 
                {
982
 
                        $this->_subject = $this->_headers['Subject'];
983
 
                        unset($this->_headers['Subject']);
984
 
                }
985
 
 
986
 
                reset($this->_headers);
987
 
                $this->_header_str = "";
988
 
 
989
 
                foreach ($this->_headers as $key => $val)
990
 
                {
991
 
                        $val = trim($val);
992
 
 
993
 
                        if ($val != "")
994
 
                        {
995
 
                                $this->_header_str .= $key.": ".$val.$this->newline;
996
 
                        }
997
 
                }
998
 
 
999
 
                if ($this->_get_protocol() == 'mail')
1000
 
                {
1001
 
                        $this->_header_str = rtrim($this->_header_str);
1002
 
                }
1003
 
        }
1004
 
 
1005
 
        // --------------------------------------------------------------------
1006
 
 
1007
 
        /**
1008
 
         * Build Final Body and attachments
1009
 
         *
1010
 
         * @access      protected
1011
 
         * @return      void
1012
 
         */
1013
 
        protected function _build_message()
1014
 
        {
1015
 
                if ($this->wordwrap === TRUE  AND  $this->mailtype != 'html')
1016
 
                {
1017
 
                        $this->_body = $this->word_wrap($this->_body);
1018
 
                }
1019
 
 
1020
 
                $this->_set_boundaries();
1021
 
                $this->_write_headers();
1022
 
 
1023
 
                $hdr = ($this->_get_protocol() == 'mail') ? $this->newline : '';
1024
 
                $body = '';
1025
 
 
1026
 
                switch ($this->_get_content_type())
1027
 
                {
1028
 
                        case 'plain' :
1029
 
 
1030
 
                                $hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
1031
 
                                $hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding();
1032
 
 
1033
 
                                if ($this->_get_protocol() == 'mail')
1034
 
                                {
1035
 
                                        $this->_header_str .= $hdr;
1036
 
                                        $this->_finalbody = $this->_body;
1037
 
                                }
1038
 
                                else
1039
 
                                {
1040
 
                                        $this->_finalbody = $hdr . $this->newline . $this->newline . $this->_body;
1041
 
                                }
1042
 
 
1043
 
                                return;
1044
 
 
1045
 
                        break;
1046
 
                        case 'html' :
1047
 
 
1048
 
                                if ($this->send_multipart === FALSE)
1049
 
                                {
1050
 
                                        $hdr .= "Content-Type: text/html; charset=" . $this->charset . $this->newline;
1051
 
                                        $hdr .= "Content-Transfer-Encoding: quoted-printable";
1052
 
                                }
1053
 
                                else
1054
 
                                {
1055
 
                                        $hdr .= "Content-Type: multipart/alternative; boundary=\"" . $this->_alt_boundary . "\"" . $this->newline . $this->newline;
1056
 
 
1057
 
                                        $body .= $this->_get_mime_message() . $this->newline . $this->newline;
1058
 
                                        $body .= "--" . $this->_alt_boundary . $this->newline;
1059
 
 
1060
 
                                        $body .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
1061
 
                                        $body .= "Content-Transfer-Encoding: " . $this->_get_encoding() . $this->newline . $this->newline;
1062
 
                                        $body .= $this->_get_alt_message() . $this->newline . $this->newline . "--" . $this->_alt_boundary . $this->newline;
1063
 
 
1064
 
                                        $body .= "Content-Type: text/html; charset=" . $this->charset . $this->newline;
1065
 
                                        $body .= "Content-Transfer-Encoding: quoted-printable" . $this->newline . $this->newline;
1066
 
                                }
1067
 
 
1068
 
                                $this->_finalbody = $body . $this->_prep_quoted_printable($this->_body) . $this->newline . $this->newline;
1069
 
 
1070
 
 
1071
 
                                if ($this->_get_protocol() == 'mail')
1072
 
                                {
1073
 
                                        $this->_header_str .= $hdr;
1074
 
                                }
1075
 
                                else
1076
 
                                {
1077
 
                                        $this->_finalbody = $hdr . $this->_finalbody;
1078
 
                                }
1079
 
 
1080
 
 
1081
 
                                if ($this->send_multipart !== FALSE)
1082
 
                                {
1083
 
                                        $this->_finalbody .= "--" . $this->_alt_boundary . "--";
1084
 
                                }
1085
 
 
1086
 
                                return;
1087
 
 
1088
 
                        break;
1089
 
                        case 'plain-attach' :
1090
 
 
1091
 
                                $hdr .= "Content-Type: multipart/".$this->multipart."; boundary=\"" . $this->_atc_boundary."\"" . $this->newline . $this->newline;
1092
 
 
1093
 
                                if ($this->_get_protocol() == 'mail')
1094
 
                                {
1095
 
                                        $this->_header_str .= $hdr;
1096
 
                                }
1097
 
 
1098
 
                                $body .= $this->_get_mime_message() . $this->newline . $this->newline;
1099
 
                                $body .= "--" . $this->_atc_boundary . $this->newline;
1100
 
 
1101
 
                                $body .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
1102
 
                                $body .= "Content-Transfer-Encoding: " . $this->_get_encoding() . $this->newline . $this->newline;
1103
 
 
1104
 
                                $body .= $this->_body . $this->newline . $this->newline;
1105
 
 
1106
 
                        break;
1107
 
                        case 'html-attach' :
1108
 
 
1109
 
                                $hdr .= "Content-Type: multipart/".$this->multipart."; boundary=\"" . $this->_atc_boundary."\"" . $this->newline . $this->newline;
1110
 
 
1111
 
                                if ($this->_get_protocol() == 'mail')
1112
 
                                {
1113
 
                                        $this->_header_str .= $hdr;
1114
 
                                }
1115
 
 
1116
 
                                $body .= $this->_get_mime_message() . $this->newline . $this->newline;
1117
 
                                $body .= "--" . $this->_atc_boundary . $this->newline;
1118
 
 
1119
 
                                $body .= "Content-Type: multipart/alternative; boundary=\"" . $this->_alt_boundary . "\"" . $this->newline .$this->newline;
1120
 
                                $body .= "--" . $this->_alt_boundary . $this->newline;
1121
 
 
1122
 
                                $body .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
1123
 
                                $body .= "Content-Transfer-Encoding: " . $this->_get_encoding() . $this->newline . $this->newline;
1124
 
                                $body .= $this->_get_alt_message() . $this->newline . $this->newline . "--" . $this->_alt_boundary . $this->newline;
1125
 
 
1126
 
                                $body .= "Content-Type: text/html; charset=" . $this->charset . $this->newline;
1127
 
                                $body .= "Content-Transfer-Encoding: quoted-printable" . $this->newline . $this->newline;
1128
 
 
1129
 
                                $body .= $this->_prep_quoted_printable($this->_body) . $this->newline . $this->newline;
1130
 
                                $body .= "--" . $this->_alt_boundary . "--" . $this->newline . $this->newline;
1131
 
 
1132
 
                        break;
1133
 
                }
1134
 
 
1135
 
                $attachment = array();
1136
 
 
1137
 
                $z = 0;
1138
 
 
1139
 
                for ($i=0; $i < count($this->_attach_name); $i++)
1140
 
                {
1141
 
                        $filename = $this->_attach_name[$i];
1142
 
                        $basename = basename($filename);
1143
 
                        $ctype = $this->_attach_type[$i];
1144
 
 
1145
 
                        if ( ! file_exists($filename))
1146
 
                        {
1147
 
                                $this->_set_error_message('lang:email_attachment_missing', $filename);
1148
 
                                return FALSE;
1149
 
                        }
1150
 
 
1151
 
                        $h  = "--".$this->_atc_boundary.$this->newline;
1152
 
                        $h .= "Content-type: ".$ctype."; ";
1153
 
                        $h .= "name=\"".$basename."\"".$this->newline;
1154
 
                        $h .= "Content-Disposition: ".$this->_attach_disp[$i].";".$this->newline;
1155
 
                        $h .= "Content-Transfer-Encoding: base64".$this->newline;
1156
 
 
1157
 
                        $attachment[$z++] = $h;
1158
 
                        $file = filesize($filename) +1;
1159
 
 
1160
 
                        if ( ! $fp = fopen($filename, FOPEN_READ))
1161
 
                        {
1162
 
                                $this->_set_error_message('lang:email_attachment_unreadable', $filename);
1163
 
                                return FALSE;
1164
 
                        }
1165
 
 
1166
 
                        $attachment[$z++] = chunk_split(base64_encode(fread($fp, $file)));
1167
 
                        fclose($fp);
1168
 
                }
1169
 
 
1170
 
                $body .= implode($this->newline, $attachment).$this->newline."--".$this->_atc_boundary."--";
1171
 
 
1172
 
 
1173
 
                if ($this->_get_protocol() == 'mail')
1174
 
                {
1175
 
                        $this->_finalbody = $body;
1176
 
                }
1177
 
                else
1178
 
                {
1179
 
                        $this->_finalbody = $hdr . $body;
1180
 
                }
1181
 
 
1182
 
                return;
1183
 
        }
1184
 
 
1185
 
        // --------------------------------------------------------------------
1186
 
 
1187
 
        /**
1188
 
         * Prep Quoted Printable
1189
 
         *
1190
 
         * Prepares string for Quoted-Printable Content-Transfer-Encoding
1191
 
         * Refer to RFC 2045 http://www.ietf.org/rfc/rfc2045.txt
1192
 
         *
1193
 
         * @access      protected
1194
 
         * @param       string
1195
 
         * @param       integer
1196
 
         * @return      string
1197
 
         */
1198
 
        protected function _prep_quoted_printable($str, $charlim = '')
1199
 
        {
1200
 
                // Set the character limit
1201
 
                // Don't allow over 76, as that will make servers and MUAs barf
1202
 
                // all over quoted-printable data
1203
 
                if ($charlim == '' OR $charlim > '76')
1204
 
                {
1205
 
                        $charlim = '76';
1206
 
                }
1207
 
 
1208
 
                // Reduce multiple spaces
1209
 
                $str = preg_replace("| +|", " ", $str);
1210
 
 
1211
 
                // kill nulls
1212
 
                $str = preg_replace('/\x00+/', '', $str);
1213
 
 
1214
 
                // Standardize newlines
1215
 
                if (strpos($str, "\r") !== FALSE)
1216
 
                {
1217
 
                        $str = str_replace(array("\r\n", "\r"), "\n", $str);
1218
 
                }
1219
 
 
1220
 
                // We are intentionally wrapping so mail servers will encode characters
1221
 
                // properly and MUAs will behave, so {unwrap} must go!
1222
 
                $str = str_replace(array('{unwrap}', '{/unwrap}'), '', $str);
1223
 
 
1224
 
                // Break into an array of lines
1225
 
                $lines = explode("\n", $str);
1226
 
 
1227
 
                $escape = '=';
1228
 
                $output = '';
1229
 
 
1230
 
                foreach ($lines as $line)
1231
 
                {
1232
 
                        $length = strlen($line);
1233
 
                        $temp = '';
1234
 
 
1235
 
                        // Loop through each character in the line to add soft-wrap
1236
 
                        // characters at the end of a line " =\r\n" and add the newly
1237
 
                        // processed line(s) to the output (see comment on $crlf class property)
1238
 
                        for ($i = 0; $i < $length; $i++)
1239
 
                        {
1240
 
                                // Grab the next character
1241
 
                                $char = substr($line, $i, 1);
1242
 
                                $ascii = ord($char);
1243
 
 
1244
 
                                // Convert spaces and tabs but only if it's the end of the line
1245
 
                                if ($i == ($length - 1))
1246
 
                                {
1247
 
                                        $char = ($ascii == '32' OR $ascii == '9') ? $escape.sprintf('%02s', dechex($ascii)) : $char;
1248
 
                                }
1249
 
 
1250
 
                                // encode = signs
1251
 
                                if ($ascii == '61')
1252
 
                                {
1253
 
                                        $char = $escape.strtoupper(sprintf('%02s', dechex($ascii)));  // =3D
1254
 
                                }
1255
 
 
1256
 
                                // If we're at the character limit, add the line to the output,
1257
 
                                // reset our temp variable, and keep on chuggin'
1258
 
                                if ((strlen($temp) + strlen($char)) >= $charlim)
1259
 
                                {
1260
 
                                        $output .= $temp.$escape.$this->crlf;
1261
 
                                        $temp = '';
1262
 
                                }
1263
 
 
1264
 
                                // Add the character to our temporary line
1265
 
                                $temp .= $char;
1266
 
                        }
1267
 
 
1268
 
                        // Add our completed line to the output
1269
 
                        $output .= $temp.$this->crlf;
1270
 
                }
1271
 
 
1272
 
                // get rid of extra CRLF tacked onto the end
1273
 
                $output = substr($output, 0, strlen($this->crlf) * -1);
1274
 
 
1275
 
                return $output;
1276
 
        }
1277
 
 
1278
 
        // --------------------------------------------------------------------
1279
 
 
1280
 
        /**
1281
 
         * Prep Q Encoding
1282
 
         *
1283
 
         * Performs "Q Encoding" on a string for use in email headers.  It's related
1284
 
         * but not identical to quoted-printable, so it has its own method
1285
 
         *
1286
 
         * @access      public
1287
 
         * @param       str
1288
 
         * @param       bool    // set to TRUE for processing From: headers
1289
 
         * @return      str
1290
 
         */
1291
 
        protected function _prep_q_encoding($str, $from = FALSE)
1292
 
        {
1293
 
                $str = str_replace(array("\r", "\n"), array('', ''), $str);
1294
 
 
1295
 
                // Line length must not exceed 76 characters, so we adjust for
1296
 
                // a space, 7 extra characters =??Q??=, and the charset that we will add to each line
1297
 
                $limit = 75 - 7 - strlen($this->charset);
1298
 
 
1299
 
                // these special characters must be converted too
1300
 
                $convert = array('_', '=', '?');
1301
 
 
1302
 
                if ($from === TRUE)
1303
 
                {
1304
 
                        $convert[] = ',';
1305
 
                        $convert[] = ';';
1306
 
                }
1307
 
 
1308
 
                $output = '';
1309
 
                $temp = '';
1310
 
 
1311
 
                for ($i = 0, $length = strlen($str); $i < $length; $i++)
1312
 
                {
1313
 
                        // Grab the next character
1314
 
                        $char = substr($str, $i, 1);
1315
 
                        $ascii = ord($char);
1316
 
 
1317
 
                        // convert ALL non-printable ASCII characters and our specials
1318
 
                        if ($ascii < 32 OR $ascii > 126 OR in_array($char, $convert))
1319
 
                        {
1320
 
                                $char = '='.dechex($ascii);
1321
 
                        }
1322
 
 
1323
 
                        // handle regular spaces a bit more compactly than =20
1324
 
                        if ($ascii == 32)
1325
 
                        {
1326
 
                                $char = '_';
1327
 
                        }
1328
 
 
1329
 
                        // If we're at the character limit, add the line to the output,
1330
 
                        // reset our temp variable, and keep on chuggin'
1331
 
                        if ((strlen($temp) + strlen($char)) >= $limit)
1332
 
                        {
1333
 
                                $output .= $temp.$this->crlf;
1334
 
                                $temp = '';
1335
 
                        }
1336
 
 
1337
 
                        // Add the character to our temporary line
1338
 
                        $temp .= $char;
1339
 
                }
1340
 
 
1341
 
                $str = $output.$temp;
1342
 
 
1343
 
                // wrap each line with the shebang, charset, and transfer encoding
1344
 
                // the preceding space on successive lines is required for header "folding"
1345
 
                $str = trim(preg_replace('/^(.*)$/m', ' =?'.$this->charset.'?Q?$1?=', $str));
1346
 
 
1347
 
                return $str;
1348
 
        }
1349
 
 
1350
 
        // --------------------------------------------------------------------
1351
 
 
1352
 
        /**
1353
 
         * Send Email
1354
 
         *
1355
 
         * @access      public
1356
 
         * @return      bool
1357
 
         */
1358
 
        public function send()
1359
 
        {
1360
 
                if ($this->_replyto_flag == FALSE)
1361
 
                {
1362
 
                        $this->reply_to($this->_headers['From']);
1363
 
                }
1364
 
 
1365
 
                if (( ! isset($this->_recipients) AND ! isset($this->_headers['To']))  AND
1366
 
                        ( ! isset($this->_bcc_array) AND ! isset($this->_headers['Bcc'])) AND
1367
 
                        ( ! isset($this->_headers['Cc'])))
1368
 
                {
1369
 
                        $this->_set_error_message('lang:email_no_recipients');
1370
 
                        return FALSE;
1371
 
                }
1372
 
 
1373
 
                $this->_build_headers();
1374
 
 
1375
 
                if ($this->bcc_batch_mode  AND  count($this->_bcc_array) > 0)
1376
 
                {
1377
 
                        if (count($this->_bcc_array) > $this->bcc_batch_size)
1378
 
                                return $this->batch_bcc_send();
1379
 
                }
1380
 
 
1381
 
                $this->_build_message();
1382
 
 
1383
 
                if ( ! $this->_spool_email())
1384
 
                {
1385
 
                        return FALSE;
1386
 
                }
1387
 
                else
1388
 
                {
1389
 
                        return TRUE;
1390
 
                }
1391
 
        }
1392
 
 
1393
 
        // --------------------------------------------------------------------
1394
 
 
1395
 
        /**
1396
 
         * Batch Bcc Send.  Sends groups of BCCs in batches
1397
 
         *
1398
 
         * @access      public
1399
 
         * @return      bool
1400
 
         */
1401
 
        public function batch_bcc_send()
1402
 
        {
1403
 
                $float = $this->bcc_batch_size -1;
1404
 
 
1405
 
                $set = "";
1406
 
 
1407
 
                $chunk = array();
1408
 
 
1409
 
                for ($i = 0; $i < count($this->_bcc_array); $i++)
1410
 
                {
1411
 
                        if (isset($this->_bcc_array[$i]))
1412
 
                        {
1413
 
                                $set .= ", ".$this->_bcc_array[$i];
1414
 
                        }
1415
 
 
1416
 
                        if ($i == $float)
1417
 
                        {
1418
 
                                $chunk[] = substr($set, 1);
1419
 
                                $float = $float + $this->bcc_batch_size;
1420
 
                                $set = "";
1421
 
                        }
1422
 
 
1423
 
                        if ($i == count($this->_bcc_array)-1)
1424
 
                        {
1425
 
                                $chunk[] = substr($set, 1);
1426
 
                        }
1427
 
                }
1428
 
 
1429
 
                for ($i = 0; $i < count($chunk); $i++)
1430
 
                {
1431
 
                        unset($this->_headers['Bcc']);
1432
 
                        unset($bcc);
1433
 
 
1434
 
                        $bcc = $this->_str_to_array($chunk[$i]);
1435
 
                        $bcc = $this->clean_email($bcc);
1436
 
 
1437
 
                        if ($this->protocol != 'smtp')
1438
 
                        {
1439
 
                                $this->_set_header('Bcc', implode(", ", $bcc));
1440
 
                        }
1441
 
                        else
1442
 
                        {
1443
 
                                $this->_bcc_array = $bcc;
1444
 
                        }
1445
 
 
1446
 
                        $this->_build_message();
1447
 
                        $this->_spool_email();
1448
 
                }
1449
 
        }
1450
 
 
1451
 
        // --------------------------------------------------------------------
1452
 
 
1453
 
        /**
1454
 
         * Unwrap special elements
1455
 
         *
1456
 
         * @access      protected
1457
 
         * @return      void
1458
 
         */
1459
 
        protected function _unwrap_specials()
1460
 
        {
1461
 
                $this->_finalbody = preg_replace_callback("/\{unwrap\}(.*?)\{\/unwrap\}/si", array($this, '_remove_nl_callback'), $this->_finalbody);
1462
 
        }
1463
 
 
1464
 
        // --------------------------------------------------------------------
1465
 
 
1466
 
        /**
1467
 
         * Strip line-breaks via callback
1468
 
         *
1469
 
         * @access      protected
1470
 
         * @return      string
1471
 
         */
1472
 
        protected function _remove_nl_callback($matches)
1473
 
        {
1474
 
                if (strpos($matches[1], "\r") !== FALSE OR strpos($matches[1], "\n") !== FALSE)
1475
 
                {
1476
 
                        $matches[1] = str_replace(array("\r\n", "\r", "\n"), '', $matches[1]);
1477
 
                }
1478
 
 
1479
 
                return $matches[1];
1480
 
        }
1481
 
 
1482
 
        // --------------------------------------------------------------------
1483
 
 
1484
 
        /**
1485
 
         * Spool mail to the mail server
1486
 
         *
1487
 
         * @access      protected
1488
 
         * @return      bool
1489
 
         */
1490
 
        protected function _spool_email()
1491
 
        {
1492
 
                $this->_unwrap_specials();
1493
 
 
1494
 
                switch ($this->_get_protocol())
1495
 
                {
1496
 
                        case 'mail'     :
1497
 
 
1498
 
                                        if ( ! $this->_send_with_mail())
1499
 
                                        {
1500
 
                                                $this->_set_error_message('lang:email_send_failure_phpmail');
1501
 
                                                return FALSE;
1502
 
                                        }
1503
 
                        break;
1504
 
                        case 'sendmail' :
1505
 
 
1506
 
                                        if ( ! $this->_send_with_sendmail())
1507
 
                                        {
1508
 
                                                $this->_set_error_message('lang:email_send_failure_sendmail');
1509
 
                                                return FALSE;
1510
 
                                        }
1511
 
                        break;
1512
 
                        case 'smtp'     :
1513
 
 
1514
 
                                        if ( ! $this->_send_with_smtp())
1515
 
                                        {
1516
 
                                                $this->_set_error_message('lang:email_send_failure_smtp');
1517
 
                                                return FALSE;
1518
 
                                        }
1519
 
                        break;
1520
 
 
1521
 
                }
1522
 
 
1523
 
                $this->_set_error_message('lang:email_sent', $this->_get_protocol());
1524
 
                return TRUE;
1525
 
        }
1526
 
 
1527
 
        // --------------------------------------------------------------------
1528
 
 
1529
 
        /**
1530
 
         * Send using mail()
1531
 
         *
1532
 
         * @access      protected
1533
 
         * @return      bool
1534
 
         */
1535
 
        protected function _send_with_mail()
1536
 
        {
1537
 
                if ($this->_safe_mode == TRUE)
1538
 
                {
1539
 
                        if ( ! mail($this->_recipients, $this->_subject, $this->_finalbody, $this->_header_str))
1540
 
                        {
1541
 
                                return FALSE;
1542
 
                        }
1543
 
                        else
1544
 
                        {
1545
 
                                return TRUE;
1546
 
                        }
1547
 
                }
1548
 
                else
1549
 
                {
1550
 
                        // most documentation of sendmail using the "-f" flag lacks a space after it, however
1551
 
                        // we've encountered servers that seem to require it to be in place.
1552
 
 
1553
 
                        if ( ! mail($this->_recipients, $this->_subject, $this->_finalbody, $this->_header_str, "-f ".$this->clean_email($this->_headers['From'])))
1554
 
                        {
1555
 
                                return FALSE;
1556
 
                        }
1557
 
                        else
1558
 
                        {
1559
 
                                return TRUE;
1560
 
                        }
1561
 
                }
1562
 
        }
1563
 
 
1564
 
        // --------------------------------------------------------------------
1565
 
 
1566
 
        /**
1567
 
         * Send using Sendmail
1568
 
         *
1569
 
         * @access      protected
1570
 
         * @return      bool
1571
 
         */
1572
 
        protected function _send_with_sendmail()
1573
 
        {
1574
 
                $fp = @popen($this->mailpath . " -oi -f ".$this->clean_email($this->_headers['From'])." -t", 'w');
1575
 
 
1576
 
                if ($fp === FALSE OR $fp === NULL)
1577
 
                {
1578
 
                        // server probably has popen disabled, so nothing we can do to get a verbose error.
1579
 
                        return FALSE;
1580
 
                }
1581
 
 
1582
 
                fputs($fp, $this->_header_str);
1583
 
                fputs($fp, $this->_finalbody);
1584
 
 
1585
 
                $status = pclose($fp);
1586
 
 
1587
 
                if (version_compare(PHP_VERSION, '4.2.3') == -1)
1588
 
                {
1589
 
                        $status = $status >> 8 & 0xFF;
1590
 
                }
1591
 
 
1592
 
                if ($status != 0)
1593
 
                {
1594
 
                        $this->_set_error_message('lang:email_exit_status', $status);
1595
 
                        $this->_set_error_message('lang:email_no_socket');
1596
 
                        return FALSE;
1597
 
                }
1598
 
 
1599
 
                return TRUE;
1600
 
        }
1601
 
 
1602
 
        // --------------------------------------------------------------------
1603
 
 
1604
 
        /**
1605
 
         * Send using SMTP
1606
 
         *
1607
 
         * @access      protected
1608
 
         * @return      bool
1609
 
         */
1610
 
        protected function _send_with_smtp()
1611
 
        {
1612
 
                if ($this->smtp_host == '')
1613
 
                {
1614
 
                        $this->_set_error_message('lang:email_no_hostname');
1615
 
                        return FALSE;
1616
 
                }
1617
 
 
1618
 
                $this->_smtp_connect();
1619
 
                $this->_smtp_authenticate();
1620
 
 
1621
 
                $this->_send_command('from', $this->clean_email($this->_headers['From']));
1622
 
 
1623
 
                foreach ($this->_recipients as $val)
1624
 
                {
1625
 
                        $this->_send_command('to', $val);
1626
 
                }
1627
 
 
1628
 
                if (count($this->_cc_array) > 0)
1629
 
                {
1630
 
                        foreach ($this->_cc_array as $val)
1631
 
                        {
1632
 
                                if ($val != "")
1633
 
                                {
1634
 
                                        $this->_send_command('to', $val);
1635
 
                                }
1636
 
                        }
1637
 
                }
1638
 
 
1639
 
                if (count($this->_bcc_array) > 0)
1640
 
                {
1641
 
                        foreach ($this->_bcc_array as $val)
1642
 
                        {
1643
 
                                if ($val != "")
1644
 
                                {
1645
 
                                        $this->_send_command('to', $val);
1646
 
                                }
1647
 
                        }
1648
 
                }
1649
 
 
1650
 
                $this->_send_command('data');
1651
 
 
1652
 
                // perform dot transformation on any lines that begin with a dot
1653
 
                $this->_send_data($this->_header_str . preg_replace('/^\./m', '..$1', $this->_finalbody));
1654
 
 
1655
 
                $this->_send_data('.');
1656
 
 
1657
 
                $reply = $this->_get_smtp_data();
1658
 
 
1659
 
                $this->_set_error_message($reply);
1660
 
 
1661
 
                if (strncmp($reply, '250', 3) != 0)
1662
 
                {
1663
 
                        $this->_set_error_message('lang:email_smtp_error', $reply);
1664
 
                        return FALSE;
1665
 
                }
1666
 
 
1667
 
                $this->_send_command('quit');
1668
 
                return TRUE;
1669
 
        }
1670
 
 
1671
 
        // --------------------------------------------------------------------
1672
 
 
1673
 
        /**
1674
 
         * SMTP Connect
1675
 
         *
1676
 
         * @access      protected
1677
 
         * @param       string
1678
 
         * @return      string
1679
 
         */
1680
 
        protected function _smtp_connect()
1681
 
        {
1682
 
                $ssl = NULL;
1683
 
                if ($this->smtp_crypto == 'ssl')
1684
 
                        $ssl = 'ssl://';
1685
 
                $this->_smtp_connect = fsockopen($ssl.$this->smtp_host,
1686
 
                                                                                $this->smtp_port,
1687
 
                                                                                $errno,
1688
 
                                                                                $errstr,
1689
 
                                                                                $this->smtp_timeout);
1690
 
 
1691
 
                if ( ! is_resource($this->_smtp_connect))
1692
 
                {
1693
 
                        $this->_set_error_message('lang:email_smtp_error', $errno." ".$errstr);
1694
 
                        return FALSE;
1695
 
                }
1696
 
 
1697
 
                $this->_set_error_message($this->_get_smtp_data());
1698
 
 
1699
 
                if ($this->smtp_crypto == 'tls')
1700
 
                {
1701
 
                        $this->_send_command('hello');
1702
 
                        $this->_send_command('starttls');
1703
 
                        stream_socket_enable_crypto($this->_smtp_connect, TRUE, STREAM_CRYPTO_METHOD_TLS_CLIENT);
1704
 
                }
1705
 
 
1706
 
                return $this->_send_command('hello');
1707
 
        }
1708
 
 
1709
 
        // --------------------------------------------------------------------
1710
 
 
1711
 
        /**
1712
 
         * Send SMTP command
1713
 
         *
1714
 
         * @access      protected
1715
 
         * @param       string
1716
 
         * @param       string
1717
 
         * @return      string
1718
 
         */
1719
 
        protected function _send_command($cmd, $data = '')
1720
 
        {
1721
 
                switch ($cmd)
1722
 
                {
1723
 
                        case 'hello' :
1724
 
 
1725
 
                                        if ($this->_smtp_auth OR $this->_get_encoding() == '8bit')
1726
 
                                                $this->_send_data('EHLO '.$this->_get_hostname());
1727
 
                                        else
1728
 
                                                $this->_send_data('HELO '.$this->_get_hostname());
1729
 
 
1730
 
                                                $resp = 250;
1731
 
                        break;
1732
 
                        case 'starttls' :
1733
 
 
1734
 
                                                $this->_send_data('STARTTLS');
1735
 
 
1736
 
                                                $resp = 220;
1737
 
                        break;
1738
 
                        case 'from' :
1739
 
 
1740
 
                                                $this->_send_data('MAIL FROM:<'.$data.'>');
1741
 
 
1742
 
                                                $resp = 250;
1743
 
                        break;
1744
 
                        case 'to'       :
1745
 
 
1746
 
                                                $this->_send_data('RCPT TO:<'.$data.'>');
1747
 
 
1748
 
                                                $resp = 250;
1749
 
                        break;
1750
 
                        case 'data'     :
1751
 
 
1752
 
                                                $this->_send_data('DATA');
1753
 
 
1754
 
                                                $resp = 354;
1755
 
                        break;
1756
 
                        case 'quit'     :
1757
 
 
1758
 
                                                $this->_send_data('QUIT');
1759
 
 
1760
 
                                                $resp = 221;
1761
 
                        break;
1762
 
                }
1763
 
 
1764
 
                $reply = $this->_get_smtp_data();
1765
 
 
1766
 
                $this->_debug_msg[] = "<pre>".$cmd.": ".$reply."</pre>";
1767
 
 
1768
 
                if (substr($reply, 0, 3) != $resp)
1769
 
                {
1770
 
                        $this->_set_error_message('lang:email_smtp_error', $reply);
1771
 
                        return FALSE;
1772
 
                }
1773
 
 
1774
 
                if ($cmd == 'quit')
1775
 
                {
1776
 
                        fclose($this->_smtp_connect);
1777
 
                }
1778
 
 
1779
 
                return TRUE;
1780
 
        }
1781
 
 
1782
 
        // --------------------------------------------------------------------
1783
 
 
1784
 
        /**
1785
 
         *  SMTP Authenticate
1786
 
         *
1787
 
         * @access      protected
1788
 
         * @return      bool
1789
 
         */
1790
 
        protected function _smtp_authenticate()
1791
 
        {
1792
 
                if ( ! $this->_smtp_auth)
1793
 
                {
1794
 
                        return TRUE;
1795
 
                }
1796
 
 
1797
 
                if ($this->smtp_user == ""  AND  $this->smtp_pass == "")
1798
 
                {
1799
 
                        $this->_set_error_message('lang:email_no_smtp_unpw');
1800
 
                        return FALSE;
1801
 
                }
1802
 
 
1803
 
                $this->_send_data('AUTH LOGIN');
1804
 
 
1805
 
                $reply = $this->_get_smtp_data();
1806
 
 
1807
 
                if (strncmp($reply, '334', 3) != 0)
1808
 
                {
1809
 
                        $this->_set_error_message('lang:email_failed_smtp_login', $reply);
1810
 
                        return FALSE;
1811
 
                }
1812
 
 
1813
 
                $this->_send_data(base64_encode($this->smtp_user));
1814
 
 
1815
 
                $reply = $this->_get_smtp_data();
1816
 
 
1817
 
                if (strncmp($reply, '334', 3) != 0)
1818
 
                {
1819
 
                        $this->_set_error_message('lang:email_smtp_auth_un', $reply);
1820
 
                        return FALSE;
1821
 
                }
1822
 
 
1823
 
                $this->_send_data(base64_encode($this->smtp_pass));
1824
 
 
1825
 
                $reply = $this->_get_smtp_data();
1826
 
 
1827
 
                if (strncmp($reply, '235', 3) != 0)
1828
 
                {
1829
 
                        $this->_set_error_message('lang:email_smtp_auth_pw', $reply);
1830
 
                        return FALSE;
1831
 
                }
1832
 
 
1833
 
                return TRUE;
1834
 
        }
1835
 
 
1836
 
        // --------------------------------------------------------------------
1837
 
 
1838
 
        /**
1839
 
         * Send SMTP data
1840
 
         *
1841
 
         * @access      protected
1842
 
         * @return      bool
1843
 
         */
1844
 
        protected function _send_data($data)
1845
 
        {
1846
 
                if ( ! fwrite($this->_smtp_connect, $data . $this->newline))
1847
 
                {
1848
 
                        $this->_set_error_message('lang:email_smtp_data_failure', $data);
1849
 
                        return FALSE;
1850
 
                }
1851
 
                else
1852
 
                {
1853
 
                        return TRUE;
1854
 
                }
1855
 
        }
1856
 
 
1857
 
        // --------------------------------------------------------------------
1858
 
 
1859
 
        /**
1860
 
         * Get SMTP data
1861
 
         *
1862
 
         * @access      protected
1863
 
         * @return      string
1864
 
         */
1865
 
        protected function _get_smtp_data()
1866
 
        {
1867
 
                $data = "";
1868
 
 
1869
 
                while ($str = fgets($this->_smtp_connect, 512))
1870
 
                {
1871
 
                        $data .= $str;
1872
 
 
1873
 
                        if (substr($str, 3, 1) == " ")
1874
 
                        {
1875
 
                                break;
1876
 
                        }
1877
 
                }
1878
 
 
1879
 
                return $data;
1880
 
        }
1881
 
 
1882
 
        // --------------------------------------------------------------------
1883
 
 
1884
 
        /**
1885
 
         * Get Hostname
1886
 
         *
1887
 
         * @access      protected
1888
 
         * @return      string
1889
 
         */
1890
 
        protected function _get_hostname()
1891
 
        {
1892
 
                return (isset($_SERVER['SERVER_NAME'])) ? $_SERVER['SERVER_NAME'] : 'localhost.localdomain';
1893
 
        }
1894
 
 
1895
 
        // --------------------------------------------------------------------
1896
 
 
1897
 
        /**
1898
 
         * Get IP
1899
 
         *
1900
 
         * @access      protected
1901
 
         * @return      string
1902
 
         */
1903
 
        protected function _get_ip()
1904
 
        {
1905
 
                if ($this->_IP !== FALSE)
1906
 
                {
1907
 
                        return $this->_IP;
1908
 
                }
1909
 
 
1910
 
                $cip = (isset($_SERVER['HTTP_CLIENT_IP']) AND $_SERVER['HTTP_CLIENT_IP'] != "") ? $_SERVER['HTTP_CLIENT_IP'] : FALSE;
1911
 
                $rip = (isset($_SERVER['REMOTE_ADDR']) AND $_SERVER['REMOTE_ADDR'] != "") ? $_SERVER['REMOTE_ADDR'] : FALSE;
1912
 
                $fip = (isset($_SERVER['HTTP_X_FORWARDED_FOR']) AND $_SERVER['HTTP_X_FORWARDED_FOR'] != "") ? $_SERVER['HTTP_X_FORWARDED_FOR'] : FALSE;
1913
 
 
1914
 
                if ($cip && $rip)       $this->_IP = $cip;
1915
 
                elseif ($rip)           $this->_IP = $rip;
1916
 
                elseif ($cip)           $this->_IP = $cip;
1917
 
                elseif ($fip)           $this->_IP = $fip;
1918
 
 
1919
 
                if (strpos($this->_IP, ',') !== FALSE)
1920
 
                {
1921
 
                        $x = explode(',', $this->_IP);
1922
 
                        $this->_IP = end($x);
1923
 
                }
1924
 
 
1925
 
                if ( ! preg_match( "/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/", $this->_IP))
1926
 
                {
1927
 
                        $this->_IP = '0.0.0.0';
1928
 
                }
1929
 
 
1930
 
                unset($cip);
1931
 
                unset($rip);
1932
 
                unset($fip);
1933
 
 
1934
 
                return $this->_IP;
1935
 
        }
1936
 
 
1937
 
        // --------------------------------------------------------------------
1938
 
 
1939
 
        /**
1940
 
         * Get Debug Message
1941
 
         *
1942
 
         * @access      public
1943
 
         * @return      string
1944
 
         */
1945
 
        public function print_debugger()
1946
 
        {
1947
 
                $msg = '';
1948
 
 
1949
 
                if (count($this->_debug_msg) > 0)
1950
 
                {
1951
 
                        foreach ($this->_debug_msg as $val)
1952
 
                        {
1953
 
                                $msg .= $val;
1954
 
                        }
1955
 
                }
1956
 
 
1957
 
                $msg .= "<pre>".$this->_header_str."\n".htmlspecialchars($this->_subject)."\n".htmlspecialchars($this->_finalbody).'</pre>';
1958
 
                return $msg;
1959
 
        }
1960
 
 
1961
 
        // --------------------------------------------------------------------
1962
 
 
1963
 
        /**
1964
 
         * Set Message
1965
 
         *
1966
 
         * @access      protected
1967
 
         * @param       string
1968
 
         * @return      string
1969
 
         */
1970
 
        protected function _set_error_message($msg, $val = '')
1971
 
        {
1972
 
                $CI =& get_instance();
1973
 
                $CI->lang->load('email');
1974
 
 
1975
 
                if (substr($msg, 0, 5) != 'lang:' || FALSE === ($line = $CI->lang->line(substr($msg, 5))))
1976
 
                {
1977
 
                        $this->_debug_msg[] = str_replace('%s', $val, $msg)."<br />";
1978
 
                }
1979
 
                else
1980
 
                {
1981
 
                        $this->_debug_msg[] = str_replace('%s', $val, $line)."<br />";
1982
 
                }
1983
 
        }
1984
 
 
1985
 
        // --------------------------------------------------------------------
1986
 
 
1987
 
        /**
1988
 
         * Mime Types
1989
 
         *
1990
 
         * @access      protected
1991
 
         * @param       string
1992
 
         * @return      string
1993
 
         */
1994
 
        protected function _mime_types($ext = "")
1995
 
        {
1996
 
                $mimes = array( 'hqx'   =>      'application/mac-binhex40',
1997
 
                                                'cpt'   =>      'application/mac-compactpro',
1998
 
                                                'doc'   =>      'application/msword',
1999
 
                                                'bin'   =>      'application/macbinary',
2000
 
                                                'dms'   =>      'application/octet-stream',
2001
 
                                                'lha'   =>      'application/octet-stream',
2002
 
                                                'lzh'   =>      'application/octet-stream',
2003
 
                                                'exe'   =>      'application/octet-stream',
2004
 
                                                'class' =>      'application/octet-stream',
2005
 
                                                'psd'   =>      'application/octet-stream',
2006
 
                                                'so'    =>      'application/octet-stream',
2007
 
                                                'sea'   =>      'application/octet-stream',
2008
 
                                                'dll'   =>      'application/octet-stream',
2009
 
                                                'oda'   =>      'application/oda',
2010
 
                                                'pdf'   =>      'application/pdf',
2011
 
                                                'ai'    =>      'application/postscript',
2012
 
                                                'eps'   =>      'application/postscript',
2013
 
                                                'ps'    =>      'application/postscript',
2014
 
                                                'smi'   =>      'application/smil',
2015
 
                                                'smil'  =>      'application/smil',
2016
 
                                                'mif'   =>      'application/vnd.mif',
2017
 
                                                'xls'   =>      'application/vnd.ms-excel',
2018
 
                                                'ppt'   =>      'application/vnd.ms-powerpoint',
2019
 
                                                'wbxml' =>      'application/vnd.wap.wbxml',
2020
 
                                                'wmlc'  =>      'application/vnd.wap.wmlc',
2021
 
                                                'dcr'   =>      'application/x-director',
2022
 
                                                'dir'   =>      'application/x-director',
2023
 
                                                'dxr'   =>      'application/x-director',
2024
 
                                                'dvi'   =>      'application/x-dvi',
2025
 
                                                'gtar'  =>      'application/x-gtar',
2026
 
                                                'php'   =>      'application/x-httpd-php',
2027
 
                                                'php4'  =>      'application/x-httpd-php',
2028
 
                                                'php3'  =>      'application/x-httpd-php',
2029
 
                                                'phtml' =>      'application/x-httpd-php',
2030
 
                                                'phps'  =>      'application/x-httpd-php-source',
2031
 
                                                'js'    =>      'application/x-javascript',
2032
 
                                                'swf'   =>      'application/x-shockwave-flash',
2033
 
                                                'sit'   =>      'application/x-stuffit',
2034
 
                                                'tar'   =>      'application/x-tar',
2035
 
                                                'tgz'   =>      'application/x-tar',
2036
 
                                                'xhtml' =>      'application/xhtml+xml',
2037
 
                                                'xht'   =>      'application/xhtml+xml',
2038
 
                                                'zip'   =>      'application/zip',
2039
 
                                                'mid'   =>      'audio/midi',
2040
 
                                                'midi'  =>      'audio/midi',
2041
 
                                                'mpga'  =>      'audio/mpeg',
2042
 
                                                'mp2'   =>      'audio/mpeg',
2043
 
                                                'mp3'   =>      'audio/mpeg',
2044
 
                                                'aif'   =>      'audio/x-aiff',
2045
 
                                                'aiff'  =>      'audio/x-aiff',
2046
 
                                                'aifc'  =>      'audio/x-aiff',
2047
 
                                                'ram'   =>      'audio/x-pn-realaudio',
2048
 
                                                'rm'    =>      'audio/x-pn-realaudio',
2049
 
                                                'rpm'   =>      'audio/x-pn-realaudio-plugin',
2050
 
                                                'ra'    =>      'audio/x-realaudio',
2051
 
                                                'rv'    =>      'video/vnd.rn-realvideo',
2052
 
                                                'wav'   =>      'audio/x-wav',
2053
 
                                                'bmp'   =>      'image/bmp',
2054
 
                                                'gif'   =>      'image/gif',
2055
 
                                                'jpeg'  =>      'image/jpeg',
2056
 
                                                'jpg'   =>      'image/jpeg',
2057
 
                                                'jpe'   =>      'image/jpeg',
2058
 
                                                'png'   =>      'image/png',
2059
 
                                                'tiff'  =>      'image/tiff',
2060
 
                                                'tif'   =>      'image/tiff',
2061
 
                                                'css'   =>      'text/css',
2062
 
                                                'html'  =>      'text/html',
2063
 
                                                'htm'   =>      'text/html',
2064
 
                                                'shtml' =>      'text/html',
2065
 
                                                'txt'   =>      'text/plain',
2066
 
                                                'text'  =>      'text/plain',
2067
 
                                                'log'   =>      'text/plain',
2068
 
                                                'rtx'   =>      'text/richtext',
2069
 
                                                'rtf'   =>      'text/rtf',
2070
 
                                                'xml'   =>      'text/xml',
2071
 
                                                'xsl'   =>      'text/xml',
2072
 
                                                'mpeg'  =>      'video/mpeg',
2073
 
                                                'mpg'   =>      'video/mpeg',
2074
 
                                                'mpe'   =>      'video/mpeg',
2075
 
                                                'qt'    =>      'video/quicktime',
2076
 
                                                'mov'   =>      'video/quicktime',
2077
 
                                                'avi'   =>      'video/x-msvideo',
2078
 
                                                'movie' =>      'video/x-sgi-movie',
2079
 
                                                'doc'   =>      'application/msword',
2080
 
                                                'word'  =>      'application/msword',
2081
 
                                                'xl'    =>      'application/excel',
2082
 
                                                'eml'   =>      'message/rfc822'
2083
 
                                        );
2084
 
 
2085
 
                return ( ! isset($mimes[strtolower($ext)])) ? "application/x-unknown-content-type" : $mimes[strtolower($ext)];
2086
 
        }
2087
 
 
2088
 
}
2089
 
// END CI_Email class
2090
 
 
2091
 
/* End of file Email.php */
2092
 
/* Location: ./system/libraries/Email.php */