/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: Gustav Hatvigsson
  • Date: 2013-04-11 09:20:09 UTC
  • mfrom: (19.1.5 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130411092009-ylcqzqwcmjdglb17
merged in implemetaion group one's team bransh, it contains code-ignighter
and the new admin-panel.
20130411

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 */