9f039ebf758a8051b24c1e4d696874e6217d8610
[banana.git] / banana / mimepart.inc.php
1 <?php
2 /********************************************************************************
3 * banana/mimepart.inc.php : class for MIME parts
4 * ------------------------
5 *
6 * This file is part of the banana distribution
7 * Copyright: See COPYING files that comes with this distribution
8 ********************************************************************************/
9
10 class BananaMimePart
11 {
12 public $headers = null; /* Should be protected */
13
14 private $id = null;
15 private $content_type = null;
16 private $charset = null;
17 private $encoding = null;
18 private $disposition = null;
19 private $boundary = null;
20 private $filename = null;
21 private $format = null;
22
23 private $body = null;
24 private $multipart = null;
25
26 protected function __construct($data = null)
27 {
28 if (!is_null($data)) {
29 $this->fromRaw($data);
30 }
31 }
32
33 protected function makeTextPart($body, $content_type, $encoding, $charset = null, $format = 'fixed')
34 {
35 $this->body = $body;
36 $this->charset = $charset;
37 $this->encoding = $encoding;
38 $this->content_type = $content_type;
39 $this->format = strtolower($format);
40 $this->parse();
41 }
42
43 protected function makeDataPart($body, $content_type, $encoding, $filename, $disposition, $id = null)
44 {
45 $this->body = $body;
46 $this->content_type = $content_type;
47 $this->encoding = $encoding;
48 $this->filename = $filename;
49 $this->disposition = $disposition;
50 $this->id = $id;
51 if (is_null($content_type) || $content_type == 'application/octet-stream') {
52 $this->decodeContent();
53 $this->content_type = BananaMimePart::getMimeType($body, false);
54 }
55 }
56
57 protected function makeFilePart($file, $content_type =null, $disposition = 'attachment')
58 {
59 $body = file_get_contents($file['tmp_name']);
60 if ($body === false || strlen($body) != $file['size']) {
61 return false;
62 }
63 if (is_null($content_type) || $content_type == 'application/octet-stream') {
64 $content_type = BananaMimePart::getMimeType($file['tmp_name']);
65 }
66 if (substr($content_type, 0, 5) == 'text/') {
67 $encoding = '8bit';
68 } else {
69 $encoding = 'base64';
70 $body = chunk_split(base64_encode($body));
71 }
72 $this->filename = $file['name'];
73 $this->content_type = $content_type;
74 $this->disposition = $disposition;
75 $this->body = $body;
76 $this->encoding = $encoding;
77 return true;
78 }
79
80 protected function makeMultiPart($body, $content_type, $encoding, $boundary)
81 {
82 $this->body = $body;
83 $this->content_type = $content_type;
84 $this->encoding = $encoding;
85 $this->boundary = $boundary;
86 $this->parse();
87 }
88
89 protected function convertToMultiPart()
90 {
91 if (!$this->isType('multipart', 'mixed')) {
92 $newpart = $this;
93 $this->content_type = 'multipart/mixed';
94 $this->encoding = '8bit';
95 $this->multipart = array($newpart);
96 $this->headers = null;
97 $this->charset = null;
98 $this->disposition = null;
99 $this->filename = null;
100 $this->boundary = null;
101 $this->body = null;
102 $this->format = null;
103 $this->id = null;
104 }
105 }
106
107 public function addAttachment(array $file, $content_type = null, $disposition = 'attachment')
108 {
109 $newpart = new BananaMimePart;
110 if (!is_uploaded_file($file['tmp_name'])) {
111 return false;
112 }
113 if ($newpart->makeFilePart($file, $content_type, $disposition)) {
114 $this->convertToMultiPart();
115 $this->multipart[] = $newpart;
116 return true;
117 }
118 return false;
119 }
120
121 protected function getHeader($title, $filter = null)
122 {
123 if (!isset($this->headers[$title])) {
124 return null;
125 }
126 $header =& $this->headers[$title];
127 if (is_null($filter)) {
128 return trim($header);
129 } elseif (preg_match($filter, $header, $matches)) {
130 return trim($matches[1]);
131 }
132 return null;
133 }
134
135 protected function fromRaw($data)
136 {
137 if (is_array($data)) {
138 if (array_key_exists('From', $data)) {
139 $this->headers = array_map(array($this, 'decodeHeader'), array_change_key_case($data));
140 return;
141 } else {
142 $lines = $data;
143 }
144 } else {
145 $lines = explode("\n", $data);
146 }
147 $headers = BananaMimePart::parseHeaders($lines);
148 $this->headers =& $headers;
149 if (empty($headers) || empty($lines)) {
150 return;
151 }
152 $content = join("\n", $lines);
153 $test = trim($content);
154 if (empty($test)) {
155 return;
156 }
157
158 $content_type = strtolower($this->getHeader('content-type', '/^\s*([^ ;]+?)(;|$)/'));
159 if (empty($content_type)) {
160 $encoding = '8bit';
161 $charset = 'CP1252';
162 $content_type = 'text/plain';
163 $format = strtolower($this->getHeader('x-rfc2646', '/format="?([^"]+?)"?\s*(;|$)/i'));
164 } else {
165 $encoding = strtolower($this->getHeader('content-transfer-encoding'));
166 $disposition = $this->getHeader('content-disposition', '/(inline|attachment)/i');
167 $boundary = $this->getHeader('content-type', '/boundary="?([^"]+?)"?\s*(;|$)/i');
168 $charset = strtolower($this->getHeader('content-type', '/charset="?([^"]+?)"?\s*(;|$)/i'));
169 $filename = $this->getHeader('content-disposition', '/filename="?([^"]+?)"?\s*(;|$)/i');
170 $format = strtolower($this->getHeader('content-type', '/format="?([^"]+?)"?\s*(;|$)/i'));
171 $id = $this->getHeader('content-id', '/<(.*?)>/');
172 if (empty($filename)) {
173 $filename = $this->getHeader('content-type', '/name="?([^"]+)"?/');
174 }
175 }
176 list($type, $subtype) = explode('/', $content_type);
177 switch ($type) {
178 case 'text': case 'message':
179 $this->makeTextPart($content, $content_type, $encoding, $charset, $format);
180 break;
181 case 'multipart':
182 $this->makeMultiPart($content, $content_type, $encoding, $boundary);
183 break;
184 default:
185 $this->makeDataPart($content, $content_type, $encoding, $filename, $disposition, $id);
186 }
187 }
188
189 private function parse()
190 {
191 if ($this->isType('multipart')) {
192 $this->splitMultipart();
193 } else {
194 $parts = $this->findUUEncoded();
195 if (count($parts)) {
196 $this->convertToMultiPart();
197 $this->multipart = array_merge(array($textpart), $parts);
198 }
199 }
200 }
201
202 private function splitMultipart()
203 {
204 $this->decodeContent();
205 if (is_null($this->multipart)) {
206 $this->multipart = array();
207 }
208 $boundary =& $this->boundary;
209 $parts = preg_split("/\n--" . preg_quote($boundary, '/') . "(--|\n)/", $this->body, -1, PREG_SPLIT_NO_EMPTY);
210 foreach ($parts as &$part) {
211 $newpart = new BananaMimePart($part);
212 if (!is_null($newpart->content_type)) {
213 $this->multipart[] = $newpart;
214 }
215 }
216 $this->body = null;
217 }
218
219 public static function getMimeType($data, $is_filename = true)
220 {
221 if ($is_filename) {
222 $type = mime_content_type($arg);
223 } else {
224 $arg = escapeshellarg($data);
225 $type = preg_replace('/;.*/', '', trim(shell_exec("echo $arg | file -bi -")));
226 }
227 return empty($type) ? 'application/octet-stream' : $type;
228 }
229
230 private function findUUEncoded()
231 {
232 $this->decodeContent();
233 $parts = array();
234 if (preg_match_all("/\n(begin \d+ ([^\r\n]+)\r?(?:\n(?!end)[^\n]*)*\nend)/",
235 $this->body, $matches, PREG_SET_ORDER)) {
236 foreach ($matches as &$match) {
237 $data = convert_uudecode($match[1]);
238 $mime = BananaMimePart::getMimeType($data, false);
239 if ($mime != 'application/x-empty') {
240 $this->body = trim(str_replace($match[0], '', $this->body));
241 $newpart = new BananaMimePart;
242 $newpart->makeDataPart($data, $mime, '8bit', $match[2], 'attachment');
243 $parts[] = $newpart;
244 }
245 }
246 }
247 return $parts;
248 }
249
250 static private function _decodeHeader($charset, $c, $str)
251 {
252 $s = ($c == 'Q' || $c == 'q') ? quoted_printable_decode($str) : base64_decode($str);
253 $s = @iconv($charset, 'UTF-8', $s);
254 return str_replace('_', ' ', $s);
255 }
256
257 static public function decodeHeader(&$val, $key)
258 {
259 if (preg_match('/[\x80-\xff]/', $val)) {
260 if (!is_utf8($val)) {
261 $val = utf8_encode($val);
262 }
263 } else {
264 $val = preg_replace('/(=\?.*?\?[bq]\?.*?\?=) (=\?.*?\?[bq]\?.*?\?=)/i', '\1\2', $val);
265 $val = preg_replace('/=\?(.*?)\?([bq])\?(.*?)\?=/ie', 'BananaMimePart::_decodeHeader("\1", "\2", "\3")', $val);
266 }
267 }
268
269 static public function &parseHeaders(array &$lines)
270 {
271 $headers = array();
272 while (count($lines)) {
273 $line = array_shift($lines);
274 if (preg_match('/^[\t\r ]+/', $line) && isset($hdr)) {
275 $headers[$hdr] .= ' ' . trim($line);
276 } elseif (!empty($line)) {
277 if (preg_match("/:[ \t\r]*/", $line)) {
278 list($hdr, $val) = split(":[ \t\r]*", $line, 2);
279 $hdr = strtolower($hdr);
280 if (in_array($hdr, Banana::$msgparse_headers)) {
281 $headers[$hdr] = $val;
282 } else {
283 unset($hdr);
284 }
285 }
286 } else {
287 break;
288 }
289 }
290 array_walk($headers, array('BananaMimePart', 'decodeHeader'));
291 return $headers;
292 }
293
294 static public function encodeHeader($value, $trim = 0)
295 {
296 if ($trim) {
297 if (strlen($value) > $trim) {
298 $value = substr($value, 0, $trim);
299 }
300 }
301 if (preg_match('/[\x80-\xff]/', $value)) {
302 return '=?UTF-8?B?' . base64_encode($value) . '?=';
303 }
304 return $value;
305 }
306
307 private function decodeContent()
308 {
309 $encodings = Array('quoted-printable' => 'quoted_printable_decode',
310 'base64' => 'base64_decode',
311 'x-uuencode' => 'convert_uudecode');
312 foreach ($encodings as $encoding => $callback) {
313 if ($this->encoding == $encoding) {
314 $this->body = $callback($this->body);
315 $this->encoding = '8bit';
316 break;
317 }
318 }
319 if (!$this->isType('text')) {
320 return;
321 }
322
323 if (!is_null($this->charset)) {
324 $body = iconv($this->charset, 'UTF-8//IGNORE', $this->body);
325 if (empty($body)) {
326 return;
327 }
328 $this->body = $body;
329 } else {
330 $this->body = utf8_encode($this->body);
331 }
332 $this->charset = 'utf-8';
333 }
334
335 public function send($force_inline = false)
336 {
337 $this->decodeContent();
338 if ($force_inline) {
339 $dispostion = $this->disposition;
340 $this->disposition = 'inline';
341 }
342 $headers = $this->getHeaders();
343 foreach ($headers as $key => $value) {
344 header("$key: $value");
345 }
346 if ($force_inline) {
347 $this->disposition = $disposition;
348 }
349 echo $this->body;
350 exit;
351 }
352
353 private function setBoundary()
354 {
355 if ($this->isType('multipart') && is_null($this->boundary)) {
356 $this->boundary = '--banana-bound-' . time() . rand(0, 255) . '-';
357 }
358 }
359
360 public function getHeaders()
361 {
362 $headers = array();
363 $this->setBoundary();
364 $headers['Content-Type'] = $this->content_type . ";"
365 . ($this->filename ? " name=\"{$this->filename}\";" : '')
366 . ($this->charset ? " charset=\"{$this->charset}\";" : '')
367 . ($this->boundary ? " boundary=\"{$this->boundary}\";" : "");
368 if ($this->encoding) {
369 $headers['Content-Transfer-Encoding'] = $this->encoding;
370 }
371 if ($this->disposition) {
372 $headers['Content-Disposition'] = $this->disposition
373 . ($this->filename ? "; filename=\"{$this->filename}\"" : '');
374 }
375 return array_map(array($this, 'encodeHeader'), $headers);
376 }
377
378 public function hasBody()
379 {
380 if (is_null($this->content) && !$this->isType('multipart')) {
381 return false;
382 }
383 return true;
384 }
385
386 public function get($with_headers = false)
387 {
388 $content = "";
389 if ($with_headers) {
390 foreach ($this->getHeaders() as $key => $value) {
391 $content .= "$key: $value\n";
392 }
393 $content .= "\n";
394 }
395 if ($this->isType('multipart')) {
396 $this->setBoundary();
397 foreach ($this->multipart as &$part) {
398 $content .= "\n--{$this->boundary}\n" . $part->get(true);
399 }
400 $content .= "\n--{$this->boundary}--";
401 } else {
402 $content .= $this->body;
403 }
404 return $content;
405 }
406
407 public function getText()
408 {
409 $this->decodeContent();
410 return $this->body;
411 }
412
413 public function toHtml()
414 {
415 list($type, $subtype) = $this->getType();
416 if ($type == 'image') {
417 $part = $this->id ? $this->id : $this->filename;
418 return '<img src="'
419 . banana_htmlentities(Banana::$page->makeUrl(array('group' => Banana::$group,
420 'artid' => Banana::$artid,
421 'part' => $part)))
422 . '" alt="' . banana_htmlentities($this->filename) . '" />';
423 } elseif (!in_array($type, Banana::$msgshow_mimeparts)
424 && !in_array($this->content_type, Banana::$msgshow_mimeparts)) {
425 $part = $this->id ? $this->id : $this->filename;
426 if (!$part) {
427 $part = $this->content_type;
428 }
429 return '[' . Banana::$page->makeImgLink(array('group' => Banana::$group,
430 'artid' => Banana::$artid,
431 'part' => $part,
432 'text' => $this->filename ? $this->filename : $this->content_type,
433 'img' => 'save')) . ']';
434 } else {
435 if ($type == 'multipart' && ($subtype == 'mixed' || $subtype == 'report')) {
436 $text = '';
437 foreach ($this->multipart as &$part) {
438 $text .= $part->toHtml();
439 }
440 return $text;
441 }
442 switch ($subtype) {
443 case 'html': return banana_formatHtml($this);
444 case 'enriched': case 'richtext': return banana_formatRichText($this);
445 default:
446 if ($type == 'message') {
447 return '<hr />' . banana_formatPlainText($this);
448 }
449 return banana_formatPlainText($this);
450 }
451 }
452 return null;
453 }
454
455 public function quote()
456 {
457 list($type, $subtype) = $this->getType();
458 if (in_array($type, Banana::$msgedit_mimeparts) || in_array($this->content_type, Banana::$msgedit_mimeparts)) {
459 if ($type == 'multipart' && ($subtype == 'mixed' || $subtype == 'report')) {
460 $text = '';
461 foreach ($this->multipart as &$part) {
462 $qt = $part->quote();
463 $qt = rtrim($qt);
464 if (!empty($text)) {
465 $text .= "\n" . banana_quote("", 1) . "\n";
466 }
467 $text .= $qt;
468 }
469 return $text;
470 }
471 switch ($subtype) {
472 case 'html': return banana_quoteHtml($this);
473 case 'enriched': case 'richtext': return banana_quoteRichText($this);
474 default: return banana_quotePlainText($this);
475 }
476 }
477 }
478
479 protected function getType()
480 {
481 return explode('/', $this->content_type);
482 }
483
484 protected function isType($type, $subtype = null)
485 {
486 list($mytype, $mysub) = $this->getType();
487 return ($mytype == $type) && (is_null($subtype) || $mysub == $subtype);
488 }
489
490 public function isFlowed()
491 {
492 return $this->format == 'flowed';
493 }
494
495 public function getFilename()
496 {
497 return $this->filename;
498 }
499
500 protected function getParts($type, $subtype = null)
501 {
502 $parts = array();
503 if ($this->isType($type, $subtype)) {
504 return array($this);
505 } elseif ($this->isType('multipart')) {
506 foreach ($this->multipart as &$part) {
507 $parts = array_merge($parts, $part->getParts($type, $subtype));
508 }
509 }
510 return $parts;
511 }
512
513 public function getFile($filename)
514 {
515 if ($this->filename == $filename) {
516 return $this;
517 } elseif ($this->isType('multipart')) {
518 foreach ($this->multipart as &$part) {
519 $file = $part->getFile($filename);
520 if (!is_null($file)) {
521 return $file;
522 }
523 }
524 }
525 return null;
526 }
527
528 public function getAttachments()
529 {
530 if (!is_null($this->filename)) {
531 return array($this);
532 } elseif ($this->isType('multipart')) {
533 $parts = array();
534 foreach ($this->multipart as &$part) {
535 $parts = array_merge($parts, $part->getAttachments());
536 }
537 return $parts;
538 }
539 return array();
540 }
541
542 public function getPartById($id)
543 {
544 if ($this->id == $id) {
545 return $this;
546 } elseif ($this->isType('multipart')) {
547 foreach ($this->multipart as &$part) {
548 $res = $part->getPartById($id);
549 if (!is_null($res)) {
550 return $res;
551 }
552 }
553 }
554 return null;
555 }
556 }
557
558 // vim:set et sw=4 sts=4 ts=4 enc=utf-8:
559 ?>