Don't open multiple IMAP connections when building reply headers during send
[squirrelmail.git] / class / deliver / Deliver.class.php
1 <?php
2
3 /**
4 * Deliver.class.php
5 *
6 * This contains all the functions needed to send messages through
7 * a delivery backend.
8 *
9 * @author Marc Groot Koerkamp
10 * @copyright &copy; 1999-2007 The SquirrelMail Project Team
11 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
12 * @version $Id$
13 * @package squirrelmail
14 */
15
16 /**
17 * Deliver Class - called to actually deliver the message
18 *
19 * This class is called by compose.php and other code that needs
20 * to send messages. All delivery functionality should be centralized
21 * in this class.
22 *
23 * Do not place UI code in this class, as UI code should be placed in templates
24 * going forward.
25 *
26 * @author Marc Groot Koerkamp
27 * @package squirrelmail
28 */
29 class Deliver {
30
31 /**
32 * function mail - send the message parts to the SMTP stream
33 *
34 * @param Message $message Message object to send
35 * NOTE that this is passed by
36 * reference and will be modified
37 * upon return with updated
38 * fields such as Message ID, References,
39 * In-Reply-To and Date headers.
40 * @param resource $stream Handle to the outgoing stream
41 * (when FALSE, nothing will be
42 * written to the stream; this can
43 * be used to determine the actual
44 * number of bytes that will be
45 * written to the stream)
46 * @param string $reply_id Identifies message being replied to
47 * (OPTIONAL; caller should ONLY specify
48 * a value for this when the message
49 * being sent is a reply)
50 * @param string $reply_ent_id Identifies message being replied to
51 * in the case it was an embedded/attached
52 * message inside another (OPTIONAL; caller
53 * should ONLY specify a value for this
54 * when the message being sent is a reply)
55 * @param mixed $extra Any implementation-specific variables
56 * can be passed in here and used in
57 * an overloaded version of this method
58 * if needed.
59 * @param resource $imap_stream If there is an open IMAP stream in
60 * the caller's context, it should be
61 * passed in here. This is OPTIONAL,
62 * as one will be created if not given,
63 * but as some IMAP servers may baulk
64 * at opening more than one connection
65 * at a time, the caller should always
66 * abide if possible. Currently, this
67 * stream is only used when $reply_id
68 * is also non-zero, but that is subject
69 * to change.
70 *
71 * @return integer The number of bytes written (or that would have been
72 * written) to the output stream.
73 *
74 */
75 function mail(&$message, $stream=false, $reply_id=0, $reply_ent_id=0,
76 $extra=NULL, $imap_stream=NULL) {
77
78 $rfc822_header = &$message->rfc822_header;
79
80 if (count($message->entities)) {
81 $boundary = $this->mimeBoundary();
82 $rfc822_header->content_type->properties['boundary']='"'.$boundary.'"';
83 } else {
84 $boundary='';
85 }
86 $raw_length = 0;
87
88
89 // calculate reply header if needed
90 //
91 if ($reply_id) {
92 global $imapConnection, $username, $imapServerAddress,
93 $imapPort, $mailbox;
94
95 // try our best to use an existing IMAP handle
96 //
97 $close_imap_stream = FALSE;
98 if (is_resource($imap_stream)) {
99 $my_imap_stream = $imap_stream;
100
101 } else if (is_resource($imapConnection)) {
102 $my_imap_stream = $imapConnection;
103
104 } else {
105 $close_imap_stream = TRUE;
106 $my_imap_stream = sqimap_login($username, FALSE,
107 $imapServerAddress, $imapPort, 0);
108 }
109
110 sqimap_mailbox_select($my_imap_stream, $mailbox);
111 $reply_message = sqimap_get_message($my_imap_stream, $reply_id, $mailbox);
112
113 if ($close_imap_stream) {
114 sqimap_logout($my_imap_stream);
115 }
116
117 if ($reply_ent_id) {
118 /* redefine the messsage in case of message/rfc822 */
119 $reply_message = $message->getEntity($reply_ent_id);
120 /* message is an entity which contains the envelope and type0=message
121 * and type1=rfc822. The actual entities are childs from
122 * $reply_message->entities[0]. That's where the encoding and is located
123 */
124
125 $orig_header = $reply_message->rfc822_header; /* here is the envelope located */
126
127 } else {
128 $orig_header = $reply_message->rfc822_header;
129 }
130 $message->reply_rfc822_header = $orig_header;
131 }
132
133
134 $reply_rfc822_header = (isset($message->reply_rfc822_header)
135 ? $message->reply_rfc822_header : '');
136 $header = $this->prepareRFC822_Header($rfc822_header, $reply_rfc822_header, $raw_length);
137
138 $this->send_mail($message, $header, $boundary, $stream, $raw_length, $extra);
139
140 return $raw_length;
141 }
142
143 /**
144 * function send_mail - send the message parts to the IMAP stream
145 *
146 * @param Message $message Message object to send
147 * @param string $header Headers ready to send
148 * @param string $boundary Message parts boundary
149 * @param resource $stream Handle to the SMTP stream
150 * (when FALSE, nothing will be
151 * written to the stream; this can
152 * be used to determine the actual
153 * number of bytes that will be
154 * written to the stream)
155 * @param int &$raw_length The number of bytes written (or that
156 * would have been written) to the
157 * output stream - NOTE that this is
158 * passed by reference
159 * @param mixed $extra Any implementation-specific variables
160 * can be passed in here and used in
161 * an overloaded version of this method
162 * if needed.
163 *
164 * @return void
165 *
166 */
167 function send_mail($message, $header, $boundary, $stream=false,
168 &$raw_length, $extra=NULL) {
169
170
171 if ($stream) {
172 $this->preWriteToStream($header);
173 $this->writeToStream($stream, $header);
174 }
175 $this->writeBody($message, $stream, $raw_length, $boundary);
176 }
177
178 /**
179 * function writeBody - generate and write the mime boundaries around each part to the stream
180 *
181 * Recursively formats and writes the MIME boundaries of the $message
182 * to the output stream.
183 *
184 * @param Message $message Message object to transform
185 * @param resource $stream SMTP output stream
186 * (when FALSE, nothing will be
187 * written to the stream; this can
188 * be used to determine the actual
189 * number of bytes that will be
190 * written to the stream)
191 * @param integer &$length_raw raw length of the message (part)
192 * as returned by mail fn
193 * @param string $boundary custom boundary to call, usually for subparts
194 *
195 * @return void
196 */
197 function writeBody($message, $stream, &$length_raw, $boundary='') {
198 // calculate boundary in case of multidimensional mime structures
199 if ($boundary && $message->entity_id && count($message->entities)) {
200 if (strpos($boundary,'_part_')) {
201 $boundary = substr($boundary,0,strpos($boundary,'_part_'));
202
203 // the next four lines use strrev to reverse any nested boundaries
204 // because RFC 2046 (5.1.1) says that if a line starts with the outer
205 // boundary string (doesn't matter what the line ends with), that
206 // can be considered a match for the outer boundary; thus the nested
207 // boundary needs to be unique from the outer one
208 //
209 } else if (strpos($boundary,'_trap_')) {
210 $boundary = substr(strrev($boundary),0,strpos(strrev($boundary),'_part_'));
211 }
212 $boundary_new = strrev($boundary . '_part_'.$message->entity_id);
213 } else {
214 $boundary_new = $boundary;
215 }
216 if ($boundary && !$message->rfc822_header) {
217 $s = '--'.$boundary."\r\n";
218 $s .= $this->prepareMIME_Header($message, $boundary_new);
219 $length_raw += strlen($s);
220 if ($stream) {
221 $this->preWriteToStream($s);
222 $this->writeToStream($stream, $s);
223 }
224 }
225 $this->writeBodyPart($message, $stream, $length_raw);
226
227 $last = false;
228 for ($i=0, $entCount=count($message->entities);$i<$entCount;$i++) {
229 $msg = $this->writeBody($message->entities[$i], $stream, $length_raw, $boundary_new);
230 if ($i == $entCount-1) $last = true;
231 }
232 if ($boundary && $last) {
233 $s = "--".$boundary_new."--\r\n\r\n";
234 $length_raw += strlen($s);
235 if ($stream) {
236 $this->preWriteToStream($s);
237 $this->writeToStream($stream, $s);
238 }
239 }
240 }
241
242 /**
243 * function writeBodyPart - write each individual mimepart
244 *
245 * Recursively called by WriteBody to write each mime part to the SMTP stream
246 *
247 * @param Message $message Message object to transform
248 * @param resource $stream SMTP output stream
249 * (when FALSE, nothing will be
250 * written to the stream; this can
251 * be used to determine the actual
252 * number of bytes that will be
253 * written to the stream)
254 * @param integer &$length length of the message part
255 * as returned by mail fn
256 *
257 * @return void
258 */
259 function writeBodyPart($message, $stream, &$length) {
260 if ($message->mime_header) {
261 $type0 = $message->mime_header->type0;
262 } else {
263 $type0 = $message->rfc822_header->content_type->type0;
264 }
265
266 $body_part_trailing = $last = '';
267 switch ($type0)
268 {
269 case 'text':
270 case 'message':
271 if ($message->body_part) {
272 $body_part = $message->body_part;
273 // remove NUL characters
274 $body_part = str_replace("\0",'',$body_part);
275 $length += $this->clean_crlf($body_part);
276 if ($stream) {
277 $this->preWriteToStream($body_part);
278 $this->writeToStream($stream, $body_part);
279 }
280 $last = $body_part;
281 } elseif ($message->att_local_name) {
282 global $username, $attachment_dir;
283 $hashed_attachment_dir = getHashedDir($username, $attachment_dir);
284 $filename = $message->att_local_name;
285 $file = fopen ($hashed_attachment_dir . '/' . $filename, 'rb');
286 while ($body_part = fgets($file, 4096)) {
287 // remove NUL characters
288 $body_part = str_replace("\0",'',$body_part);
289 $length += $this->clean_crlf($body_part);
290 if ($stream) {
291 $this->preWriteToStream($body_part);
292 $this->writeToStream($stream, $body_part);
293 }
294 $last = $body_part;
295 }
296 fclose($file);
297 }
298 break;
299 default:
300 if ($message->body_part) {
301 $body_part = $message->body_part;
302 // remove NUL characters
303 $body_part = str_replace("\0",'',$body_part);
304 $length += $this->clean_crlf($body_part);
305 if ($stream) {
306 $this->writeToStream($stream, $body_part);
307 }
308 } elseif ($message->att_local_name) {
309 global $username, $attachment_dir;
310 $hashed_attachment_dir = getHashedDir($username, $attachment_dir);
311 $filename = $message->att_local_name;
312 $file = fopen ($hashed_attachment_dir . '/' . $filename, 'rb');
313 while ($tmp = fread($file, 570)) {
314 $body_part = chunk_split(base64_encode($tmp));
315 // Up to 4.3.10 chunk_split always appends a newline,
316 // while in 4.3.11 it doesn't if the string to split
317 // is shorter than the chunk length.
318 if( substr($body_part, -1 , 1 ) != "\n" )
319 $body_part .= "\n";
320 $length += $this->clean_crlf($body_part);
321 if ($stream) {
322 $this->writeToStream($stream, $body_part);
323 }
324 }
325 fclose($file);
326 }
327 break;
328 }
329 $body_part_trailing = '';
330 if ($last && substr($last,-1) != "\n") {
331 $body_part_trailing = "\r\n";
332 }
333 if ($body_part_trailing) {
334 $length += strlen($body_part_trailing);
335 if ($stream) {
336 $this->preWriteToStream($body_part_trailing);
337 $this->writeToStream($stream, $body_part_trailing);
338 }
339 }
340 }
341
342 /**
343 * function clean_crlf - change linefeeds and newlines to legal characters
344 *
345 * The SMTP format only allows CRLF as line terminators.
346 * This function replaces illegal teminators with the correct terminator.
347 *
348 * @param string &$s string to clean linefeeds on
349 *
350 * @return void
351 */
352 function clean_crlf(&$s) {
353 $s = str_replace("\r\n", "\n", $s);
354 $s = str_replace("\r", "\n", $s);
355 $s = str_replace("\n", "\r\n", $s);
356 return strlen($s);
357 }
358
359 /**
360 * function strip_crlf - strip linefeeds and newlines from a string
361 *
362 * The SMTP format only allows CRLF as line terminators.
363 * This function strips all line terminators from the string.
364 *
365 * @param string &$s string to clean linefeeds on
366 *
367 * @return void
368 */
369 function strip_crlf(&$s) {
370 $s = str_replace("\r\n ", '', $s);
371 $s = str_replace("\r", '', $s);
372 $s = str_replace("\n", '', $s);
373 }
374
375 /**
376 * function preWriteToStream - reserved for extended functionality
377 *
378 * This function is not yet implemented.
379 * Reserved for extended functionality.
380 *
381 * @param string &$s string to operate on
382 *
383 * @return void
384 */
385 function preWriteToStream(&$s) {
386 }
387
388 /**
389 * function writeToStream - write data to the SMTP stream
390 *
391 * @param resource $stream SMTP output stream
392 * @param string $data string with data to send to the SMTP stream
393 *
394 * @return void
395 */
396 function writeToStream($stream, $data) {
397 fputs($stream, $data);
398 }
399
400 /**
401 * function initStream - reserved for extended functionality
402 *
403 * This function is not yet implemented.
404 * Reserved for extended functionality.
405 *
406 * @param Message $message Message object
407 * @param string $host host name or IP to connect to
408 * @param string $user username to log into the SMTP server with
409 * @param string $pass password to log into the SMTP server with
410 * @param integer $length
411 *
412 * @return handle $stream file handle resource to SMTP stream
413 */
414 function initStream($message, $length=0, $host='', $port='', $user='', $pass='') {
415 return $stream;
416 }
417
418 /**
419 * function getBCC - reserved for extended functionality
420 *
421 * This function is not yet implemented.
422 * Reserved for extended functionality.
423 *
424 */
425 function getBCC() {
426 return false;
427 }
428
429 /**
430 * function prepareMIME_Header - creates the mime header
431 *
432 * @param Message $message Message object to act on
433 * @param string $boundary mime boundary from fn MimeBoundary
434 *
435 * @return string $header properly formatted mime header
436 */
437 function prepareMIME_Header($message, $boundary) {
438 $mime_header = $message->mime_header;
439 $rn="\r\n";
440 $header = array();
441
442 $contenttype = 'Content-Type: '. $mime_header->type0 .'/'.
443 $mime_header->type1;
444 if (count($message->entities)) {
445 $contenttype .= ';' . 'boundary="'.$boundary.'"';
446 }
447 if (isset($mime_header->parameters['name'])) {
448 $contenttype .= '; name="'.
449 encodeHeader($mime_header->parameters['name']). '"';
450 }
451 if (isset($mime_header->parameters['charset'])) {
452 $charset = $mime_header->parameters['charset'];
453 $contenttype .= '; charset="'.
454 encodeHeader($charset). '"';
455 }
456
457 $header[] = $contenttype . $rn;
458 if ($mime_header->description) {
459 $header[] = 'Content-Description: ' . $mime_header->description . $rn;
460 }
461 if ($mime_header->encoding) {
462 $header[] = 'Content-Transfer-Encoding: ' . $mime_header->encoding . $rn;
463 } else {
464 if ($mime_header->type0 == 'text' || $mime_header->type0 == 'message') {
465 $header[] = 'Content-Transfer-Encoding: 8bit' . $rn;
466 } else if ($mime_header->type0 == 'multipart' || $mime_header->type0 == 'alternative') {
467 /* no-op; no encoding needed */
468 } else {
469 $header[] = 'Content-Transfer-Encoding: base64' . $rn;
470 }
471 }
472 if ($mime_header->id) {
473 $header[] = 'Content-ID: ' . $mime_header->id . $rn;
474 }
475 if ($mime_header->disposition) {
476 $disposition = $mime_header->disposition;
477 $contentdisp = 'Content-Disposition: ' . $disposition->name;
478 if ($disposition->getProperty('filename')) {
479 $contentdisp .= '; filename="'.
480 encodeHeader($disposition->getProperty('filename')). '"';
481 }
482 $header[] = $contentdisp . $rn;
483 }
484 if ($mime_header->md5) {
485 $header[] = 'Content-MD5: ' . $mime_header->md5 . $rn;
486 }
487 if ($mime_header->language) {
488 $header[] = 'Content-Language: ' . $mime_header->language . $rn;
489 }
490
491 $cnt = count($header);
492 $hdr_s = '';
493 for ($i = 0 ; $i < $cnt ; $i++) {
494 $hdr_s .= $this->foldLine($header[$i], 78,str_pad('',4));
495 }
496 $header = $hdr_s;
497 $header .= $rn; /* One blank line to separate mimeheader and body-entity */
498 return $header;
499 }
500
501 /**
502 * function prepareRFC822_Header - prepares the RFC822 header string from Rfc822Header object(s)
503 *
504 * This function takes the Rfc822Header object(s) and formats them
505 * into the RFC822Header string to send to the SMTP server as part
506 * of the SMTP message.
507 *
508 * @param Rfc822Header $rfc822_header
509 * @param Rfc822Header $reply_rfc822_header
510 * @param integer &$raw_length length of the message
511 *
512 * @return string $header
513 */
514 function prepareRFC822_Header(&$rfc822_header, $reply_rfc822_header, &$raw_length) {
515 global $domain, $username, $encode_header_key,
516 $edit_identity, $hide_auth_header;
517
518 /* if server var SERVER_NAME not available, or contains
519 ":" (e.g. IPv6) which is illegal in a Message-ID, use $domain */
520 if(!sqGetGlobalVar('SERVER_NAME', $SERVER_NAME, SQ_SERVER) ||
521 strpos($SERVER_NAME,':') !== FALSE) {
522 $SERVER_NAME = $domain;
523 }
524
525 sqGetGlobalVar('REMOTE_ADDR', $REMOTE_ADDR, SQ_SERVER);
526 sqGetGlobalVar('REMOTE_PORT', $REMOTE_PORT, SQ_SERVER);
527 sqGetGlobalVar('REMOTE_HOST', $REMOTE_HOST, SQ_SERVER);
528 sqGetGlobalVar('HTTP_VIA', $HTTP_VIA, SQ_SERVER);
529 sqGetGlobalVar('HTTP_X_FORWARDED_FOR', $HTTP_X_FORWARDED_FOR, SQ_SERVER);
530
531 $rn = "\r\n";
532
533 /* This creates an RFC 822 date */
534 $date = date('D, j M Y H:i:s ', time()) . $this->timezone();
535
536 /* Create a message-id */
537 $message_id = 'MESSAGE ID GENERATION ERROR! PLEASE CONTACT SQUIRRELMAIL DEVELOPERS';
538 if (empty($rfc822_header->message_id)) {
539 $message_id = '<';
540 /* user-specifc data to decrease collision chance */
541 $seed_data = $username . '.';
542 $seed_data .= (!empty($REMOTE_PORT) ? $REMOTE_PORT . '.' : '');
543 $seed_data .= (!empty($REMOTE_ADDR) ? $REMOTE_ADDR . '.' : '');
544 /* add the current time in milliseconds and randomness */
545 $seed_data .= uniqid(mt_rand(),true);
546 /* put it through one-way hash and add it to the ID */
547 $message_id .= md5($seed_data) . '.squirrel@' . $SERVER_NAME .'>';
548 }
549
550 /* Make an RFC822 Received: line */
551 if (isset($REMOTE_HOST)) {
552 $received_from = "$REMOTE_HOST ([$REMOTE_ADDR])";
553 } else {
554 $received_from = $REMOTE_ADDR;
555 }
556 if (isset($HTTP_VIA) || isset ($HTTP_X_FORWARDED_FOR)) {
557 if (!isset($HTTP_X_FORWARDED_FOR) || $HTTP_X_FORWARDED_FOR == '') {
558 $HTTP_X_FORWARDED_FOR = 'unknown';
559 }
560 $received_from .= " (proxying for $HTTP_X_FORWARDED_FOR)";
561 }
562 $header = array();
563
564 /**
565 * SquirrelMail header
566 *
567 * This Received: header provides information that allows to track
568 * user and machine that was used to send email. Don't remove it
569 * unless you understand all possible forging issues or your
570 * webmail installation does not prevent changes in user's email address.
571 * See SquirrelMail bug tracker #847107 for more details about it.
572 *
573 * Add $hide_squirrelmail_header as a candidate for config_local.php
574 * to allow completely hiding SquirrelMail participation in message
575 * processing; This is dangerous, especially if users can modify their
576 * account information, as it makes mapping a sent message back to the
577 * original sender almost impossible.
578 */
579 $show_sm_header = ( defined('hide_squirrelmail_header') ? ! hide_squirrelmail_header : 1 );
580
581 // FIXME: The following headers may generate slightly differently between the message sent to the destination and that stored in the Sent folder because this code will be called before both actions. This is not necessarily a big problem, but other headers such as Message-ID and Date are preserved between both actions
582 if ( $show_sm_header ) {
583 if (isset($encode_header_key) &&
584 trim($encode_header_key)!='') {
585 // use encoded headers, if encryption key is set and not empty
586 $header[] = 'X-Squirrel-UserHash: '.OneTimePadEncrypt($username,base64_encode($encode_header_key)).$rn;
587 $header[] = 'X-Squirrel-FromHash: '.OneTimePadEncrypt($this->ip2hex($REMOTE_ADDR),base64_encode($encode_header_key)).$rn;
588 if (isset($HTTP_X_FORWARDED_FOR))
589 $header[] = 'X-Squirrel-ProxyHash:'.OneTimePadEncrypt($this->ip2hex($HTTP_X_FORWARDED_FOR),base64_encode($encode_header_key)).$rn;
590 } else {
591 // use default received headers
592 $header[] = "Received: from $received_from" . $rn;
593 if ($edit_identity || ! isset($hide_auth_header) || ! $hide_auth_header)
594 $header[] = " (SquirrelMail authenticated user $username)" . $rn;
595 $header[] = " by $SERVER_NAME with HTTP;" . $rn;
596 $header[] = " $date" . $rn;
597 }
598 }
599
600 /* Insert the rest of the header fields */
601
602 if (!empty($rfc822_header->message_id)) {
603 $header[] = 'Message-ID: '. $rfc822_header->message_id . $rn;
604 } else {
605 $header[] = 'Message-ID: '. $message_id . $rn;
606 $rfc822_header->message_id = $message_id;
607 }
608
609 if (is_object($reply_rfc822_header) &&
610 isset($reply_rfc822_header->message_id) &&
611 $reply_rfc822_header->message_id) {
612 $rep_message_id = $reply_rfc822_header->message_id;
613 $header[] = 'In-Reply-To: '.$rep_message_id . $rn;
614 $rfc822_header->in_reply_to = $rep_message_id;
615 $references = $this->calculate_references($reply_rfc822_header);
616 $header[] = 'References: '.$references . $rn;
617 $rfc822_header->references = $references;
618 }
619
620 if (!empty($rfc822_header->date) && $rfc822_header->date != -1) {
621 $header[] = 'Date: '. $rfc822_header->date . $rn;
622 } else {
623 $header[] = "Date: $date" . $rn;
624 $rfc822_header->date = $date;
625 }
626
627 $header[] = 'Subject: '.encodeHeader($rfc822_header->subject) . $rn;
628 $header[] = 'From: '. $rfc822_header->getAddr_s('from',",$rn ",true) . $rn;
629
630 // folding address list [From|To|Cc|Bcc] happens by using ",$rn<space>"
631 // as delimiter
632 // Do not use foldLine for that.
633
634 // RFC2822 if from contains more then 1 address
635 if (count($rfc822_header->from) > 1) {
636 $header[] = 'Sender: '. $rfc822_header->getAddr_s('sender',',',true) . $rn;
637 }
638 if (count($rfc822_header->to)) {
639 $header[] = 'To: '. $rfc822_header->getAddr_s('to',",$rn ",true) . $rn;
640 }
641 if (count($rfc822_header->cc)) {
642 $header[] = 'Cc: '. $rfc822_header->getAddr_s('cc',",$rn ",true) . $rn;
643 }
644 if (count($rfc822_header->reply_to)) {
645 $header[] = 'Reply-To: '. $rfc822_header->getAddr_s('reply_to',',',true) . $rn;
646 }
647 /* Sendmail should return true. Default = false */
648 $bcc = $this->getBcc();
649 if (count($rfc822_header->bcc)) {
650 $s = 'Bcc: '. $rfc822_header->getAddr_s('bcc',",$rn ",true) . $rn;
651 if (!$bcc) {
652 $raw_length += strlen($s);
653 } else {
654 $header[] = $s;
655 }
656 }
657 /* Identify SquirrelMail */
658 $header[] = 'User-Agent: SquirrelMail/' . SM_VERSION . $rn;
659 /* Do the MIME-stuff */
660 $header[] = 'MIME-Version: 1.0' . $rn;
661 $contenttype = 'Content-Type: '. $rfc822_header->content_type->type0 .'/'.
662 $rfc822_header->content_type->type1;
663 if (count($rfc822_header->content_type->properties)) {
664 foreach ($rfc822_header->content_type->properties as $k => $v) {
665 if ($k && $v) {
666 $contenttype .= ';' .$k.'='.$v;
667 }
668 }
669 }
670 $header[] = $contenttype . $rn;
671 if ($encoding = $rfc822_header->encoding) {
672 $header[] = 'Content-Transfer-Encoding: ' . $encoding . $rn;
673 }
674 if (isset($rfc822_header->dnt) && $rfc822_header->dnt) {
675 $dnt = $rfc822_header->getAddr_s('dnt');
676 /* Pegasus Mail */
677 $header[] = 'X-Confirm-Reading-To: '.$dnt. $rn;
678 /* RFC 2298 */
679 $header[] = 'Disposition-Notification-To: '.$dnt. $rn;
680 }
681 if ($rfc822_header->priority) {
682 switch($rfc822_header->priority)
683 {
684 case 1:
685 $header[] = 'X-Priority: 1 (Highest)'.$rn;
686 $header[] = 'Importance: High'. $rn; break;
687 case 5:
688 $header[] = 'X-Priority: 5 (Lowest)'.$rn;
689 $header[] = 'Importance: Low'. $rn; break;
690 default: break;
691 }
692 }
693 /* Insert headers from the $more_headers array */
694 if(count($rfc822_header->more_headers)) {
695 reset($rfc822_header->more_headers);
696 foreach ($rfc822_header->more_headers as $k => $v) {
697 $header[] = $k.': '.$v .$rn;
698 }
699 }
700 $cnt = count($header);
701 $hdr_s = '';
702
703 for ($i = 0 ; $i < $cnt ; $i++) {
704 $sKey = substr($header[$i],0,strpos($header[$i],':'));
705 switch ($sKey)
706 {
707 case 'Message-ID':
708 case 'In-Reply_To':
709 $hdr_s .= $header[$i];
710 break;
711 case 'References':
712 $sRefs = substr($header[$i],12);
713 $aRefs = explode(' ',$sRefs);
714 $sLine = 'References:';
715 foreach ($aRefs as $sReference) {
716 if ( trim($sReference) == '' ) {
717 /* Don't add spaces. */
718 } elseif (strlen($sLine)+strlen($sReference) >76) {
719 $hdr_s .= $sLine;
720 $sLine = $rn . ' ' . $sReference;
721 } else {
722 $sLine .= ' '. $sReference;
723 }
724 }
725 $hdr_s .= $sLine;
726 break;
727 case 'To':
728 case 'Cc':
729 case 'Bcc':
730 case 'From':
731 $hdr_s .= $header[$i];
732 break;
733 default: $hdr_s .= $this->foldLine($header[$i], 78, str_pad('',4)); break;
734 }
735 }
736 $header = $hdr_s;
737 $header .= $rn; /* One blank line to separate header and body */
738 $raw_length += strlen($header);
739 return $header;
740 }
741
742 /**
743 * function foldLine - for cleanly folding of headerlines
744 *
745 * @param string $line
746 * @param integer $length length to fold the line at
747 * @param string $pre prefix the line with...
748 *
749 * @return string $line folded line with trailing CRLF
750 */
751 function foldLine($line, $length, $pre='') {
752 $line = substr($line,0, -2);
753 $length -= 2; /* do not fold between \r and \n */
754 $cnt = strlen($line);
755 if ($cnt > $length) { /* try folding */
756 $fold_string = "\r\n " . $pre;
757 $bFirstFold = false;
758 $aFoldLine = array();
759 while (strlen($line) > $length) {
760 $fold = false;
761 /* handle encoded parts */
762 if (preg_match('/(=\?([^?]*)\?(Q|B)\?([^?]*)\?=)(\s+|.*)/Ui',$line,$regs)) {
763 $fold_tmp = $regs[1];
764 if (!trim($regs[5])) {
765 $fold_tmp .= $regs[5];
766 }
767 $iPosEnc = strpos($line,$fold_tmp);
768 $iLengthEnc = strlen($fold_tmp);
769 $iPosEncEnd = $iPosEnc+$iLengthEnc;
770 if ($iPosEnc < $length && (($iPosEncEnd) > $length)) {
771 $fold = true;
772 /* fold just before the start of the encoded string */
773 if ($iPosEnc) {
774 $aFoldLine[] = substr($line,0,$iPosEnc);
775 }
776 $line = substr($line,$iPosEnc);
777 if (!$bFirstFold) {
778 $bFirstFold = true;
779 $length -= strlen($fold_string);
780 }
781 if ($iLengthEnc > $length) { /* place the encoded
782 string on a separate line and do not fold inside it*/
783 /* minimize foldstring */
784 $fold_string = "\r\n ";
785 $aFoldLine[] = substr($line,0,$iLengthEnc);
786 $line = substr($line,$iLengthEnc);
787 }
788 } else if ($iPosEnc < $length) { /* the encoded string fits into the foldlength */
789 /*remainder */
790 $sLineRem = substr($line,$iPosEncEnd,$length - $iPosEncEnd);
791 if (preg_match('/^(=\?([^?]*)\?(Q|B)\?([^?]*)\?=)(.*)/Ui',$sLineRem) || !preg_match('/[=,;\s]/',$sLineRem)) {
792 /*impossible to fold clean in the next part -> fold after the enc string */
793 $aFoldLine[] = substr($line,0,$iPosEncEnd);
794 $line = substr($line,$iPosEncEnd);
795 $fold = true;
796 if (!$bFirstFold) {
797 $bFirstFold = true;
798 $length -= strlen($fold_string);
799 }
800 }
801 }
802 }
803 if (!$fold) {
804 $line_tmp = substr($line,0,$length);
805 $iFoldPos = false;
806 /* try to fold at logical places */
807 switch (true)
808 {
809 case ($iFoldPos = strrpos($line_tmp,',')): break;
810 case ($iFoldPos = strrpos($line_tmp,';')): break;
811 case ($iFoldPos = strrpos($line_tmp,' ')): break;
812 case ($iFoldPos = strrpos($line_tmp,'=')): break;
813 default: break;
814 }
815
816 if (!$iFoldPos) { /* clean folding didn't work */
817 $iFoldPos = $length;
818 }
819 $aFoldLine[] = substr($line,0,$iFoldPos+1);
820 $line = substr($line,$iFoldPos+1);
821 if (!$bFirstFold) {
822 $bFirstFold = true;
823 $length -= strlen($fold_string);
824 }
825 }
826 }
827 /*$reconstruct the line */
828 if ($line) {
829 $aFoldLine[] = $line;
830 }
831 $line = implode($fold_string,$aFoldLine);
832 }
833 return $line."\r\n";
834 }
835
836 /**
837 * function mimeBoundary - calculates the mime boundary to use
838 *
839 * This function will generate a random mime boundary base part
840 * for the message if the boundary has not already been set.
841 *
842 * @return string $mimeBoundaryString random mime boundary string
843 */
844 function mimeBoundary () {
845 static $mimeBoundaryString;
846
847 if ( !isset( $mimeBoundaryString ) ||
848 $mimeBoundaryString == '') {
849 $mimeBoundaryString = '----=_' . date( 'YmdHis' ) . '_' .
850 mt_rand( 10000, 99999 );
851 }
852 return $mimeBoundaryString;
853 }
854
855 /**
856 * function timezone - Time offset for correct timezone
857 *
858 * @return string $result with timezone and offset
859 */
860 function timezone () {
861 global $invert_time;
862
863 $diff_second = date('Z');
864 if ($invert_time) {
865 $diff_second = - $diff_second;
866 }
867 if ($diff_second > 0) {
868 $sign = '+';
869 } else {
870 $sign = '-';
871 }
872 $diff_second = abs($diff_second);
873 $diff_hour = floor ($diff_second / 3600);
874 $diff_minute = floor (($diff_second-3600*$diff_hour) / 60);
875 $zonename = '('.strftime('%Z').')';
876 $result = sprintf ("%s%02d%02d %s", $sign, $diff_hour, $diff_minute,
877 $zonename);
878 return ($result);
879 }
880
881 /**
882 * function calculate_references - calculate correct References string
883 * Adds the current message ID, and makes sure it doesn't grow forever,
884 * to that extent it drops message-ID's in a smart way until the string
885 * length is under the recommended value of 1000 ("References: <986>\r\n").
886 * It always keeps the first and the last three ID's.
887 *
888 * @param Rfc822Header $hdr message header to calculate from
889 *
890 * @return string $refer concatenated and trimmed References string
891 */
892 function calculate_references($hdr) {
893 $aReferences = preg_split('/\s+/', $hdr->references);
894 $message_id = $hdr->message_id;
895 $in_reply_to = $hdr->in_reply_to;
896
897 // if References already exists, add the current message ID at the end.
898 // no References exists; if we know a IRT, add that aswell
899 if (count($aReferences) == 0 && $in_reply_to) {
900 $aReferences[] = $in_reply_to;
901 }
902 $aReferences[] = $message_id;
903
904 // sanitize the array: trim whitespace, remove dupes
905 array_walk($aReferences, 'sq_trim_value');
906 $aReferences = array_unique($aReferences);
907
908 while ( count($aReferences) > 4 && strlen(implode(' ', $aReferences)) >= 986 ) {
909 $aReferences = array_merge(array_slice($aReferences,0,1),array_slice($aReferences,2));
910 }
911 return implode(' ', $aReferences);
912 }
913
914 /**
915 * Converts ip address to hexadecimal string
916 *
917 * Function is used to convert ipv4 and ipv6 addresses to hex strings.
918 * It removes all delimiter symbols from ip addresses, converts decimal
919 * ipv4 numbers to hex and pads strings in order to present full length
920 * address. ipv4 addresses are represented as 8 byte strings, ipv6 addresses
921 * are represented as 32 byte string.
922 *
923 * If function fails to detect address format, it returns unprocessed string.
924 * @param string $string ip address string
925 * @return string processed ip address string
926 * @since 1.5.1 and 1.4.5
927 */
928 function ip2hex($string) {
929 if (preg_match("/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/",$string,$match)) {
930 // ipv4 address
931 $ret = str_pad(dechex($match[1]),2,'0',STR_PAD_LEFT)
932 . str_pad(dechex($match[2]),2,'0',STR_PAD_LEFT)
933 . str_pad(dechex($match[3]),2,'0',STR_PAD_LEFT)
934 . str_pad(dechex($match[4]),2,'0',STR_PAD_LEFT);
935 } elseif (preg_match("/^([0-9a-h]+)\:([0-9a-h]+)\:([0-9a-h]+)\:([0-9a-h]+)\:([0-9a-h]+)\:([0-9a-h]+)\:([0-9a-h]+)\:([0-9a-h]+)$/i",$string,$match)) {
936 // full ipv6 address
937 $ret = str_pad($match[1],4,'0',STR_PAD_LEFT)
938 . str_pad($match[2],4,'0',STR_PAD_LEFT)
939 . str_pad($match[3],4,'0',STR_PAD_LEFT)
940 . str_pad($match[4],4,'0',STR_PAD_LEFT)
941 . str_pad($match[5],4,'0',STR_PAD_LEFT)
942 . str_pad($match[6],4,'0',STR_PAD_LEFT)
943 . str_pad($match[7],4,'0',STR_PAD_LEFT)
944 . str_pad($match[8],4,'0',STR_PAD_LEFT);
945 } elseif (preg_match("/^\:\:([0-9a-h\:]+)$/i",$string,$match)) {
946 // short ipv6 with all starting symbols nulled
947 $aAddr=explode(':',$match[1]);
948 $ret='';
949 foreach ($aAddr as $addr) {
950 $ret.=str_pad($addr,4,'0',STR_PAD_LEFT);
951 }
952 $ret=str_pad($ret,32,'0',STR_PAD_LEFT);
953 } elseif (preg_match("/^([0-9a-h\:]+)::([0-9a-h\:]+)$/i",$string,$match)) {
954 // short ipv6 with middle part nulled
955 $aStart=explode(':',$match[1]);
956 $sStart='';
957 foreach($aStart as $addr) {
958 $sStart.=str_pad($addr,4,'0',STR_PAD_LEFT);
959 }
960 $aEnd = explode(':',$match[2]);
961 $sEnd='';
962 foreach($aEnd as $addr) {
963 $sEnd.=str_pad($addr,4,'0',STR_PAD_LEFT);
964 }
965 $ret = $sStart
966 . str_pad('',(32 - strlen($sStart . $sEnd)),'0',STR_PAD_LEFT)
967 . $sEnd;
968 } else {
969 // unknown addressing
970 $ret = $string;
971 }
972 return $ret;
973 }
974 }