/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-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

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