Source for file Message.class.php

Documentation is available at Message.class.php

  1. <?php
  3. /**
  4. * Message.class.php
  5. *
  6. * This file contains functions needed to handle mime messages.
  7. *
  8. * @copyright 2003-2020 The SquirrelMail Project Team
  9. * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  10. * @version $Id: Message.class.php 14840 2020年01月07日 07:42:38Z pdontthink $
  11. * @package squirrelmail
  12. * @subpackage mime
  13. * @since 1.3.2
  14. */
  16. /**
  17. * The object that contains a message.
  18. *
  19. * message is the object that contains messages. It is a recursive object in
  20. * that through the $entities variable, it can contain more objects of type
  21. * message. See documentation in mime.txt for a better description of how this
  22. * works.
  23. * @package squirrelmail
  24. * @subpackage mime
  25. * @since 1.3.0
  26. */
  27. class Message {
  28. /**
  29. * rfc822header object
  30. * @var object
  31. */
  32. var $rfc822_header = '';
  33. /**
  34. * Headers from original email in reply
  35. * @var string
  36. */
  38. /**
  39. * MessageHeader object
  40. * @var object
  41. */
  42. var $mime_header = '';
  43. /**
  44. * @var mixed
  45. */
  46. var $flags = '';
  47. /**
  48. * Media type
  49. * @var string
  50. */
  51. var $type0='';
  52. /**
  53. * Media subtype
  54. * @var string
  55. */
  56. var $type1='';
  57. /**
  58. * Nested mime parts
  59. * @var array
  60. */
  61. var $entities = array();
  62. /**
  63. * Message part id
  64. * @var string
  65. */
  66. var $entity_id = '';
  67. /**
  68. * Parent message part id
  69. * @var string
  70. */
  72. /**
  73. * @var mixed
  74. */
  75. var $entity ;
  76. /**
  77. * @var mixed
  78. */
  79. var $parent = '';
  80. /**
  81. * @var string
  82. */
  83. var $decoded_body='';
  84. /**
  85. * Message \seen status
  86. * @var boolean
  87. */
  88. var $is_seen = 0;
  89. /**
  90. * Message \answered status
  91. * @var boolean
  92. */
  93. var $is_answered = 0;
  94. /**
  95. * Message \deleted status
  96. * @var boolean
  97. */
  98. var $is_deleted = 0;
  99. /**
  100. * Message \flagged status
  101. * @var boolean
  102. */
  103. var $is_flagged = 0;
  104. /**
  105. * Message mdn status
  106. * @var boolean
  107. */
  108. var $is_mdnsent = 0;
  109. /**
  110. * Message text body
  111. * @var string
  112. */
  113. var $body_part = '';
  114. /**
  115. * Message part offset
  116. * for fetching body parts out of raw messages
  117. * @var integer
  118. */
  119. var $offset = 0;
  120. /**
  121. * Message part length
  122. * for fetching body parts out of raw messages
  123. * @var integer
  124. */
  125. var $length = 0;
  126. /**
  127. * Local attachment filename location where the tempory attachment is
  128. * stored. For use in delivery class.
  129. * @var string
  130. */
  131. var $att_local_name = '';
  133. /**
  134. * @param string $ent entity id
  135. */
  136. function setEnt ($ent) {
  137. $this->entity_id= $ent;
  138. }
  140. /**
  141. * Add nested message part
  142. * @param object $msg
  143. */
  144. function addEntity ($msg) {
  145. $this->entities [] = $msg;
  146. }
  148. /**
  149. * Get file name used for mime part
  150. * @return string file name
  151. * @since 1.3.2
  152. */
  153. function getFilename () {
  154. $filename = '';
  155. $header = $this->header;
  156. if (is_object ($header->disposition)) {
  157. $filename = $header->disposition->getProperty('filename');
  158. if (trim ($filename) == '') {
  159. $name = decodeHeader ($header->disposition->getProperty('name'));
  160. if (!trim ($name)) {
  161. $name = $header->getParameter('name');
  162. if(!trim ($name)) {
  163. if (!trim ( $header->id )) {
  164. $filename = 'untitled-[' . $this->entity_id . ']' . '.' . strtolower ($header->type1);
  165. } else {
  166. $filename = 'cid: ' . $header->id . '.' . strtolower ($header->type1);
  167. }
  168. } else {
  169. $filename = $name;
  170. }
  171. } else {
  172. $filename = $name;
  173. }
  174. }
  175. } else {
  176. $filename = $header->getParameter('filename');
  177. if (!trim ($filename)) {
  178. $filename = $header->getParameter('name');
  179. if (!trim ($filename)) {
  180. if (!trim ( $header->id )) {
  181. $filename = 'untitled-[' . $this->entity_id . ']' . '.' . strtolower ($header->type1);
  182. } else {
  183. $filename = 'cid: ' . $header->id . '.' . strtolower ($header->type1);
  184. }
  185. }
  186. }
  187. }
  188. return $filename;
  189. }
  191. /**
  192. * Add header object to message object.
  193. * WARNING: Unfinished code. Don't expect it to work in older sm versions.
  194. * @param mixed $read array or string with message headers
  195. * @todo FIXME: rfc822header->parseHeader() does not return rfc822header object
  196. */
  197. function addRFC822Header ($read) {
  198. $header = new Rfc822Header ();
  199. $this->rfc822_header = $header->parseHeader($read);
  200. }
  202. /**
  203. * @param string $ent
  204. * @return mixed (object or string?)
  205. */
  206. function getEntity ($ent) {
  207. $cur_ent = $this->entity_id ;
  208. $msg = $this;
  209. if (($cur_ent == '') || ($cur_ent == '0')) {
  210. $cur_ent_a = array();
  211. } else {
  212. $cur_ent_a = explode ('.', $this->entity_id );
  213. }
  214. $ent_a = explode ('.', $ent);
  216. for ($i = 0,$entCount = count ($ent_a) - 1; $i < $entCount; ++$i) {
  217. if (isset($cur_ent_a[$i]) && ($cur_ent_a[$i] != $ent_a[$i])) {
  218. $msg = $msg->parent;
  219. $cur_ent_a = explode ('.', $msg->entity_id);
  220. --$i;
  221. } else if (!isset($cur_ent_a[$i])) {
  222. if (isset($msg->entities[($ent_a[$i]-1)])) {
  223. $msg = $msg->entities[($ent_a[$i]-1)];
  224. } else {
  225. $msg = $msg->entities[0];
  226. }
  227. }
  228. if (($msg->type0 == 'message') && ($msg->type1 == 'rfc822')) {
  229. /*this is a header for a message/rfc822 entity */
  230. $msg = $msg->entities[0];
  231. }
  232. }
  234. if (($msg->type0 == 'message') && ($msg->type1 == 'rfc822')) {
  235. /*this is a header for a message/rfc822 entity */
  236. $msg = $msg->entities[0];
  237. }
  239. if (isset($msg->entities[($ent_a[$entCount])-1])) {
  240. if (is_object ($msg->entities[($ent_a[$entCount])-1])) {
  241. $msg = $msg->entities[($ent_a[$entCount]-1)];
  242. }
  243. }
  245. return $msg;
  246. }
  248. /**
  249. * Set message body
  250. * @param string $s message body
  251. */
  252. function setBody ($s) {
  253. $this->body_part = $s;
  254. }
  256. /**
  257. * Clean message object
  258. */
  259. function clean_up () {
  260. $msg = $this;
  261. $msg->body_part = '';
  263. foreach ($msg->entities as $m) {
  264. $m->clean_up();
  265. }
  266. }
  268. /**
  269. * @return string
  270. */
  271. function getMailbox () {
  272. $msg = $this;
  273. while (is_object ($msg->parent)) {
  274. $msg = $msg->parent;
  275. }
  276. return $msg->mailbox;
  277. }
  279. /*
  280. * Bodystructure parser, a recursive function for generating the
  281. * entity-tree with all the mime-parts.
  282. *
  283. * It follows RFC2060 and stores all the described fields in the
  284. * message object.
  285. *
  286. * Question/Bugs:
  287. *
  288. * Ask for me (Marc Groot Koerkamp, [email protected])
  289. * @param string $read
  290. * @param integer $i
  291. * @param mixed $sub_msg
  292. * @return object Message object
  293. * @todo define argument and return types
  294. */
  295. static function parseStructure ($read, &$i, $sub_msg = '') {
  296. $msg = Message ::parseBodyStructure ($read, $i, $sub_msg);
  297. if($msg) $msg->setEntIds($msg,false,0);
  298. return $msg;
  299. }
  301. /**
  302. * @param object $msg
  303. * @param mixed $init
  304. * @param integer $i
  305. * @todo document me
  306. * @since 1.4.0
  307. */
  308. function setEntIds (&$msg,$init=false,$i=0) {
  309. $iCnt = count ($msg->entities);
  310. if ($init !==false) {
  311. $iEntSub = $i+1;
  312. if ($msg->parent->type0 == 'message' &&
  313. $msg->parent->type1 == 'rfc822' &&
  314. $msg->type0 == 'multipart') {
  315. $iEntSub = '0';
  316. }
  317. if ($init) {
  318. $msg->entity_id = "$init.$iEntSub";
  319. } else {
  320. $msg->entity_id = $iEntSub;
  321. }
  322. } else if ($iCnt) {
  323. $msg->entity_id='0';
  324. } else {
  325. $msg->entity_id='1';
  326. }
  327. for ($i=0;$i<$iCnt;++$i) {
  328. $msg->entities[$i]->parent =& $msg;
  329. if (strrchr ($msg->entity_id, '.') != '.0') {
  330. $msg->entities[$i]->setEntIds($msg->entities[$i],$msg->entity_id,$i);
  331. } else {
  332. $msg->entities[$i]->setEntIds($msg->entities[$i],$msg->parent->entity_id,$i);
  333. }
  334. }
  335. }
  337. /**
  338. * @param string $read
  339. * @param integer $i
  340. * @param mixed $sub_msg
  341. * @return object Message object
  342. * @todo document me
  343. * @since 1.4.0 (code was part of parseStructure() in 1.3.x)
  344. */
  345. static function parseBodyStructure ($read, &$i, $sub_msg = '') {
  346. $arg_no = 0;
  347. $arg_a = array();
  348. if ($sub_msg) {
  349. $message = $sub_msg;
  350. } else {
  351. $message = new Message ();
  352. }
  354. for ($cnt = strlen ($read); $i < $cnt; ++$i) {
  355. $char = strtoupper ($read{$i});
  356. switch ($char) {
  357. case '(':
  358. switch($arg_no) {
  359. case 0:
  360. if (!isset($msg)) {
  361. $msg = new Message ();
  362. $hdr = new MessageHeader ();
  363. $hdr->type0 = 'text';
  364. $hdr->type1 = 'plain';
  365. $hdr->encoding = '7bit';
  366. $msg->header = $hdr;
  367. } else {
  368. $msg->header->type0 = 'multipart';
  369. $msg->type0 = 'multipart';
  370. while ($read{$i} == '(') {
  371. $msg->addEntity($msg->parseBodyStructure($read, $i, $msg));
  372. }
  373. }
  374. break;
  375. case 1:
  376. /* multipart properties */
  377. ++$i;
  378. $arg_a[] = $msg->parseProperties($read, $i);
  379. ++$arg_no;
  380. break;
  381. case 2:
  382. if (isset($msg->type0) && ($msg->type0 == 'multipart')) {
  383. ++$i;
  384. $arg_a[] = $msg->parseDisposition($read, $i);
  385. } else { /* properties */
  386. $arg_a[] = $msg->parseProperties($read, $i);
  387. }
  388. ++$arg_no;
  389. break;
  390. case 3:
  391. if (isset($msg->type0) && ($msg->type0 == 'multipart')) {
  392. ++$i;
  393. $arg_a[]= $msg->parseLanguage($read, $i);
  394. }
  395. case 7:
  396. if (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822')) {
  397. $msg->header->type0 = $arg_a[0];
  398. $msg->header->type1 = $arg_a[1];
  399. $msg->type0 = $arg_a[0];
  400. $msg->type1 = $arg_a[1];
  401. $rfc822_hdr = new Rfc822Header ();
  402. $msg->rfc822_header = $msg->parseEnvelope($read, $i, $rfc822_hdr);
  403. while (($i < $cnt) && ($read{$i} != '(')) {
  404. ++$i;
  405. }
  406. $msg->addEntity($msg->parseBodyStructure($read, $i,$msg));
  407. }
  408. break;
  409. case 8:
  410. ++$i;
  411. $arg_a[] = $msg->parseDisposition($read, $i);
  412. ++$arg_no;
  413. break;
  414. case 9:
  415. ++$i;
  416. if (($arg_a[0] == 'text') || (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822'))) {
  417. $arg_a[] = $msg->parseDisposition($read, $i);
  418. } else {
  419. $arg_a[] = $msg->parseLanguage($read, $i);
  420. }
  421. ++$arg_no;
  422. break;
  423. case 10:
  424. if (($arg_a[0] == 'text') || (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822'))) {
  425. ++$i;
  426. $arg_a[] = $msg->parseLanguage($read, $i);
  427. } else {
  428. $i = $msg->parseParenthesis($read, $i);
  429. $arg_a[] = ''; /* not yet described in rfc2060 */
  430. }
  431. ++$arg_no;
  432. break;
  433. default:
  434. /* unknown argument, skip this part */
  435. $i = $msg->parseParenthesis($read, $i);
  436. $arg_a[] = '';
  437. ++$arg_no;
  438. break;
  439. } /* switch */
  440. break;
  441. case '"':
  442. /* inside an entity -> start processing */
  443. $arg_s = $msg->parseQuote($read, $i);
  444. ++$arg_no;
  445. if ($arg_no < 3) {
  446. $arg_s = strtolower ($arg_s); /* type0 and type1 */
  447. }
  448. $arg_a[] = $arg_s;
  449. break;
  450. case 'n':
  451. case 'N':
  452. /* probably NIL argument */
  453. $tmpnil = strtoupper (substr ($read, $i, 4));
  454. if ($tmpnil == 'NIL ' || $tmpnil == 'NIL)') {
  455. $arg_a[] = '';
  456. ++$arg_no;
  457. $i += 2;
  458. }
  459. break;
  460. case '{':
  461. /* process the literal value */
  462. $arg_a[] = $msg->parseLiteral($read, $i);
  463. ++$arg_no;
  464. break;
  465. case '0':
  466. case is_numeric ($read{$i}):
  467. /* process integers */
  468. if ($read{$i} == ' ') { break; }
  469. ++$arg_no;
  470. if (preg_match ('/^([0-9]+).*/',substr ($read,$i), $regs)) {
  471. $i += strlen ($regs[1])-1;
  472. $arg_a[] = $regs[1];
  473. } else {
  474. $arg_a[] = 0;
  475. }
  476. break;
  477. case ')':
  478. $multipart = (isset($msg->type0) && ($msg->type0 == 'multipart'));
  479. if (!$multipart) {
  480. $shifted_args = (($arg_a[0] == 'text') || (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822')));
  481. $hdr->type0 = $arg_a[0];
  482. $hdr->type1 = $arg_a[1];
  484. $msg->type0 = $arg_a[0];
  485. $msg->type1 = $arg_a[1];
  486. $arr = $arg_a[2];
  487. if (is_array ($arr)) {
  488. $hdr->parameters = $arg_a[2];
  489. }
  490. $hdr->id = str_replace ('<', '', str_replace ('>', '', $arg_a[3]));
  491. $hdr->description = $arg_a[4];
  492. $hdr->encoding = strtolower ($arg_a[5]);
  493. $hdr->entity_id = $msg->entity_id;
  494. $hdr->size = $arg_a[6];
  495. if ($shifted_args) {
  496. $hdr->lines = $arg_a[7];
  497. $s = 1;
  498. } else {
  499. $s = 0;
  500. }
  501. $hdr->md5 = (isset($arg_a[7+$s]) ? $arg_a[7+$s] : $hdr->md5);
  502. $hdr->disposition = (isset($arg_a[8+$s]) ? $arg_a[8+$s] : $hdr->disposition);
  503. $hdr->language = (isset($arg_a[9+$s]) ? $arg_a[9+$s] : $hdr->language);
  504. $msg->header = $hdr;
  505. } else {
  506. $hdr->type0 = 'multipart';
  507. $hdr->type1 = $arg_a[0];
  508. $msg->type0 = 'multipart';
  509. $msg->type1 = $arg_a[0];
  510. $hdr->parameters = (isset($arg_a[1]) ? $arg_a[1] : $hdr->parameters);
  511. $hdr->disposition = (isset($arg_a[2]) ? $arg_a[2] : $hdr->disposition);
  512. $hdr->language = (isset($arg_a[3]) ? $arg_a[3] : $hdr->language);
  513. $msg->header = $hdr;
  514. }
  515. return $msg;
  516. default: break;
  517. } /* switch */
  518. } /* for */
  519. } /* parsestructure */
  521. /**
  522. * @param string $read
  523. * @param integer $i
  524. * @return array
  525. */
  526. function parseProperties ($read, &$i) {
  527. $properties = array();
  528. $prop_name = '';
  530. for (; $read{$i} != ')'; ++$i) {
  531. $arg_s = '';
  532. if ($read{$i} == '"') {
  533. $arg_s = $this->parseQuote ($read, $i);
  534. } else if ($read{$i} == '{') {
  535. $arg_s = $this->parseLiteral ($read, $i);
  536. }
  538. if ($arg_s != '') {
  539. if ($prop_name == '') {
  540. $prop_name = strtolower ($arg_s);
  541. $properties[$prop_name] = '';
  542. } else if ($prop_name != '') {
  543. $properties[$prop_name] = $arg_s;
  544. $prop_name = '';
  545. }
  546. }
  547. }
  548. return $properties;
  549. }
  551. /**
  552. * @param string $read
  553. * @param integer $i
  554. * @param object $hdr MessageHeader object
  555. * @return object MessageHeader object
  556. */
  557. function parseEnvelope ($read, &$i, $hdr) {
  558. $arg_no = 0;
  559. $arg_a = array();
  560. ++$i;
  561. for ($cnt = strlen ($read); ($i < $cnt) && ($read{$i} != ')'); ++$i) {
  562. $char = strtoupper ($read{$i});
  563. switch ($char) {
  564. case '"':
  565. $arg_a[] = $this->parseQuote ($read, $i);
  566. ++$arg_no;
  567. break;
  568. case '{':
  569. $arg_a[] = $this->parseLiteral ($read, $i);
  570. /* temp bugfix (SM 1.5 will have a working clean version)
  571. too much work to implement that version right now */
  572. // --$i;
  573. ++$arg_no;
  574. break;
  575. case 'N':
  576. /* probably NIL argument */
  577. if (strtoupper (substr ($read, $i, 3)) == 'NIL') {
  578. $arg_a[] = '';
  579. ++$arg_no;
  580. $i += 2;
  581. }
  582. break;
  583. case '(':
  584. /* Address structure (with group support)
  585. * Note: Group support is useless on SMTP connections
  586. * because the protocol doesn't support it
  587. */
  588. $addr_a = array();
  589. $group = '';
  590. $a=0;
  591. for (; $i < $cnt && $read{$i} != ')'; ++$i) {
  592. if ($read{$i} == '(') {
  593. $addr = $this->parseAddress ($read, $i);
  594. if (($addr->host == '') && ($addr->mailbox != '')) {
  595. /* start of group */
  596. $group = $addr->mailbox;
  597. $group_addr = $addr;
  598. $j = $a;
  599. } else if ($group && ($addr->host == '') && ($addr->mailbox == '')) {
  600. /* end group */
  601. if ($a == ($j+1)) { /* no group members */
  602. $group_addr->group = $group;
  603. $group_addr->mailbox = '';
  604. $group_addr->personal = "$group: Undisclosed recipients;";
  605. $addr_a[] = $group_addr;
  606. $group ='';
  607. }
  608. } else {
  609. $addr->group = $group;
  610. $addr_a[] = $addr;
  611. }
  612. ++$a;
  613. }
  614. }
  615. $arg_a[] = $addr_a;
  616. break;
  617. default: break;
  618. }
  619. }
  621. if (count ($arg_a) > 9) {
  622. $d = strtr ($arg_a[0], array(' ' => ' '));
  623. $d_parts = explode (' ', $d);
  624. if (!$arg_a[1]) $arg_a[1] = _ ("(no subject)");
  626. $hdr->date = getTimeStamp ($d_parts); /* argument 1: date */
  627. $hdr->date_unparsed = strtr ($d,'<>',' '); /* original date */
  628. $hdr->subject = $arg_a[1]; /* argument 2: subject */
  629. $hdr->from = is_array ($arg_a[2]) ? $arg_a[2][0] : ''; /* argument 3: from */
  630. $hdr->sender = is_array ($arg_a[3]) ? $arg_a[3][0] : ''; /* argument 4: sender */
  631. $hdr->reply_to = is_array ($arg_a[4]) ? $arg_a[4][0] : ''; /* argument 5: reply-to */
  632. $hdr->to = $arg_a[5]; /* argument 6: to */
  633. $hdr->cc = $arg_a[6]; /* argument 7: cc */
  634. $hdr->bcc = $arg_a[7]; /* argument 8: bcc */
  635. $hdr->in_reply_to = $arg_a[8]; /* argument 9: in-reply-to */
  636. $hdr->message_id = $arg_a[9]; /* argument 10: message-id */
  637. }
  638. return $hdr;
  639. }
  641. /**
  642. * @param string $read
  643. * @param integer $i
  644. * @return string
  645. * @todo document me
  646. */
  647. function parseLiteral ($read, &$i) {
  648. $lit_cnt = '';
  649. ++$i;
  650. $iPos = strpos ($read,'}',$i);
  651. if ($iPos) {
  652. $lit_cnt = substr ($read, $i, $iPos - $i);
  653. $i += strlen ($lit_cnt) + 3; /* skip } + \r + \n */
  654. /* Now read the literal */
  655. $s = ($lit_cnt ? substr ($read,$i,$lit_cnt): '');
  656. $i += $lit_cnt;
  657. /* temp bugfix (SM 1.5 will have a working clean version)
  658. too much work to implement that version right now */
  659. --$i;
  660. } else { /* should never happen */
  661. $i += 3; /* } + \r + \n */
  662. $s = '';
  663. }
  664. return $s;
  665. }
  667. /**
  668. * function parseQuote
  669. *
  670. * This extract the string value from a quoted string. After the end-quote
  671. * character is found it returns the string. The offset $i when calling
  672. * this function points to the first double quote. At the end it points to
  673. * The ending quote. This function takes care of escaped double quotes.
  674. * "some \"string\""
  675. * ^ ^
  676. * initial $i end position $i
  677. *
  678. * @param string $read
  679. * @param integer $i offset in $read
  680. * @return string string inbetween the double quotes
  681. * @author Marc Groot Koerkamp
  682. */
  683. function parseQuote ($read, &$i) {
  684. $s = '';
  685. $iPos = ++$i;
  686. $iPosStart = $iPos;
  687. while (true) {
  688. $iPos = strpos ($read,'"',$iPos);
  689. if (!$iPos) break;
  690. if ($iPos && $read{$iPos -1} != '\\') {
  691. $s = substr ($read,$i,($iPos-$i));
  692. $i = $iPos;
  693. break;
  694. } else if ($iPos > 1 && $read{$iPos -1} == '\\' && $read{$iPos-2} == '\\') {
  695. // This is an unique situation where the fast detection of the string
  696. // fails. If the quote string ends with \\ then we need to iterate
  697. // through the entire string to make sure we detect the unexcaped
  698. // double quotes correctly.
  699. $s = '';
  700. $bEscaped = false;
  701. $k = 0;
  702. for ($j=$iPosStart,$iCnt=strlen ($read);$j<$iCnt;++$j) {
  703. $cChar = $read{$j};
  704. switch ($cChar) {
  705. case '\\':
  706. $bEscaped = !$bEscaped;
  707. $s .= $cChar;
  708. break;
  709. case '"':
  710. if ($bEscaped) {
  711. $s .= $cChar;
  712. $bEscaped = false;
  713. } else {
  714. $i = $j;
  715. break 3;
  716. }
  717. break;
  718. default:
  719. if ($bEscaped) {
  720. $bEscaped = false;
  721. }
  722. $s .= $cChar;
  723. break;
  724. }
  725. }
  726. }
  727. ++$iPos;
  728. if ($iPos > strlen ($read)) {
  729. break;
  730. }
  731. }
  732. return $s;
  733. }
  735. /**
  736. * @param string $read
  737. * @param integer $i
  738. * @return object AddressStructure object
  739. */
  740. function parseAddress ($read, &$i) {
  741. $arg_a = array();
  742. for (; $read{$i} != ')'; ++$i) {
  743. $char = strtoupper ($read{$i});
  744. switch ($char) {
  745. case '"': $arg_a[] = $this->parseQuote ($read, $i); break;
  746. case '{': $arg_a[] = $this->parseLiteral ($read, $i); break;
  747. case 'n':
  748. case 'N':
  749. if (strtoupper (substr ($read, $i, 3)) == 'NIL') {
  750. $arg_a[] = '';
  751. $i += 2;
  752. }
  753. break;
  754. default: break;
  755. }
  756. }
  758. if (count ($arg_a) == 4) {
  759. $adr = new AddressStructure ();
  760. $adr->personal = $arg_a[0];
  761. $adr->adl = $arg_a[1];
  762. $adr->mailbox = $arg_a[2];
  763. $adr->host = $arg_a[3];
  764. } else {
  765. $adr = '';
  766. }
  767. return $adr;
  768. }
  770. /**
  771. * @param string $read
  772. * @param integer $i
  773. * @param object Disposition object or empty string
  774. */
  775. function parseDisposition ($read, &$i) {
  776. $arg_a = array();
  777. for (; $read{$i} != ')'; ++$i) {
  778. switch ($read{$i}) {
  779. case '"': $arg_a[] = $this->parseQuote ($read, $i); break;
  780. case '{': $arg_a[] = $this->parseLiteral ($read, $i); break;
  781. case '(': $arg_a[] = $this->parseProperties ($read, $i); break;
  782. default: break;
  783. }
  784. }
  786. if (isset($arg_a[0])) {
  787. $disp = new Disposition ($arg_a[0]);
  788. if (isset($arg_a[1])) {
  789. $disp->properties = $arg_a[1];
  790. }
  791. }
  792. return (is_object ($disp) ? $disp : '');
  793. }
  795. /**
  796. * @param string $read
  797. * @param integer $i
  798. * @return object Language object or empty string
  799. */
  800. function parseLanguage ($read, &$i) {
  801. /* no idea how to process this one without examples */
  802. $arg_a = array();
  804. for (; $read{$i} != ')'; ++$i) {
  805. switch ($read{$i}) {
  806. case '"': $arg_a[] = $this->parseQuote ($read, $i); break;
  807. case '{': $arg_a[] = $this->parseLiteral ($read, $i); break;
  808. case '(': $arg_a[] = $this->parseProperties ($read, $i); break;
  809. default: break;
  810. }
  811. }
  813. if (isset($arg_a[0])) {
  814. $lang = new Language ($arg_a[0]);
  815. if (isset($arg_a[1])) {
  816. $lang->properties = $arg_a[1];
  817. }
  818. }
  819. return (is_object ($lang) ? $lang : '');
  820. }
  822. /**
  823. * Parse message text enclosed in parenthesis
  824. * @param string $read
  825. * @param integer $i
  826. * @return integer
  827. */
  828. function parseParenthesis ($read, $i) {
  829. for ($i++; $read{$i} != ')'; ++$i) {
  830. switch ($read{$i}) {
  831. case '"': $this->parseQuote ($read, $i); break;
  832. case '{': $this->parseLiteral ($read, $i); break;
  833. case '(': $this->parseProperties ($read, $i); break;
  834. default: break;
  835. }
  836. }
  837. return $i;
  838. }
  840. /**
  841. * Function to fill the message structure in case the
  842. * bodystructure is not available
  843. * NOT FINISHED YET
  844. * @param string $read
  845. * @param string $type0 message part type
  846. * @param string $type1 message part subtype
  847. * @return string (only when type0 is not message or multipart)
  848. */
  849. function parseMessage ($read, $type0, $type1) {
  850. switch ($type0) {
  851. case 'message':
  852. $rfc822_header = true;
  853. $mime_header = false;
  854. break;
  855. case 'multipart':
  856. $rfc822_header = false;
  857. $mime_header = true;
  858. break;
  859. default: return $read;
  860. }
  862. for ($i = 1; $i < $count; ++$i) {
  863. $line = trim ($body[$i]);
  864. if (($mime_header || $rfc822_header) &&
  865. (preg_match ("/^.*boundary=\"?(.+(?=\")|.+).*/i", $line, $reg))) {
  866. $bnd = $reg[1];
  867. $bndreg = $bnd;
  868. $bndreg = str_replace ("\\", "\\\\", $bndreg);
  869. $bndreg = str_replace ("?", "\\?", $bndreg);
  870. $bndreg = str_replace ("+", "\\+", $bndreg);
  871. $bndreg = str_replace (".", "\\.", $bndreg);
  872. $bndreg = str_replace ("/", "\\/", $bndreg);
  873. $bndreg = str_replace ("-", "\\-", $bndreg);
  874. $bndreg = str_replace ("(", "\\(", $bndreg);
  875. $bndreg = str_replace (")", "\\)", $bndreg);
  876. } else if ($rfc822_header && $line == '') {
  877. $rfc822_header = false;
  878. if ($msg->type0 == 'multipart') {
  879. $mime_header = true;
  880. }
  881. }
  883. if ((($line{0} == '-') || $rfc822_header) && isset($boundaries[0])) {
  884. $cnt = count ($boundaries)-1;
  885. $bnd = $boundaries[$cnt]['bnd'];
  886. $bndreg = $boundaries[$cnt]['bndreg'];
  888. $regstr = '/^--'."($bndreg)".".*".'/';
  889. if (preg_match ($regstr, $line, $reg)) {
  890. $bndlen = strlen ($reg[1]);
  891. $bndend = false;
  892. if (strlen ($line) > ($bndlen + 3)) {
  893. if (($line{$bndlen+2} == '-') && ($line{$bndlen+3} == '-')) {
  894. $bndend = true;
  895. }
  896. }
  897. if ($bndend) {
  898. /* calc offset and return $msg */
  899. //$entStr = CalcEntity("$entStr", -1);
  900. array_pop ($boundaries);
  901. $mime_header = true;
  902. $bnd_end = true;
  903. } else {
  904. $mime_header = true;
  905. $bnd_end = false;
  906. //$entStr = CalcEntity("$entStr", 0);
  907. ++$content_indx;
  908. }
  909. } else {
  910. if ($header) { }
  911. }
  912. }
  913. }
  914. }
  916. /**
  917. * @param array $entity
  918. * @param array $alt_order
  919. * @param boolean $strict
  920. * @return array
  921. */
  922. function findDisplayEntity ($entity = array(), $alt_order = array('text/plain', 'text/html'), $strict=false) {
  923. $found = false;
  924. if ($this->type0 == 'multipart') {
  925. if($this->type1 == 'alternative') {
  926. $msg = $this->findAlternativeEntity ($alt_order);
  927. if ( ! is_null ($msg) ) {
  928. if (count ($msg->entities) == 0) {
  929. $entity[] = $msg->entity_id;
  930. } else {
  931. $entity = $msg->findDisplayEntity($entity, $alt_order, $strict);
  932. }
  933. $found = true;
  934. }
  935. } else if ($this->type1 == 'related') { /* RFC 2387 */
  936. $msgs = $this->findRelatedEntity ();
  937. foreach ($msgs as $msg) {
  938. if (count ($msg->entities) == 0) {
  939. $entity[] = $msg->entity_id;
  940. } else {
  941. $entity = $msg->findDisplayEntity($entity, $alt_order, $strict);
  942. }
  943. }
  944. if (count ($msgs) > 0) {
  945. $found = true;
  946. }
  947. } else { /* Treat as multipart/mixed */
  948. foreach ($this->entities as $ent) {
  949. if(!(is_object ($ent->header->disposition) && strtolower ($ent->header->disposition->name) == 'attachment') &&
  950. (!isset($ent->header->parameters['filename'])) &&
  951. (!isset($ent->header->parameters['name'])) &&
  952. (($ent->type0 != 'message') && ($ent->type1 != 'rfc822'))) {
  953. $entity = $ent->findDisplayEntity($entity, $alt_order, $strict);
  954. $found = true;
  955. }
  956. }
  957. }
  958. } else { /* If not multipart, then just compare with each entry from $alt_order */
  959. $type = $this->type0.'/'.$this->type1 ;
  960. // $alt_order[] = "message/rfc822";
  961. foreach ($alt_order as $alt) {
  962. if( ($alt == $type) && isset($this->entity_id ) ) {
  963. if ((count ($this->entities ) == 0) &&
  964. (!isset($this->header->parameters['filename'])) &&
  965. (!isset($this->header->parameters['name'])) &&
  966. (isset($this->header->disposition) && is_object ($this->header->disposition) &&
  967. strtolower ($this->header->disposition->name) != 'attachment')) {
  968. $entity[] = $this->entity_id ;
  969. $found = true;
  970. }
  971. }
  972. }
  973. }
  974. if(!$found) {
  975. foreach ($this->entities as $ent) {
  976. if(!(is_object ($ent->header->disposition) && strtolower ($ent->header->disposition->name) == 'attachment') &&
  977. (($ent->type0 != 'message') && ($ent->type1 != 'rfc822'))) {
  978. $entity = $ent->findDisplayEntity($entity, $alt_order, $strict);
  979. $found = true;
  980. }
  981. }
  982. }
  983. if(!$strict && !$found) {
  984. if (($this->type0 == 'text') &&
  985. in_array ($this->type1 , array('plain', 'html', 'message')) &&
  986. isset($this->entity_id )) {
  987. if (count ($this->entities ) == 0) {
  988. if (!is_object ($this->header->disposition) || strtolower ($this->header->disposition->name) != 'attachment') {
  989. $entity[] = $this->entity_id ;
  990. }
  991. }
  992. }
  993. }
  994. return $entity;
  995. }
  997. /**
  998. * @param array $alt_order
  999. * @return entity
  1000. */
  1001. function findAlternativeEntity ($alt_order) {
  1002. /* If we are dealing with alternative parts then we */
  1003. /* choose the best viewable message supported by SM. */
  1004. $best_view = 0;
  1005. $entity = null;
  1006. foreach($this->entities as $ent) {
  1007. $type = $ent->header->type0 . '/' . $ent->header->type1;
  1008. if ($type == 'multipart/related') {
  1009. $type = $ent->header->getParameter('type');
  1010. // Mozilla bug. Mozilla does not provide the parameter type.
  1011. if (!$type) $type = 'text/html';
  1012. }
  1013. $altCount = count ($alt_order);
  1014. for ($j = $best_view; $j < $altCount; ++$j) {
  1015. if (($alt_order[$j] == $type) && ($j >= $best_view)) {
  1016. $best_view = $j;
  1017. $entity = $ent;
  1018. }
  1019. }
  1020. }
  1021. return $entity;
  1022. }
  1024. /**
  1025. * @return array
  1026. */
  1027. function findRelatedEntity () {
  1028. $msgs = array();
  1029. $related_type = $this->header->getParameter('type');
  1030. // Mozilla bug. Mozilla does not provide the parameter type.
  1031. if (!$related_type) $related_type = 'text/html';
  1032. $entCount = count ($this->entities );
  1033. for ($i = 0; $i < $entCount; ++$i) {
  1034. $type = $this->entities [$i]->header->type0.'/'.$this->entities [$i]->header->type1;
  1035. if ($related_type == $type) {
  1036. $msgs[] = $this->entities [$i];
  1037. }
  1038. }
  1039. return $msgs;
  1040. }
  1042. /**
  1043. * @param array $exclude_id
  1044. * @param array $result
  1045. * @return array
  1046. */
  1047. function getAttachments ($exclude_id=array(), $result = array()) {
  1048. /*
  1049. if (($this->type0 == 'message') &&
  1050. ($this->type1 == 'rfc822') &&
  1051. ($this->entity_id) ) {
  1052. $this = $this->entities[0];
  1053. }
  1054. */
  1055. if (count ($this->entities )) {
  1056. foreach ($this->entities as $entity) {
  1057. $exclude = false;
  1058. foreach ($exclude_id as $excl) {
  1059. if ($entity->entity_id === $excl) {
  1060. $exclude = true;
  1061. }
  1062. }
  1064. if (!$exclude) {
  1065. if ($entity->type0 == 'multipart') {
  1066. $result = $entity->getAttachments($exclude_id, $result);
  1067. } else if ($entity->type0 != 'multipart') {
  1068. $result[] = $entity;
  1069. }
  1070. }
  1071. }
  1072. } else {
  1073. $exclude = false;
  1074. foreach ($exclude_id as $excl) {
  1075. $exclude = $exclude || ($this->entity_id == $excl);
  1076. }
  1078. if (!$exclude) {
  1079. $result[] = $this;
  1080. }
  1081. }
  1082. return $result;
  1083. }
  1085. /**
  1086. * Add attachment to message object
  1087. * @param string $type attachment type
  1088. * @param string $name attachment name
  1089. * @param string $location path to attachment
  1090. */
  1091. function initAttachment ($type, $name, $location) {
  1092. $attachment = new Message ();
  1093. $mime_header = new MessageHeader ();
  1094. $mime_header->setParameter('name', $name);
  1095. $pos = strpos ($type, '/');
  1096. if ($pos > 0) {
  1097. $mime_header->type0 = substr ($type, 0, $pos);
  1098. $mime_header->type1 = substr ($type, $pos+1);
  1099. } else {
  1100. $mime_header->type0 = $type;
  1101. }
  1102. $attachment->att_local_name = $location;
  1103. $disposition = new Disposition ('attachment');
  1104. $disposition->properties['filename'] = $name;
  1105. $mime_header->disposition = $disposition;
  1106. $attachment->mime_header = $mime_header;
  1107. $this->entities []=$attachment;
  1108. }
  1110. /**
  1111. * Delete all attachments from this object from disk.
  1112. * @since 1.4.6
  1113. */
  1114. function purgeAttachments () {
  1115. if ($this->att_local_name ) {
  1116. global $username, $attachment_dir ;
  1117. $hashed_attachment_dir = getHashedDir ($username, $attachment_dir);
  1118. if ( file_exists ($hashed_attachment_dir . '/' . $this->att_local_name ) ) {
  1119. unlink ($hashed_attachment_dir . '/' . $this->att_local_name );
  1120. }
  1121. }
  1122. // recursively delete attachments from entities contained in this object
  1123. for ($i=0, $entCount=count ($this->entities );$i< $entCount; ++$i) {
  1124. $this->entities [$i]->purgeAttachments();
  1125. }
  1126. }
  1127. }

Documentation generated on 2020年1月13日 04:24:56 +0100 by phpDocumentor 1.4.3

AltStyle によって変換されたページ (->オリジナル) /