Operations::copyAttachments()   D
last analyzed

Complexity

Conditions 23
Paths 113

Size

Total Lines 115
Code Lines 56

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 23
eloc 56
nc 113
nop 5
dl 0
loc 115
rs 4.0583
c 0
b 0
f 0

How to fix   Long Method    Complexity   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1
<?php
2
3
/**
4
 * General operations.
5
 *
6
 * All mapi operations, like create, change and delete, are set in this class.
7
 * A module calls one of these methods.
8
 *
9
 * Note: All entryids in this class are binary
10
 *
11
 * @todo This class is bloated. It also returns data in various arbitrary formats
12
 * that other functions depend on, making lots of code almost completely unreadable.
13
 */
14
class Operations {
15
	/**
16
	 * Gets the hierarchy list of all required stores.
17
	 *
18
	 * getHierarchyList builds an entire hierarchy list of all folders that should be shown in various places. Most importantly,
19
	 * it generates the list of folders to be show in the hierarchylistmodule (left-hand folder browser) on the client.
20
	 *
21
	 * It is also used to generate smaller hierarchy lists, for example for the 'create folder' dialog.
22
	 *
23
	 * The returned array is a flat array of folders, so if the caller wishes to build a tree, it is up to the caller to correlate
24
	 * the entryids and the parent_entryids of all the folders to build the tree.
25
	 *
26
	 * The return value is an associated array with the following keys:
27
	 * - store: array of stores
28
	 *
29
	 * Each store contains:
30
	 * - array("store_entryid" => entryid of store, name => name of store, subtree => entryid of viewable root, type => default|public|other, folder_type => "all")
31
	 * - folder: array of folders with each an array of properties (see Operations::setFolder() for properties)
32
	 *
33
	 * @param array  $properties   MAPI property mapping for folders
34
	 * @param int    $type         Which stores to fetch (HIERARCHY_GET_ALL | HIERARCHY_GET_DEFAULT | HIERARCHY_GET_ONE)
35
	 * @param object $store        Only when $type == HIERARCHY_GET_ONE
36
	 * @param array  $storeOptions Only when $type == HIERARCHY_GET_ONE, this overrides the  loading options which is normally
37
	 *                             obtained from the settings for loading the store (e.g. only load calendar).
38
	 * @param string $username     The username
39
	 *
40
	 * @return array Return structure
41
	 */
42
	public function getHierarchyList($properties, $type = HIERARCHY_GET_ALL, $store = null, $storeOptions = null, $username = null) {
43
		switch ($type) {
44
			case HIERARCHY_GET_ALL:
45
				$storelist = $GLOBALS["mapisession"]->getAllMessageStores();
46
				break;
47
48
			case HIERARCHY_GET_DEFAULT:
49
				$storelist = [$GLOBALS["mapisession"]->getDefaultMessageStore()];
50
				break;
51
52
			case HIERARCHY_GET_ONE:
53
				// Get single store and it's archive store as well
54
				$storelist = $GLOBALS["mapisession"]->getSingleMessageStores($store, $storeOptions, $username);
55
				break;
56
		}
57
58
		$data = [];
59
		$data["item"] = [];
60
61
		// Get the other store options
62
		if (isset($storeOptions)) {
63
			$otherUsers = $storeOptions;
64
		}
65
		else {
66
			$otherUsers = $GLOBALS["mapisession"]->retrieveOtherUsersFromSettings();
67
		}
68
69
		foreach ($storelist as $store) {
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $storelist does not seem to be defined for all execution paths leading up to this point.
Loading history...
70
			$msgstore_props = mapi_getprops($store, [PR_ENTRYID, PR_DISPLAY_NAME, PR_IPM_SUBTREE_ENTRYID, PR_IPM_OUTBOX_ENTRYID, PR_IPM_SENTMAIL_ENTRYID, PR_IPM_WASTEBASKET_ENTRYID, PR_MDB_PROVIDER, PR_IPM_PUBLIC_FOLDERS_ENTRYID, PR_IPM_FAVORITES_ENTRYID, PR_OBJECT_TYPE, PR_STORE_SUPPORT_MASK, PR_MAILBOX_OWNER_ENTRYID, PR_MAILBOX_OWNER_NAME, PR_USER_ENTRYID, PR_USER_NAME, PR_QUOTA_WARNING_THRESHOLD, PR_QUOTA_SEND_THRESHOLD, PR_QUOTA_RECEIVE_THRESHOLD, PR_MESSAGE_SIZE_EXTENDED, PR_COMMON_VIEWS_ENTRYID, PR_FINDER_ENTRYID]);
71
72
			$inboxProps = [];
73
			$storeType = $msgstore_props[PR_MDB_PROVIDER];
74
75
			/*
76
			 * storetype is public and if public folder is disabled
77
			 * then continue in loop for next store.
78
			 */
79
			if ($storeType == ZARAFA_STORE_PUBLIC_GUID && ENABLE_PUBLIC_FOLDERS === false) {
80
				continue;
81
			}
82
83
			// Obtain the real username for the store when dealing with a shared store
84
			if ($storeType == ZARAFA_STORE_DELEGATE_GUID) {
85
				$storeUserName = $GLOBALS["mapisession"]->getUserNameOfStore($msgstore_props[PR_ENTRYID]);
86
			}
87
			else {
88
				$storeUserName = $msgstore_props[PR_USER_NAME] ?? $GLOBALS["mapisession"]->getUserName();
89
			}
90
91
			$storeData = [
92
				"store_entryid" => bin2hex((string) $msgstore_props[PR_ENTRYID]),
93
				"props" => [
94
					// Showing the store as 'Inbox - Name' is confusing, so we strip the 'Inbox - ' part.
95
					"display_name" => str_replace('Inbox - ', '', $msgstore_props[PR_DISPLAY_NAME]),
96
					"subtree_entryid" => bin2hex((string) $msgstore_props[PR_IPM_SUBTREE_ENTRYID]),
97
					"mdb_provider" => bin2hex((string) $msgstore_props[PR_MDB_PROVIDER]),
98
					"object_type" => $msgstore_props[PR_OBJECT_TYPE],
99
					"store_support_mask" => $msgstore_props[PR_STORE_SUPPORT_MASK],
100
					"user_name" => $storeUserName,
101
					"store_size" => round($msgstore_props[PR_MESSAGE_SIZE_EXTENDED] / 1024),
102
					"quota_warning" => $msgstore_props[PR_QUOTA_WARNING_THRESHOLD] ?? 0,
103
					"quota_soft" => $msgstore_props[PR_QUOTA_SEND_THRESHOLD] ?? 0,
104
					"quota_hard" => $msgstore_props[PR_QUOTA_RECEIVE_THRESHOLD] ?? 0,
105
					"common_view_entryid" => isset($msgstore_props[PR_COMMON_VIEWS_ENTRYID]) ? bin2hex((string) $msgstore_props[PR_COMMON_VIEWS_ENTRYID]) : "",
106
					"finder_entryid" => isset($msgstore_props[PR_FINDER_ENTRYID]) ? bin2hex((string) $msgstore_props[PR_FINDER_ENTRYID]) : "",
107
					"todolist_entryid" => bin2hex(TodoList::getEntryId()),
108
				],
109
			];
110
111
			// these properties doesn't exist in public store
112
			if (isset($msgstore_props[PR_MAILBOX_OWNER_ENTRYID], $msgstore_props[PR_MAILBOX_OWNER_NAME])) {
113
				$storeData["props"]["mailbox_owner_entryid"] = bin2hex((string) $msgstore_props[PR_MAILBOX_OWNER_ENTRYID]);
114
				$storeData["props"]["mailbox_owner_name"] = $msgstore_props[PR_MAILBOX_OWNER_NAME];
115
			}
116
117
			// public store doesn't have inbox
118
			try {
119
				$inbox = mapi_msgstore_getreceivefolder($store);
120
				$inboxProps = mapi_getprops($inbox, [PR_ENTRYID]);
121
			}
122
			catch (MAPIException $e) {
123
				// don't propagate this error to parent handlers, if store doesn't support it
124
				if ($e->getCode() === MAPI_E_NO_SUPPORT) {
125
					$e->setHandled();
126
				}
127
			}
128
129
			$root = mapi_msgstore_openentry($store);
130
			$rootProps = mapi_getprops($root, [PR_IPM_APPOINTMENT_ENTRYID, PR_IPM_CONTACT_ENTRYID, PR_IPM_DRAFTS_ENTRYID, PR_IPM_JOURNAL_ENTRYID, PR_IPM_NOTE_ENTRYID, PR_IPM_TASK_ENTRYID, PR_ADDITIONAL_REN_ENTRYIDS]);
131
132
			$additional_ren_entryids = [];
133
			if (isset($rootProps[PR_ADDITIONAL_REN_ENTRYIDS])) {
134
				$additional_ren_entryids = $rootProps[PR_ADDITIONAL_REN_ENTRYIDS];
135
			}
136
137
			$defaultfolders = [
138
				"default_folder_inbox" => ["inbox" => PR_ENTRYID],
139
				"default_folder_outbox" => ["store" => PR_IPM_OUTBOX_ENTRYID],
140
				"default_folder_sent" => ["store" => PR_IPM_SENTMAIL_ENTRYID],
141
				"default_folder_wastebasket" => ["store" => PR_IPM_WASTEBASKET_ENTRYID],
142
				"default_folder_favorites" => ["store" => PR_IPM_FAVORITES_ENTRYID],
143
				"default_folder_publicfolders" => ["store" => PR_IPM_PUBLIC_FOLDERS_ENTRYID],
144
				"default_folder_calendar" => ["root" => PR_IPM_APPOINTMENT_ENTRYID],
145
				"default_folder_contact" => ["root" => PR_IPM_CONTACT_ENTRYID],
146
				"default_folder_drafts" => ["root" => PR_IPM_DRAFTS_ENTRYID],
147
				"default_folder_journal" => ["root" => PR_IPM_JOURNAL_ENTRYID],
148
				"default_folder_note" => ["root" => PR_IPM_NOTE_ENTRYID],
149
				"default_folder_task" => ["root" => PR_IPM_TASK_ENTRYID],
150
				"default_folder_junk" => ["additional" => 4],
151
				"default_folder_syncissues" => ["additional" => 1],
152
				"default_folder_conflicts" => ["additional" => 0],
153
				"default_folder_localfailures" => ["additional" => 2],
154
				"default_folder_serverfailures" => ["additional" => 3],
155
			];
156
157
			foreach ($defaultfolders as $key => $prop) {
158
				$tag = reset($prop);
159
				$from = key($prop);
160
161
				switch ($from) {
162
					case "inbox":
163
						if (isset($inboxProps[$tag])) {
164
							$storeData["props"][$key] = bin2hex((string) $inboxProps[$tag]);
165
						}
166
						break;
167
168
					case "store":
169
						if (isset($msgstore_props[$tag])) {
170
							$storeData["props"][$key] = bin2hex((string) $msgstore_props[$tag]);
171
						}
172
						break;
173
174
					case "root":
175
						if (isset($rootProps[$tag])) {
176
							$storeData["props"][$key] = bin2hex((string) $rootProps[$tag]);
177
						}
178
						break;
179
180
					case "additional":
181
						if (isset($additional_ren_entryids[$tag])) {
182
							$storeData["props"][$key] = bin2hex((string) $additional_ren_entryids[$tag]);
183
						}
184
						break;
185
				}
186
			}
187
188
			$storeData["folders"] = ["item" => []];
189
190
			if (isset($msgstore_props[PR_IPM_SUBTREE_ENTRYID])) {
191
				$subtreeFolderEntryID = $msgstore_props[PR_IPM_SUBTREE_ENTRYID];
192
193
				$openWholeStore = true;
194
				if ($storeType == ZARAFA_STORE_DELEGATE_GUID) {
195
					$username = strtolower((string) $storeData["props"]["user_name"]);
196
					$sharedFolders = [];
197
198
					// Check whether we should open the whole store or just single folders
199
					if (isset($otherUsers[$username])) {
200
						$sharedFolders = $otherUsers[$username];
201
						if (!isset($otherUsers[$username]['all'])) {
202
							$openWholeStore = false;
203
						}
204
					}
205
206
					// Update the store properties when this function was called to
207
					// only open a particular shared store.
208
					if (is_array($storeOptions)) {
209
						// Update the store properties to mark previously opened
210
						$prevSharedFolders = $GLOBALS["settings"]->get("zarafa/v1/contexts/hierarchy/shared_stores/" . $username, null);
211
						if (!empty($prevSharedFolders)) {
212
							foreach ($prevSharedFolders as $type => $prevSharedFolder) {
213
								// Update the store properties to refer to the shared folder,
214
								// note that we don't care if we have access to the folder or not.
215
								$type = $prevSharedFolder["folder_type"];
216
								if ($type == "all") {
217
									$propname = "subtree_entryid";
218
								}
219
								else {
220
									$propname = "default_folder_" . $prevSharedFolder["folder_type"];
221
								}
222
223
								if (isset($storeData["props"][$propname])) {
224
									$folderEntryID = hex2bin($storeData["props"][$propname]);
225
									$storeData["props"]["shared_folder_" . $prevSharedFolder["folder_type"]] = bin2hex($folderEntryID);
226
								}
227
							}
228
						}
229
					}
230
				}
231
232
				// Get the IPMSUBTREE object
233
				$storeAccess = true;
234
235
				try {
236
					$subtreeFolder = mapi_msgstore_openentry($store, $subtreeFolderEntryID);
237
					// Add root folder
238
					$subtree = $this->setFolder(mapi_getprops($subtreeFolder, $properties));
239
					if (!$openWholeStore) {
240
						$subtree['props']['access'] = 0;
241
					}
242
					array_push($storeData["folders"]["item"], $subtree);
243
				}
244
				catch (MAPIException $e) {
245
					if ($openWholeStore) {
246
						/*
247
						 * if we are going to open whole store and we are not able to open the subtree folder
248
						 * then it should be considered as an error
249
						 * but if we are only opening single folder then it could be possible that we don't have
250
						 * permission to open subtree folder so add a dummy subtree folder in the response and don't consider this as an error
251
						 */
252
						$storeAccess = false;
253
254
						// Add properties to the store response to indicate to the client
255
						// that the store could not be loaded.
256
						$this->invalidateResponseStore($storeData, 'all', $subtreeFolderEntryID);
257
					}
258
					else {
259
						// Add properties to the store response to add a placeholder IPMSubtree.
260
						$this->getDummyIPMSubtreeFolder($storeData, $subtreeFolderEntryID);
261
					}
262
263
					// We've handled the event
264
					$e->setHandled();
265
				}
266
267
				if ($storeAccess) {
268
					// Open the whole store and be done with it
269
					if ($openWholeStore) {
270
						try {
271
							// Update the store properties to refer to the shared folder,
272
							// note that we don't care if we have access to the folder or not.
273
							$storeData["props"]["shared_folder_all"] = bin2hex((string) $subtreeFolderEntryID);
274
							$this->getSubFolders($subtreeFolder, $store, $properties, $storeData);
275
276
							if ($storeType == ZARAFA_SERVICE_GUID) {
277
								// If store type ZARAFA_SERVICE_GUID (own store) then get the
278
								// IPM_COMMON_VIEWS folder and set it to folders array.
279
								$storeData["favorites"] = ["item" => []];
280
								$commonViewFolderEntryid = $msgstore_props[PR_COMMON_VIEWS_ENTRYID];
281
282
								$this->setDefaultFavoritesFolder($commonViewFolderEntryid, $store, $storeData);
283
284
								$commonViewFolder = mapi_msgstore_openentry($store, $commonViewFolderEntryid);
285
								$this->getFavoritesFolders($commonViewFolder, $storeData);
286
287
								$commonViewFolderProps = mapi_getprops($commonViewFolder);
288
								array_push($storeData["folders"]["item"], $this->setFolder($commonViewFolderProps));
289
290
								// Get the To-do list folder and add it to the hierarchy
291
								$todoSearchFolder = todoList::getTodoSearchFolder($store);
292
								if ($todoSearchFolder) {
293
									$todoSearchFolderProps = mapi_getprops($todoSearchFolder);
294
295
									// Change the parent so the folder will be shown in the hierarchy
296
									$todoSearchFolderProps[PR_PARENT_ENTRYID] = $subtreeFolderEntryID;
297
									// Change the display name of the folder
298
									$todoSearchFolderProps[PR_DISPLAY_NAME] = _('To-Do List');
299
									// Never show unread content for the To-do list
300
									$todoSearchFolderProps[PR_CONTENT_UNREAD] = 0;
301
									$todoSearchFolderProps[PR_CONTENT_COUNT] = 0;
302
									array_push($storeData["folders"]["item"], $this->setFolder($todoSearchFolderProps));
303
									$storeData["props"]['default_folder_todolist'] = bin2hex((string) $todoSearchFolderProps[PR_ENTRYID]);
304
								}
305
							}
306
						}
307
						catch (MAPIException $e) {
308
							// Add properties to the store response to indicate to the client
309
							// that the store could not be loaded.
310
							$this->invalidateResponseStore($storeData, 'all', $subtreeFolderEntryID);
311
312
							// We've handled the event
313
							$e->setHandled();
314
						}
315
316
					// Open single folders under the store object
317
					}
318
					else {
319
						foreach ($sharedFolders as $type => $sharedFolder) {
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $sharedFolders does not seem to be defined for all execution paths leading up to this point.
Loading history...
320
							$openSubFolders = ($sharedFolder["show_subfolders"] == true);
321
322
							// See if the folders exists by checking if it is in the default folders entryid list
323
							$store_access = true;
324
							if (!isset($storeData["props"]["default_folder_" . $sharedFolder["folder_type"]])) {
325
								// Create a fake folder entryid which must be used for referencing this folder
326
								$folderEntryID = "default_folder_" . $sharedFolder["folder_type"];
327
328
								// Add properties to the store response to indicate to the client
329
								// that the store could not be loaded.
330
								$this->invalidateResponseStore($storeData, $type, $folderEntryID);
0 ignored issues
show
Bug introduced by
$folderEntryID of type string is incompatible with the type array expected by parameter $folderEntryID of Operations::invalidateResponseStore(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

330
								$this->invalidateResponseStore($storeData, $type, /** @scrutinizer ignore-type */ $folderEntryID);
Loading history...
331
332
								// Update the store properties to refer to the shared folder,
333
								// note that we don't care if we have access to the folder or not.
334
								$storeData["props"]["shared_folder_" . $sharedFolder["folder_type"]] = bin2hex($folderEntryID);
335
336
								// Indicate that we don't have access to the store,
337
								// so no more attempts to read properties or open entries.
338
								$store_access = false;
339
340
							// If you access according to the above check, go ahead and retrieve the MAPIFolder object
341
							}
342
							else {
343
								$folderEntryID = hex2bin($storeData["props"]["default_folder_" . $sharedFolder["folder_type"]]);
344
345
								// Update the store properties to refer to the shared folder,
346
								// note that we don't care if we have access to the folder or not.
347
								$storeData["props"]["shared_folder_" . $sharedFolder["folder_type"]] = bin2hex($folderEntryID);
348
349
								try {
350
									// load folder props
351
									$folder = mapi_msgstore_openentry($store, $folderEntryID);
352
								}
353
								catch (MAPIException $e) {
354
									// Add properties to the store response to indicate to the client
355
									// that the store could not be loaded.
356
									$this->invalidateResponseStore($storeData, $type, $folderEntryID);
357
358
									// Indicate that we don't have access to the store,
359
									// so no more attempts to read properties or open entries.
360
									$store_access = false;
361
362
									// We've handled the event
363
									$e->setHandled();
364
								}
365
							}
366
367
							// Check if a error handler already inserted a error folder,
368
							// or if we can insert the real folders here.
369
							if ($store_access === true) {
370
								// check if we need subfolders or not
371
								if ($openSubFolders === true) {
372
									// add folder data (with all subfolders recursively)
373
									// get parent folder's properties
374
									$folderProps = mapi_getprops($folder, $properties);
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $folder does not seem to be defined for all execution paths leading up to this point.
Loading history...
375
									$tempFolderProps = $this->setFolder($folderProps);
376
377
									array_push($storeData["folders"]["item"], $tempFolderProps);
378
379
									// get subfolders
380
									if ($tempFolderProps["props"]["has_subfolder"] != false) {
381
										$subfoldersData = [];
382
										$subfoldersData["folders"]["item"] = [];
383
										$this->getSubFolders($folder, $store, $properties, $subfoldersData);
384
385
										$storeData["folders"]["item"] = array_merge($storeData["folders"]["item"], $subfoldersData["folders"]["item"]);
386
									}
387
								}
388
								else {
389
									$folderProps = mapi_getprops($folder, $properties);
390
									$tempFolderProps = $this->setFolder($folderProps);
391
									// We don't load subfolders, this means the user isn't allowed
392
									// to create subfolders, as they should normally be hidden immediately.
393
									$tempFolderProps["props"]["access"] = ($tempFolderProps["props"]["access"] & ~MAPI_ACCESS_CREATE_HIERARCHY);
394
									// We don't load subfolders, so force the 'has_subfolder' property
395
									// to be false, so the UI will not consider loading subfolders.
396
									$tempFolderProps["props"]["has_subfolder"] = false;
397
									array_push($storeData["folders"]["item"], $tempFolderProps);
398
								}
399
							}
400
						}
401
					}
402
				}
403
				array_push($data["item"], $storeData);
404
			}
405
		}
406
407
		return $data;
408
	}
409
410
	/**
411
	 * Helper function to get the subfolders of a Personal Store.
412
	 *
413
	 * @param object $folder        mapi Folder Object
414
	 * @param object $store         Message Store Object
415
	 * @param array  $properties    MAPI property mappings for folders
416
	 * @param array  $storeData     Reference to an array. The folder properties are added to this array.
417
	 * @param mixed  $parentEntryid
418
	 */
419
	public function getSubFolders($folder, $store, $properties, &$storeData, $parentEntryid = false) {
420
		/**
421
		 * remove hidden folders, folders with PR_ATTR_HIDDEN property set
422
		 * should not be shown to the client.
423
		 */
424
		$restriction = [RES_OR, [
425
			[RES_PROPERTY,
426
				[
427
					RELOP => RELOP_EQ,
428
					ULPROPTAG => PR_ATTR_HIDDEN,
429
					VALUE => [PR_ATTR_HIDDEN => false],
430
				],
431
			],
432
			[RES_NOT,
433
				[
434
					[RES_EXIST,
435
						[
436
							ULPROPTAG => PR_ATTR_HIDDEN,
437
						],
438
					],
439
				],
440
			],
441
		]];
442
443
		$hierarchyTable = mapi_folder_gethierarchytable($folder, CONVENIENT_DEPTH | MAPI_DEFERRED_ERRORS);
444
		mapi_table_restrict($hierarchyTable, $restriction, TBL_BATCH);
445
446
		// Also request PR_DEPTH
447
		$columns = array_merge($properties, [PR_DEPTH]);
448
449
		mapi_table_setcolumns($hierarchyTable, $columns);
450
		$columns = null;
451
452
		// Load the hierarchy in bulks
453
		$rows = mapi_table_queryrows($hierarchyTable, $columns, 0, 0x7FFFFFFF);
454
455
		foreach ($rows as $subfolder) {
456
			if ($parentEntryid !== false && isset($subfolder[PR_DEPTH]) && $subfolder[PR_DEPTH] === 1) {
457
				$subfolder[PR_PARENT_ENTRYID] = $parentEntryid;
458
			}
459
			array_push($storeData["folders"]["item"], $this->setFolder($subfolder));
460
		}
461
	}
462
463
	/**
464
	 * Convert MAPI properties into useful XML properties for a folder.
465
	 *
466
	 * @param array $folderProps Properties of a folder
467
	 *
468
	 * @return array List of properties of a folder
469
	 *
470
	 * @todo The name of this function is misleading because it doesn't 'set' anything, it just reads some properties.
471
	 */
472
	public function setFolder($folderProps) {
473
		$props = [
474
			// Identification properties
475
			"entryid" => bin2hex((string) $folderProps[PR_ENTRYID]),
476
			"parent_entryid" => bin2hex((string) $folderProps[PR_PARENT_ENTRYID]),
477
			"store_entryid" => bin2hex((string) $folderProps[PR_STORE_ENTRYID]),
478
			// Scalar properties
479
			"props" => [
480
				"display_name" => $folderProps[PR_DISPLAY_NAME],
481
				"object_type" => $folderProps[PR_OBJECT_TYPE] ?? MAPI_FOLDER, // FIXME: Why isn't this always set?
482
				"content_count" => $folderProps[PR_CONTENT_COUNT] ?? 0,
483
				"content_unread" => $folderProps[PR_CONTENT_UNREAD] ?? 0,
484
				"has_subfolder" => $folderProps[PR_SUBFOLDERS] ?? false,
485
				"container_class" => $folderProps[PR_CONTAINER_CLASS] ?? "IPF.Note",
486
				"access" => $folderProps[PR_ACCESS] ?? 0,
487
				"rights" => $folderProps[PR_RIGHTS] ?? ecRightsNone,
488
				"assoc_content_count" => $folderProps[PR_ASSOC_CONTENT_COUNT] ?? 0,
489
			],
490
		];
491
492
		$this->setExtendedFolderFlags($folderProps, $props);
493
494
		return $props;
495
	}
496
497
	/**
498
	 * Function is used to retrieve the favorites and search folders from
499
	 * respective favorites(IPM.Microsoft.WunderBar.Link) and search (IPM.Microsoft.WunderBar.SFInfo)
500
	 * link messages which belongs to associated contains table of IPM_COMMON_VIEWS folder.
501
	 *
502
	 * @param object $commonViewFolder MAPI Folder Object in which the favorites link messages lives
503
	 * @param array  $storeData        Reference to an array. The favorites folder properties are added to this array.
504
	 */
505
	public function getFavoritesFolders($commonViewFolder, &$storeData) {
506
		$table = mapi_folder_getcontentstable($commonViewFolder, MAPI_ASSOCIATED);
507
508
		$restriction = [RES_OR,
509
			[
510
				[RES_PROPERTY,
511
					[
512
						RELOP => RELOP_EQ,
513
						ULPROPTAG => PR_MESSAGE_CLASS,
514
						VALUE => [PR_MESSAGE_CLASS => "IPM.Microsoft.WunderBar.Link"],
515
					],
516
				],
517
				[RES_PROPERTY,
518
					[
519
						RELOP => RELOP_EQ,
520
						ULPROPTAG => PR_MESSAGE_CLASS,
521
						VALUE => [PR_MESSAGE_CLASS => "IPM.Microsoft.WunderBar.SFInfo"],
522
					],
523
				],
524
			],
525
		];
526
527
		// Get hierarchy table from all FINDERS_ROOT folders of
528
		// all message stores.
529
		$stores = $GLOBALS["mapisession"]->getAllMessageStores();
530
		$finderHierarchyTables = [];
531
		foreach ($stores as $entryid => $store) {
532
			$props = mapi_getprops($store, [PR_DEFAULT_STORE, PR_FINDER_ENTRYID]);
533
			if (!$props[PR_DEFAULT_STORE]) {
534
				continue;
535
			}
536
537
			try {
538
				$finderFolder = mapi_msgstore_openentry($store, $props[PR_FINDER_ENTRYID]);
539
				$hierarchyTable = mapi_folder_gethierarchytable($finderFolder, MAPI_DEFERRED_ERRORS);
540
				$finderHierarchyTables[$props[PR_FINDER_ENTRYID]] = $hierarchyTable;
541
			}
542
			catch (MAPIException $e) {
543
				$e->setHandled();
544
				$props = mapi_getprops($store, [PR_DISPLAY_NAME]);
545
				error_log(sprintf(
546
					"Unable to open FINDER_ROOT for store \"%s\": %s (%s)",
547
					$props[PR_DISPLAY_NAME],
548
					mapi_strerror($e->getCode()),
549
					get_mapi_error_name($e->getCode())
550
				));
551
			}
552
		}
553
554
		$rows = mapi_table_queryallrows($table, $GLOBALS["properties"]->getFavoritesFolderProperties(), $restriction);
555
		$faultyLinkMsg = [];
556
		foreach ($rows as $row) {
557
			if (isset($row[PR_WLINK_TYPE]) && $row[PR_WLINK_TYPE] > wblSharedFolder) {
558
				continue;
559
			}
560
561
			try {
562
				if ($row[PR_MESSAGE_CLASS] === "IPM.Microsoft.WunderBar.Link") {
563
					// Find faulty link messages which does not linked to any message. if link message
564
					// does not contains store entryid in which actual message is located then it consider as
565
					// faulty link message.
566
					if (isset($row[PR_WLINK_STORE_ENTRYID]) && empty($row[PR_WLINK_STORE_ENTRYID]) ||
0 ignored issues
show
introduced by
Consider adding parentheses for clarity. Current Interpretation: (IssetNode && empty($row...TRYID])) || ! IssetNode, Probably Intended Meaning: IssetNode && (empty($row...TRYID]) || ! IssetNode)
Loading history...
567
						!isset($row[PR_WLINK_STORE_ENTRYID])) {
568
						// Outlook apparently doesn't set PR_WLINK_STORE_ENTRYID
569
						// for with free/busy permission only opened shared calendars,
570
						// so do not remove them from the IPM_COMMON_VIEWS
571
						if ((isset($row[PR_WLINK_SECTION]) && $row[PR_WLINK_SECTION] != wbsidCalendar) ||
572
							!isset($row[PR_WLINK_SECTION])) {
573
							array_push($faultyLinkMsg, $row[PR_ENTRYID]);
574
						}
575
576
						continue;
577
					}
578
					$props = $this->getFavoriteLinkedFolderProps($row);
579
					if (empty($props)) {
580
						continue;
581
					}
582
				}
583
				elseif ($row[PR_MESSAGE_CLASS] === "IPM.Microsoft.WunderBar.SFInfo") {
584
					$props = $this->getFavoritesLinkedSearchFolderProps($row[PR_WB_SF_ID], $finderHierarchyTables);
585
					if (empty($props)) {
586
						continue;
587
					}
588
				}
589
			}
590
			catch (MAPIException) {
591
				continue;
592
			}
593
594
			array_push($storeData['favorites']['item'], $this->setFavoritesFolder($props));
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $props does not seem to be defined for all execution paths leading up to this point.
Loading history...
595
		}
596
597
		if (!empty($faultyLinkMsg)) {
598
			// remove faulty link messages from common view folder.
599
			mapi_folder_deletemessages($commonViewFolder, $faultyLinkMsg);
600
		}
601
	}
602
603
	/**
604
	 * Function which checks whether given linked Message is faulty or not.
605
	 * It will store faulty linked messages in given &$faultyLinkMsg array.
606
	 * Returns true if linked message of favorite item is faulty.
607
	 *
608
	 * @param array  &$faultyLinkMsg   reference in which faulty linked messages will be stored
609
	 * @param array  $allMessageStores Associative array with entryid -> mapistore of all open stores (private, public, delegate)
610
	 * @param object $linkedMessage    link message which belongs to associated contains table of IPM_COMMON_VIEWS folder
611
	 *
612
	 * @return true if linked message of favorite item is faulty or false
613
	 */
614
	public function checkFaultyFavoritesLinkedFolder(&$faultyLinkMsg, $allMessageStores, $linkedMessage) {
615
		// Find faulty link messages which does not linked to any message. if link message
616
		// does not contains store entryid in which actual message is located then it consider as
617
		// faulty link message.
618
		if (isset($linkedMessage[PR_WLINK_STORE_ENTRYID]) && empty($linkedMessage[PR_WLINK_STORE_ENTRYID])) {
619
			array_push($faultyLinkMsg, $linkedMessage[PR_ENTRYID]);
620
621
			return true;
622
		}
623
624
		// Check if store of a favorite Item does not exist in Hierarchy then
625
		// delete link message of that favorite item.
626
		// i.e. If a user is unhooked then remove its favorite items.
627
		$storeExist = array_key_exists($linkedMessage[PR_WLINK_STORE_ENTRYID], $allMessageStores);
628
		if (!$storeExist) {
629
			array_push($faultyLinkMsg, $linkedMessage[PR_ENTRYID]);
630
631
			return true;
632
		}
633
634
		return false;
0 ignored issues
show
Bug Best Practice introduced by
The expression return false returns the type false which is incompatible with the documented return type true.
Loading history...
635
	}
636
637
	/**
638
	 * Function which get the favorites marked folders from favorites link message
639
	 * which belongs to associated contains table of IPM_COMMON_VIEWS folder.
640
	 *
641
	 * @param array $linkMessageProps properties of link message which belongs to
642
	 *                                associated contains table of IPM_COMMON_VIEWS folder
643
	 *
644
	 * @return array List of properties of a folder
645
	 */
646
	public function getFavoriteLinkedFolderProps($linkMessageProps) {
647
		// In webapp we use IPM_SUBTREE as root folder for the Hierarchy but OL is use IMsgStore as a
648
		// Root folder. OL never mark favorites to IPM_SUBTREE. So to make favorites compatible with OL
649
		// we need this check.
650
		// Here we check PR_WLINK_STORE_ENTRYID and PR_WLINK_ENTRYID is same. Which same only in one case
651
		// where some user has mark favorites to root(Inbox-<user name>) folder from OL. So here if condition
652
		// gets true we get the IPM_SUBTREE and send it to response as favorites folder to webapp.
653
		try {
654
			if ($GLOBALS['entryid']->compareEntryIds($linkMessageProps[PR_WLINK_STORE_ENTRYID], $linkMessageProps[PR_WLINK_ENTRYID])) {
655
				$storeObj = $GLOBALS["mapisession"]->openMessageStore($linkMessageProps[PR_WLINK_STORE_ENTRYID]);
656
				$subTreeEntryid = mapi_getprops($storeObj, [PR_IPM_SUBTREE_ENTRYID]);
657
				$folderObj = mapi_msgstore_openentry($storeObj, $subTreeEntryid[PR_IPM_SUBTREE_ENTRYID]);
658
			}
659
			else {
660
				$storeObj = $GLOBALS["mapisession"]->openMessageStore($linkMessageProps[PR_WLINK_STORE_ENTRYID]);
661
				if (!is_resource($storeObj)) {
662
					return false;
0 ignored issues
show
Bug Best Practice introduced by
The expression return false returns the type false which is incompatible with the documented return type array.
Loading history...
663
				}
664
				$folderObj = mapi_msgstore_openentry($storeObj, $linkMessageProps[PR_WLINK_ENTRYID]);
665
			}
666
667
			return mapi_getprops($folderObj, $GLOBALS["properties"]->getFavoritesFolderProperties());
668
		}
669
		catch (Exception) {
670
			// in some cases error_log was causing an endless loop, so disable it for now
671
			// error_log($e);
672
		}
673
674
		return false;
0 ignored issues
show
Bug Best Practice introduced by
The expression return false returns the type false which is incompatible with the documented return type array.
Loading history...
675
	}
676
677
	/**
678
	 * Function which retrieve the search folder from FINDERS_ROOT folder of all open
679
	 * message store.
680
	 *
681
	 * @param string $searchFolderId        contains a GUID that identifies the search folder.
682
	 *                                      The value of this property MUST NOT change.
683
	 * @param array  $finderHierarchyTables hierarchy tables which belongs to FINDERS_ROOT
684
	 *                                      folder of message stores
685
	 *
686
	 * @return array list of search folder properties
687
	 */
688
	public function getFavoritesLinkedSearchFolderProps($searchFolderId, $finderHierarchyTables) {
689
		$restriction = [RES_EXIST,
690
			[
691
				ULPROPTAG => PR_EXTENDED_FOLDER_FLAGS,
692
			],
693
		];
694
695
		foreach ($finderHierarchyTables as $finderEntryid => $hierarchyTable) {
696
			$rows = mapi_table_queryallrows($hierarchyTable, $GLOBALS["properties"]->getFavoritesFolderProperties(), $restriction);
697
			foreach ($rows as $row) {
698
				$flags = unpack("H2ExtendedFlags-Id/H2ExtendedFlags-Cb/H8ExtendedFlags-Data/H2SearchFolderTag-Id/H2SearchFolderTag-Cb/H8SearchFolderTag-Data/H2SearchFolderId-Id/H2SearchFolderId-Cb/H32SearchFolderId-Data", (string) $row[PR_EXTENDED_FOLDER_FLAGS]);
699
				if ($flags["SearchFolderId-Data"] === bin2hex($searchFolderId)) {
700
					return $row;
701
				}
702
			}
703
		}
704
	}
705
706
	/**
707
	 * Create link messages for default favorites(Inbox and Sent Items) folders in associated contains table of IPM_COMMON_VIEWS folder
708
	 * and remove all other link message from the same.
709
	 *
710
	 * @param string $commonViewFolderEntryid IPM_COMMON_VIEWS folder entryid
711
	 * @param object $store                   Message Store Object
712
	 * @param array  $storeData               the store data which use to create restriction
713
	 */
714
	public function setDefaultFavoritesFolder($commonViewFolderEntryid, $store, $storeData) {
715
		if ($GLOBALS["settings"]->get("zarafa/v1/contexts/hierarchy/show_default_favorites") !== false) {
716
			$commonViewFolder = mapi_msgstore_openentry($store, $commonViewFolderEntryid);
717
718
			$inboxFolderEntryid = hex2bin((string) $storeData["props"]["default_folder_inbox"]);
719
			$sentFolderEntryid = hex2bin((string) $storeData["props"]["default_folder_sent"]);
720
721
			$table = mapi_folder_getcontentstable($commonViewFolder, MAPI_ASSOCIATED);
722
723
			// Restriction for get all link message(IPM.Microsoft.WunderBar.Link)
724
			// and search link message (IPM.Microsoft.WunderBar.SFInfo) from
725
			// Associated contains table of IPM_COMMON_VIEWS folder.
726
			$findLinkMsgRestriction = [RES_OR,
727
				[
728
					[RES_PROPERTY,
729
						[
730
							RELOP => RELOP_EQ,
731
							ULPROPTAG => PR_MESSAGE_CLASS,
732
							VALUE => [PR_MESSAGE_CLASS => "IPM.Microsoft.WunderBar.Link"],
733
						],
734
					],
735
					[RES_PROPERTY,
736
						[
737
							RELOP => RELOP_EQ,
738
							ULPROPTAG => PR_MESSAGE_CLASS,
739
							VALUE => [PR_MESSAGE_CLASS => "IPM.Microsoft.WunderBar.SFInfo"],
740
						],
741
					],
742
				],
743
			];
744
745
			// Restriction for find Inbox and/or Sent folder link message from
746
			// Associated contains table of IPM_COMMON_VIEWS folder.
747
			$findInboxOrSentLinkMessage = [RES_OR,
748
				[
749
					[RES_PROPERTY,
750
						[
751
							RELOP => RELOP_EQ,
752
							ULPROPTAG => PR_WLINK_ENTRYID,
753
							VALUE => [PR_WLINK_ENTRYID => $inboxFolderEntryid],
754
						],
755
					],
756
					[RES_PROPERTY,
757
						[
758
							RELOP => RELOP_EQ,
759
							ULPROPTAG => PR_WLINK_ENTRYID,
760
							VALUE => [PR_WLINK_ENTRYID => $sentFolderEntryid],
761
						],
762
					],
763
				],
764
			];
765
766
			// Restriction to get all link messages except Inbox and Sent folder's link messages from
767
			// Associated contains table of IPM_COMMON_VIEWS folder, if exist in it.
768
			$restriction = [RES_AND,
769
				[
770
					$findLinkMsgRestriction,
771
					[RES_NOT,
772
						[
773
							$findInboxOrSentLinkMessage,
774
						],
775
					],
776
				],
777
			];
778
779
			$rows = mapi_table_queryallrows($table, [PR_ENTRYID], $restriction);
780
			if (!empty($rows)) {
781
				$deleteMessages = [];
782
				foreach ($rows as $row) {
783
					array_push($deleteMessages, $row[PR_ENTRYID]);
784
				}
785
				mapi_folder_deletemessages($commonViewFolder, $deleteMessages);
786
			}
787
788
			// We need to remove all search folder from FIND_ROOT(search root folder)
789
			// when reset setting was triggered because on reset setting we remove all
790
			// link messages from common view folder which are linked with either
791
			// favorites or search folder.
792
			$finderFolderEntryid = hex2bin((string) $storeData["props"]["finder_entryid"]);
793
			$finderFolder = mapi_msgstore_openentry($store, $finderFolderEntryid);
794
			$hierarchyTable = mapi_folder_gethierarchytable($finderFolder, MAPI_DEFERRED_ERRORS);
795
			$folders = mapi_table_queryallrows($hierarchyTable, [PR_ENTRYID]);
796
			foreach ($folders as $folder) {
797
				try {
798
					mapi_folder_deletefolder($finderFolder, $folder[PR_ENTRYID]);
799
				}
800
				catch (MAPIException $e) {
801
					$msg = "Problem in deleting search folder while reset settings. MAPI Error %s.";
802
					$formattedMsg = sprintf($msg, get_mapi_error_name($e->getCode()));
803
					error_log($formattedMsg);
804
					Log::Write(LOGLEVEL_ERROR, "Operations:setDefaultFavoritesFolder() " . $formattedMsg);
805
				}
806
			}
807
			// Restriction used to find only Inbox and Sent folder's link messages from
808
			// Associated contains table of IPM_COMMON_VIEWS folder, if exist in it.
809
			$restriction = [RES_AND,
810
				[
811
					$findLinkMsgRestriction,
812
					$findInboxOrSentLinkMessage,
813
				],
814
			];
815
816
			$rows = mapi_table_queryallrows($table, [PR_WLINK_ENTRYID], $restriction);
817
818
			// If Inbox and Sent folder's link messages are not exist then create the
819
			// link message for those in associated contains table of IPM_COMMON_VIEWS folder.
820
			if (empty($rows)) {
821
				$defaultFavFoldersKeys = ["inbox", "sent"];
822
				foreach ($defaultFavFoldersKeys as $folderKey) {
823
					$folderObj = $GLOBALS["mapisession"]->openMessage(hex2bin((string) $storeData["props"]["default_folder_" . $folderKey]));
824
					$props = mapi_getprops($folderObj, [PR_ENTRYID, PR_STORE_ENTRYID, PR_DISPLAY_NAME]);
825
					$this->createFavoritesLink($commonViewFolder, $props);
826
				}
827
			}
828
			elseif (count($rows) < 2) {
829
				// If rows count is less than 2 it means associated contains table of IPM_COMMON_VIEWS folder
830
				// can have either Inbox or Sent folder link message in it. So we have to create link message
831
				// for Inbox or Sent folder which ever not exist in associated contains table of IPM_COMMON_VIEWS folder
832
				// to maintain default favorites folder.
833
				$row = $rows[0];
834
				$wlinkEntryid = $row[PR_WLINK_ENTRYID];
835
836
				$isInboxFolder = $GLOBALS['entryid']->compareEntryIds($wlinkEntryid, $inboxFolderEntryid);
837
838
				if (!$isInboxFolder) {
839
					$folderObj = $GLOBALS["mapisession"]->openMessage($inboxFolderEntryid);
840
				}
841
				else {
842
					$folderObj = $GLOBALS["mapisession"]->openMessage($sentFolderEntryid);
843
				}
844
845
				$props = mapi_getprops($folderObj, [PR_ENTRYID, PR_STORE_ENTRYID, PR_DISPLAY_NAME]);
846
				$this->createFavoritesLink($commonViewFolder, $props);
847
			}
848
			$GLOBALS["settings"]->set("zarafa/v1/contexts/hierarchy/show_default_favorites", false, true);
849
		}
850
	}
851
852
	/**
853
	 * Create favorites link message (IPM.Microsoft.WunderBar.Link) or
854
	 * search link message ("IPM.Microsoft.WunderBar.SFInfo") in associated
855
	 * contains table of IPM_COMMON_VIEWS folder.
856
	 *
857
	 * @param object      $commonViewFolder MAPI Message Folder Object
858
	 * @param array       $folderProps      Properties of a folder
859
	 * @param bool|string $searchFolderId   search folder id which is used to identify the
860
	 *                                      linked search folder from search link message. by default it is false.
861
	 */
862
	public function createFavoritesLink($commonViewFolder, $folderProps, $searchFolderId = false) {
863
		if ($searchFolderId) {
864
			$props = [
865
				PR_MESSAGE_CLASS => "IPM.Microsoft.WunderBar.SFInfo",
866
				PR_WB_SF_ID => $searchFolderId,
867
				PR_WLINK_TYPE => wblSearchFolder,
868
			];
869
		}
870
		else {
871
			$defaultStoreEntryId = hex2bin((string) $GLOBALS['mapisession']->getDefaultMessageStoreEntryId());
872
			$props = [
873
				PR_MESSAGE_CLASS => "IPM.Microsoft.WunderBar.Link",
874
				PR_WLINK_ENTRYID => $folderProps[PR_ENTRYID],
875
				PR_WLINK_STORE_ENTRYID => $folderProps[PR_STORE_ENTRYID],
876
				PR_WLINK_TYPE => $GLOBALS['entryid']->compareEntryIds($defaultStoreEntryId, $folderProps[PR_STORE_ENTRYID]) ? wblNormalFolder : wblSharedFolder,
877
			];
878
		}
879
880
		$favoritesLinkMsg = mapi_folder_createmessage($commonViewFolder, MAPI_ASSOCIATED);
881
		mapi_setprops($favoritesLinkMsg, $props);
882
		mapi_savechanges($favoritesLinkMsg);
883
	}
884
885
	/**
886
	 * Convert MAPI properties into useful and human readable string for favorites folder.
887
	 *
888
	 * @param array $folderProps Properties of a folder
889
	 *
890
	 * @return array List of properties of a folder
891
	 */
892
	public function setFavoritesFolder($folderProps) {
893
		$props = $this->setFolder($folderProps);
894
		// Add and Make isFavorites to true, this allows the client to properly
895
		// indicate to the user that this is a favorites item/folder.
896
		$props["props"]["isFavorites"] = true;
897
		$props["props"]["folder_type"] = $folderProps[PR_FOLDER_TYPE];
898
899
		return $props;
900
	}
901
902
	/**
903
	 * Fetches extended flags for folder. If PR_EXTENDED_FLAGS is not set then we assume that client
904
	 * should handle which property to display.
905
	 *
906
	 * @param array $folderProps Properties of a folder
907
	 * @param array $props       properties in which flags should be set
908
	 */
909
	public function setExtendedFolderFlags($folderProps, &$props) {
910
		if (isset($folderProps[PR_EXTENDED_FOLDER_FLAGS])) {
911
			$flags = unpack("Cid/Cconst/Cflags", $folderProps[PR_EXTENDED_FOLDER_FLAGS]);
912
913
			// ID property is '1' this means 'Data' property contains extended flags
914
			if ($flags["id"] == 1) {
915
				$props["props"]["extended_flags"] = $flags["flags"];
916
			}
917
		}
918
	}
919
920
	/**
921
	 * Used to update the storeData with a folder and properties that will
922
	 * inform the user that the store could not be opened.
923
	 *
924
	 * @param array  &$storeData    The store data which will be updated
925
	 * @param string $folderType    The foldertype which was attempted to be loaded
926
	 * @param array  $folderEntryID The entryid of the which was attempted to be opened
927
	 */
928
	public function invalidateResponseStore(&$storeData, $folderType, $folderEntryID) {
929
		$folderName = "Folder";
930
		$containerClass = "IPF.Note";
931
932
		switch ($folderType) {
933
			case "all":
934
				$folderName = "IPM_SUBTREE";
935
				$containerClass = "IPF.Note";
936
				break;
937
938
			case "calendar":
939
				$folderName = _("Calendar");
940
				$containerClass = "IPF.Appointment";
941
				break;
942
943
			case "contact":
944
				$folderName = _("Contacts");
945
				$containerClass = "IPF.Contact";
946
				break;
947
948
			case "inbox":
949
				$folderName = _("Inbox");
950
				$containerClass = "IPF.Note";
951
				break;
952
953
			case "note":
954
				$folderName = _("Notes");
955
				$containerClass = "IPF.StickyNote";
956
				break;
957
958
			case "task":
959
				$folderName = _("Tasks");
960
				$containerClass = "IPF.Task";
961
				break;
962
		}
963
964
		// Insert a fake folder which will be shown to the user
965
		// to acknowledge that he has a shared store, but also
966
		// to indicate that he can't open it.
967
		$tempFolderProps = $this->setFolder([
968
			PR_ENTRYID => $folderEntryID,
969
			PR_PARENT_ENTRYID => hex2bin((string) $storeData["props"]["subtree_entryid"]),
970
			PR_STORE_ENTRYID => hex2bin((string) $storeData["store_entryid"]),
971
			PR_DISPLAY_NAME => $folderName,
972
			PR_OBJECT_TYPE => MAPI_FOLDER,
973
			PR_SUBFOLDERS => false,
974
			PR_CONTAINER_CLASS => $containerClass,
975
			PR_ACCESS => 0,
976
		]);
977
978
		// Mark the folder as unavailable, this allows the client to properly
979
		// indicate to the user that this is a fake entry.
980
		$tempFolderProps['props']['is_unavailable'] = true;
981
982
		array_push($storeData["folders"]["item"], $tempFolderProps);
983
984
		/* TRANSLATORS: This indicates that the opened folder belongs to a particular user,
985
		 * for example: 'Calendar of Holiday', in this case %1$s is 'Calendar' (the foldername)
986
		 * and %2$s is 'Holiday' (the username).
987
		 */
988
		$storeData["props"]["display_name"] = ($folderType === "all") ? $storeData["props"]["display_name"] : sprintf(_('%1$s of %2$s'), $folderName, $storeData["props"]["mailbox_owner_name"]);
989
		$storeData["props"]["subtree_entryid"] = $tempFolderProps["parent_entryid"];
990
		$storeData["props"]["folder_type"] = $folderType;
991
	}
992
993
	/**
994
	 * Used to update the storeData with a folder and properties that will function as a
995
	 * placeholder for the IPMSubtree that could not be opened.
996
	 *
997
	 * @param array &$storeData    The store data which will be updated
998
	 * @param array $folderEntryID The entryid of the which was attempted to be opened
999
	 */
1000
	public function getDummyIPMSubtreeFolder(&$storeData, $folderEntryID) {
1001
		// Insert a fake folder which will be shown to the user
1002
		// to acknowledge that he has a shared store.
1003
		$tempFolderProps = $this->setFolder([
1004
			PR_ENTRYID => $folderEntryID,
1005
			PR_PARENT_ENTRYID => hex2bin((string) $storeData["props"]["subtree_entryid"]),
1006
			PR_STORE_ENTRYID => hex2bin((string) $storeData["store_entryid"]),
1007
			PR_DISPLAY_NAME => "IPM_SUBTREE",
1008
			PR_OBJECT_TYPE => MAPI_FOLDER,
1009
			PR_SUBFOLDERS => true,
1010
			PR_CONTAINER_CLASS => "IPF.Note",
1011
			PR_ACCESS => 0,
1012
		]);
1013
1014
		array_push($storeData["folders"]["item"], $tempFolderProps);
1015
		$storeData["props"]["subtree_entryid"] = $tempFolderProps["parent_entryid"];
1016
	}
1017
1018
	/**
1019
	 * Create a MAPI folder.
1020
	 *
1021
	 * This function simply creates a MAPI folder at a specific location with a specific folder
1022
	 * type.
1023
	 *
1024
	 * @param object $store         MAPI Message Store Object in which the folder lives
1025
	 * @param string $parententryid The parent entryid in which the new folder should be created
1026
	 * @param string $name          The name of the new folder
1027
	 * @param string $type          The type of the folder (PR_CONTAINER_CLASS, so value should be 'IPM.Appointment', etc)
1028
	 * @param array  $folderProps   reference to an array which will be filled with PR_ENTRYID and PR_STORE_ENTRYID of new folder
1029
	 *
1030
	 * @return bool true if action succeeded, false if not
1031
	 */
1032
	public function createFolder($store, $parententryid, $name, $type, &$folderProps) {
1033
		$result = false;
1034
		$folder = mapi_msgstore_openentry($store, $parententryid);
1035
1036
		if ($folder) {
1037
			/**
1038
			 * @TODO: If parent folder has any sub-folder with the same name than this will return
1039
			 * MAPI_E_COLLISION error, so show this error to client and don't close the dialog.
1040
			 */
1041
			$new_folder = mapi_folder_createfolder($folder, $name);
1042
1043
			if ($new_folder) {
1044
				mapi_setprops($new_folder, [PR_CONTAINER_CLASS => $type]);
1045
				$result = true;
1046
1047
				$folderProps = mapi_getprops($new_folder, [PR_ENTRYID, PR_STORE_ENTRYID]);
1048
			}
1049
		}
1050
1051
		return $result;
1052
	}
1053
1054
	/**
1055
	 * Rename a folder.
1056
	 *
1057
	 * This function renames the specified folder. However, a conflict situation can arise
1058
	 * if the specified folder name already exists. In this case, the folder name is postfixed with
1059
	 * an ever-higher integer to create a unique folder name.
1060
	 *
1061
	 * @param object $store       MAPI Message Store Object
1062
	 * @param string $entryid     The entryid of the folder to rename
1063
	 * @param string $name        The new name of the folder
1064
	 * @param array  $folderProps reference to an array which will be filled with PR_ENTRYID and PR_STORE_ENTRYID
1065
	 *
1066
	 * @return bool true if action succeeded, false if not
1067
	 */
1068
	public function renameFolder($store, $entryid, $name, &$folderProps) {
1069
		$folder = mapi_msgstore_openentry($store, $entryid);
1070
		if (!$folder) {
1071
			return false;
1072
		}
1073
		$result = false;
0 ignored issues
show
Unused Code introduced by
The assignment to $result is dead and can be removed.
Loading history...
1074
		$folderProps = mapi_getprops($folder, [PR_ENTRYID, PR_STORE_ENTRYID, PR_DISPLAY_NAME]);
1075
1076
		/*
1077
		 * If parent folder has any sub-folder with the same name than this will return
1078
		 * MAPI_E_COLLISION error while renaming folder, so show this error to client,
1079
		 * and revert changes in view.
1080
		 */
1081
		try {
1082
			mapi_setprops($folder, [PR_DISPLAY_NAME => $name]);
1083
			mapi_savechanges($folder);
1084
			$result = true;
1085
		}
1086
		catch (MAPIException $e) {
1087
			if ($e->getCode() == MAPI_E_COLLISION) {
1088
				/*
1089
				 * revert folder name to original one
1090
				 * There is a bug in php-mapi that updates folder name in hierarchy table with null value
1091
				 * so we need to revert those change by again setting the old folder name
1092
				 * (ZCP-11586)
1093
				 */
1094
				mapi_setprops($folder, [PR_DISPLAY_NAME => $folderProps[PR_DISPLAY_NAME]]);
1095
				mapi_savechanges($folder);
1096
			}
1097
1098
			// rethrow exception so we will send error to client
1099
			throw $e;
1100
		}
1101
1102
		return $result;
1103
	}
1104
1105
	/**
1106
	 * Check if a folder is 'special'.
1107
	 *
1108
	 * All default MAPI folders such as 'inbox', 'outbox', etc have special permissions; you can not rename them for example. This
1109
	 * function returns TRUE if the specified folder is 'special'.
1110
	 *
1111
	 * @param object $store   MAPI Message Store Object
1112
	 * @param string $entryid The entryid of the folder
1113
	 *
1114
	 * @return bool true if folder is a special folder, false if not
1115
	 */
1116
	public function isSpecialFolder($store, $entryid) {
1117
		$msgstore_props = mapi_getprops($store, [PR_MDB_PROVIDER]);
1118
1119
		// "special" folders don't exists in public store
1120
		if ($msgstore_props[PR_MDB_PROVIDER] == ZARAFA_STORE_PUBLIC_GUID) {
1121
			return false;
1122
		}
1123
1124
		// Check for the Special folders which are provided on the store
1125
		$msgstore_props = mapi_getprops($store, [
1126
			PR_IPM_SUBTREE_ENTRYID,
1127
			PR_IPM_OUTBOX_ENTRYID,
1128
			PR_IPM_SENTMAIL_ENTRYID,
1129
			PR_IPM_WASTEBASKET_ENTRYID,
1130
			PR_IPM_PUBLIC_FOLDERS_ENTRYID,
1131
			PR_IPM_FAVORITES_ENTRYID,
1132
		]);
1133
1134
		if (array_search($entryid, $msgstore_props)) {
1135
			return true;
1136
		}
1137
1138
		// Check for the Special folders which are provided on the root folder
1139
		$root = mapi_msgstore_openentry($store);
1140
		$rootProps = mapi_getprops($root, [
1141
			PR_IPM_APPOINTMENT_ENTRYID,
1142
			PR_IPM_CONTACT_ENTRYID,
1143
			PR_IPM_DRAFTS_ENTRYID,
1144
			PR_IPM_JOURNAL_ENTRYID,
1145
			PR_IPM_NOTE_ENTRYID,
1146
			PR_IPM_TASK_ENTRYID,
1147
			PR_ADDITIONAL_REN_ENTRYIDS,
1148
		]);
1149
1150
		if (array_search($entryid, $rootProps)) {
1151
			return true;
1152
		}
1153
1154
		// The PR_ADDITIONAL_REN_ENTRYIDS are a bit special
1155
		if (isset($rootProps[PR_ADDITIONAL_REN_ENTRYIDS]) && is_array($rootProps[PR_ADDITIONAL_REN_ENTRYIDS])) {
1156
			if (array_search($entryid, $rootProps[PR_ADDITIONAL_REN_ENTRYIDS])) {
1157
				return true;
1158
			}
1159
		}
1160
1161
		// Check if the given folder is the inbox, note that we are unsure
1162
		// if we have permissions on that folder, so we need a try catch.
1163
		try {
1164
			$inbox = mapi_msgstore_getreceivefolder($store);
1165
			$props = mapi_getprops($inbox, [PR_ENTRYID]);
1166
1167
			if ($props[PR_ENTRYID] == $entryid) {
1168
				return true;
1169
			}
1170
		}
1171
		catch (MAPIException $e) {
1172
			if ($e->getCode() !== MAPI_E_NO_ACCESS) {
1173
				throw $e;
1174
			}
1175
		}
1176
1177
		return false;
1178
	}
1179
1180
	/**
1181
	 * Delete a folder.
1182
	 *
1183
	 * Deleting a folder normally just moves the folder to the wastebasket, which is what this function does. However,
1184
	 * if the folder was already in the wastebasket, then the folder is really deleted.
1185
	 *
1186
	 * @param object $store         MAPI Message Store Object
1187
	 * @param string $parententryid The parent in which the folder should be deleted
1188
	 * @param string $entryid       The entryid of the folder which will be deleted
1189
	 * @param array  $folderProps   reference to an array which will be filled with PR_ENTRYID, PR_STORE_ENTRYID of the deleted object
1190
	 * @param bool   $softDelete    flag for indicating that folder should be soft deleted which can be recovered from
1191
	 *                              restore deleted items
1192
	 * @param bool   $hardDelete    flag for indicating that folder should be hard deleted from system and can not be
1193
	 *                              recovered from restore soft deleted items
1194
	 *
1195
	 * @return bool true if action succeeded, false if not
1196
	 *
1197
	 * @todo subfolders of folders in the wastebasket should also be hard-deleted
1198
	 */
1199
	public function deleteFolder($store, $parententryid, $entryid, &$folderProps, $softDelete = false, $hardDelete = false) {
1200
		$result = false;
1201
		$msgprops = mapi_getprops($store, [PR_IPM_WASTEBASKET_ENTRYID]);
1202
		$folder = mapi_msgstore_openentry($store, $parententryid);
1203
1204
		if ($folder && !$this->isSpecialFolder($store, $entryid)) {
1205
			if ($hardDelete === true) {
1206
				// hard delete the message if requested
1207
				// beware that folder can not be recovered after this and will be deleted from system entirely
1208
				if (mapi_folder_deletefolder($folder, $entryid, DEL_MESSAGES | DEL_FOLDERS | DELETE_HARD_DELETE)) {
1209
					$result = true;
1210
1211
					// if exists, also delete settings made for this folder (client don't need an update for this)
1212
					$GLOBALS["settings"]->delete("zarafa/v1/state/folders/" . bin2hex($entryid));
1213
				}
1214
			}
1215
			else {
1216
				if (isset($msgprops[PR_IPM_WASTEBASKET_ENTRYID])) {
1217
					// TODO: check if not only $parententryid=wastebasket, but also the parents of that parent...
1218
					// if folder is already in wastebasket or softDelete is requested then delete the message
1219
					if ($msgprops[PR_IPM_WASTEBASKET_ENTRYID] == $parententryid || $softDelete === true) {
1220
						if (mapi_folder_deletefolder($folder, $entryid, DEL_MESSAGES | DEL_FOLDERS)) {
1221
							$result = true;
1222
1223
							// if exists, also delete settings made for this folder (client don't need an update for this)
1224
							$GLOBALS["settings"]->delete("zarafa/v1/state/folders/" . bin2hex($entryid));
1225
						}
1226
					}
1227
					else {
1228
						// move the folder to wastebasket
1229
						$wastebasket = mapi_msgstore_openentry($store, $msgprops[PR_IPM_WASTEBASKET_ENTRYID]);
1230
1231
						$deleted_folder = mapi_msgstore_openentry($store, $entryid);
1232
						$props = mapi_getprops($deleted_folder, [PR_DISPLAY_NAME]);
1233
1234
						try {
1235
							/*
1236
							 * To decrease overload of checking for conflicting folder names on modification of every folder
1237
							 * we should first try to copy folder and if it returns MAPI_E_COLLISION then
1238
							 * only we should check for the conflicting folder names and generate a new name
1239
							 * and copy folder with the generated name.
1240
							 */
1241
							mapi_folder_copyfolder($folder, $entryid, $wastebasket, $props[PR_DISPLAY_NAME], FOLDER_MOVE);
1242
							$folderProps = mapi_getprops($deleted_folder, [PR_ENTRYID, PR_STORE_ENTRYID]);
1243
							$result = true;
1244
						}
1245
						catch (MAPIException $e) {
1246
							if ($e->getCode() == MAPI_E_COLLISION) {
1247
								$foldername = $this->checkFolderNameConflict($store, $wastebasket, $props[PR_DISPLAY_NAME]);
1248
1249
								mapi_folder_copyfolder($folder, $entryid, $wastebasket, $foldername, FOLDER_MOVE);
1250
								$folderProps = mapi_getprops($deleted_folder, [PR_ENTRYID, PR_STORE_ENTRYID]);
1251
								$result = true;
1252
							}
1253
							else {
1254
								// all other errors should be propagated to higher level exception handlers
1255
								throw $e;
1256
							}
1257
						}
1258
					}
1259
				}
1260
				else {
1261
					if (mapi_folder_deletefolder($folder, $entryid, DEL_MESSAGES | DEL_FOLDERS)) {
1262
						$result = true;
1263
1264
						// if exists, also delete settings made for this folder (client don't need an update for this)
1265
						$GLOBALS["settings"]->delete("zarafa/v1/state/folders/" . bin2hex($entryid));
1266
					}
1267
				}
1268
			}
1269
		}
1270
1271
		return $result;
1272
	}
1273
1274
	/**
1275
	 * Empty folder.
1276
	 *
1277
	 * Removes all items from a folder. This is a real delete, not a move.
1278
	 *
1279
	 * @param object $store           MAPI Message Store Object
1280
	 * @param string $entryid         The entryid of the folder which will be emptied
1281
	 * @param array  $folderProps     reference to an array which will be filled with PR_ENTRYID and PR_STORE_ENTRYID of the emptied folder
1282
	 * @param bool   $hardDelete      flag to indicate if messages will be hard deleted and can not be recoved using restore soft deleted items
1283
	 * @param bool   $emptySubFolders true to remove all messages with child folders of selected folder else false will
1284
	 *                                remove only message of selected folder
1285
	 *
1286
	 * @return bool true if action succeeded, false if not
1287
	 */
1288
	public function emptyFolder($store, $entryid, &$folderProps, $hardDelete = false, $emptySubFolders = true) {
1289
		$result = false;
1290
		$folder = mapi_msgstore_openentry($store, $entryid);
1291
1292
		if ($folder) {
1293
			$flag = DEL_ASSOCIATED;
1294
1295
			if ($hardDelete) {
1296
				$flag |= DELETE_HARD_DELETE;
1297
			}
1298
1299
			if ($emptySubFolders) {
1300
				$result = mapi_folder_emptyfolder($folder, $flag);
0 ignored issues
show
Unused Code introduced by
The assignment to $result is dead and can be removed.
Loading history...
1301
			}
1302
			else {
1303
				// Delete all items of selected folder without
1304
				// removing child folder and it's content.
1305
				// FIXME: it is effecting performance because mapi_folder_emptyfolder function not provide facility to
1306
				// remove only selected folder items without touching child folder and it's items.
1307
				// for more check KC-1268
1308
				$table = mapi_folder_getcontentstable($folder, MAPI_DEFERRED_ERRORS);
1309
				$rows = mapi_table_queryallrows($table, [PR_ENTRYID]);
1310
				$messages = [];
1311
				foreach ($rows as $row) {
1312
					array_push($messages, $row[PR_ENTRYID]);
1313
				}
1314
				$result = mapi_folder_deletemessages($folder, $messages, $flag);
1315
			}
1316
1317
			$folderProps = mapi_getprops($folder, [PR_ENTRYID, PR_STORE_ENTRYID]);
1318
			$result = true;
1319
		}
1320
1321
		return $result;
1322
	}
1323
1324
	/**
1325
	 * Copy or move a folder.
1326
	 *
1327
	 * @param object $store               MAPI Message Store Object
1328
	 * @param string $parentfolderentryid The parent entryid of the folder which will be copied or moved
1329
	 * @param string $sourcefolderentryid The entryid of the folder which will be copied or moved
1330
	 * @param string $destfolderentryid   The entryid of the folder which the folder will be copied or moved to
1331
	 * @param bool   $moveFolder          true - move folder, false - copy folder
1332
	 * @param array  $folderProps         reference to an array which will be filled with entryids
1333
	 * @param mixed  $deststore
1334
	 *
1335
	 * @return bool true if action succeeded, false if not
1336
	 */
1337
	public function copyFolder($store, $parentfolderentryid, $sourcefolderentryid, $destfolderentryid, $deststore, $moveFolder, &$folderProps) {
1338
		$result = false;
1339
		$sourceparentfolder = mapi_msgstore_openentry($store, $parentfolderentryid);
1340
		$destfolder = mapi_msgstore_openentry($deststore, $destfolderentryid);
1341
		if (!$this->isSpecialFolder($store, $sourcefolderentryid) && $sourceparentfolder && $destfolder && $deststore) {
1342
			$folder = mapi_msgstore_openentry($store, $sourcefolderentryid);
1343
			$props = mapi_getprops($folder, [PR_DISPLAY_NAME]);
1344
1345
			try {
1346
				/*
1347
				  * To decrease overload of checking for conflicting folder names on modification of every folder
1348
				  * we should first try to copy/move folder and if it returns MAPI_E_COLLISION then
1349
				  * only we should check for the conflicting folder names and generate a new name
1350
				  * and copy/move folder with the generated name.
1351
				  */
1352
				if ($moveFolder) {
1353
					mapi_folder_copyfolder($sourceparentfolder, $sourcefolderentryid, $destfolder, $props[PR_DISPLAY_NAME], FOLDER_MOVE);
1354
					$folderProps = mapi_getprops($folder, [PR_ENTRYID, PR_STORE_ENTRYID]);
1355
					// In some cases PR_PARENT_ENTRYID is not available in mapi_getprops, add it manually
1356
					$folderProps[PR_PARENT_ENTRYID] = $destfolderentryid;
1357
					$result = true;
1358
				}
1359
				else {
1360
					mapi_folder_copyfolder($sourceparentfolder, $sourcefolderentryid, $destfolder, $props[PR_DISPLAY_NAME], COPY_SUBFOLDERS);
1361
					$result = true;
1362
				}
1363
			}
1364
			catch (MAPIException $e) {
1365
				if ($e->getCode() == MAPI_E_COLLISION) {
1366
					$foldername = $this->checkFolderNameConflict($deststore, $destfolder, $props[PR_DISPLAY_NAME]);
1367
					if ($moveFolder) {
1368
						mapi_folder_copyfolder($sourceparentfolder, $sourcefolderentryid, $destfolder, $foldername, FOLDER_MOVE);
1369
						$folderProps = mapi_getprops($folder, [PR_ENTRYID, PR_STORE_ENTRYID]);
1370
						$result = true;
1371
					}
1372
					else {
1373
						mapi_folder_copyfolder($sourceparentfolder, $sourcefolderentryid, $destfolder, $foldername, COPY_SUBFOLDERS);
1374
						$result = true;
1375
					}
1376
				}
1377
				else {
1378
					// all other errors should be propagated to higher level exception handlers
1379
					throw $e;
1380
				}
1381
			}
1382
		}
1383
1384
		return $result;
1385
	}
1386
1387
	/**
1388
	 * Read MAPI table.
1389
	 *
1390
	 * This function performs various operations to open, setup, and read all rows from a MAPI table.
1391
	 *
1392
	 * The output from this function is an XML array structure which can be sent directly to XML serialisation.
1393
	 *
1394
	 * @param object $store        MAPI Message Store Object
1395
	 * @param string $entryid      The entryid of the folder to read the table from
1396
	 * @param array  $properties   The set of properties which will be read
1397
	 * @param array  $sort         The set properties which the table will be sort on (formatted as a MAPI sort order)
1398
	 * @param int    $start        Starting row at which to start reading rows
1399
	 * @param int    $rowcount     Number of rows which should be read
1400
	 * @param array  $restriction  Table restriction to apply to the table (formatted as MAPI restriction)
1401
	 * @param mixed  $getHierarchy
1402
	 * @param mixed  $flags
1403
	 *
1404
	 * @return array XML array structure with row data
1405
	 */
1406
	public function getTable($store, $entryid, $properties, $sort, $start, $rowcount = false, $restriction = false, $getHierarchy = false, $flags = MAPI_DEFERRED_ERRORS) {
1407
		$data = [];
1408
		$folder = mapi_msgstore_openentry($store, $entryid);
1409
1410
		if (!$folder) {
1411
			return $data;
1412
		}
1413
1414
		$table = $getHierarchy ? mapi_folder_gethierarchytable($folder, $flags) : mapi_folder_getcontentstable($folder, $flags);
1415
1416
		if (!$rowcount) {
0 ignored issues
show
Bug Best Practice introduced by
The expression $rowcount of type false|integer is loosely compared to false; this is ambiguous if the integer can be 0. You might want to explicitly use === false instead.

In PHP, under loose comparison (like ==, or !=, or switch conditions), values of different types might be equal.

For integer values, zero is a special case, in particular the following results might be unexpected:

0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
Loading history...
1417
			$rowcount = $GLOBALS['settings']->get('zarafa/v1/main/page_size', 50);
1418
		}
1419
1420
		if (is_array($restriction)) {
1421
			mapi_table_restrict($table, $restriction, TBL_BATCH);
1422
		}
1423
1424
		if (is_array($sort) && !empty($sort)) {
1425
			/*
1426
			 * If the sort array contains the PR_SUBJECT column we should change this to
1427
			 * PR_NORMALIZED_SUBJECT to make sure that when sorting on subjects: "sweet" and
1428
			 * "RE: sweet", the first one is displayed before the latter one. If the subject
1429
			 * is used for sorting the PR_MESSAGE_DELIVERY_TIME must be added as well as
1430
			 * Outlook behaves the same way in this case.
1431
			 */
1432
			if (isset($sort[PR_SUBJECT])) {
1433
				$sortReplace = [];
1434
				foreach ($sort as $key => $value) {
1435
					if ($key == PR_SUBJECT) {
1436
						$sortReplace[PR_NORMALIZED_SUBJECT] = $value;
1437
						$sortReplace[PR_MESSAGE_DELIVERY_TIME] = TABLE_SORT_DESCEND;
1438
					}
1439
					else {
1440
						$sortReplace[$key] = $value;
1441
					}
1442
				}
1443
				$sort = $sortReplace;
1444
			}
1445
1446
			mapi_table_sort($table, $sort, TBL_BATCH);
1447
		}
1448
1449
		$data["item"] = [];
1450
1451
		$rows = mapi_table_queryrows($table, $properties, $start, $rowcount);
1452
1453
		foreach ($rows as $row) {
1454
			$itemData = Conversion::mapMAPI2XML($properties, $row);
1455
1456
			// For ZARAFA type users the email_address properties are filled with the username
1457
			// Here we will copy that property to the *_username property for consistency with
1458
			// the getMessageProps() function
1459
			// We will not retrieve the real email address (like the getMessageProps function does)
1460
			// for all items because that would be a performance decrease!
1461
			if (isset($itemData['props']["sent_representing_email_address"])) {
1462
				$itemData['props']["sent_representing_username"] = $itemData['props']["sent_representing_email_address"];
1463
			}
1464
			if (isset($itemData['props']["sender_email_address"])) {
1465
				$itemData['props']["sender_username"] = $itemData['props']["sender_email_address"];
1466
			}
1467
			if (isset($itemData['props']["received_by_email_address"])) {
1468
				$itemData['props']["received_by_username"] = $itemData['props']["received_by_email_address"];
1469
			}
1470
1471
			array_push($data["item"], $itemData);
1472
		}
1473
1474
		// Update the page information
1475
		$data["page"] = [];
1476
		$data["page"]["start"] = $start;
1477
		$data["page"]["rowcount"] = $rowcount;
1478
		$data["page"]["totalrowcount"] = mapi_table_getrowcount($table);
1479
1480
		return $data;
1481
	}
1482
1483
	/**
1484
	 * Returns TRUE of the MAPI message only has inline attachments.
1485
	 *
1486
	 * @param mapimessage $message The MAPI message object to check
0 ignored issues
show
Bug introduced by
The type mapimessage was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
1487
	 *
1488
	 * @return bool TRUE if the item contains only inline attachments, FALSE otherwise
1489
	 *
1490
	 * @deprecated This function is not used, because it is much too slow to run on all messages in your inbox
1491
	 */
1492
	public function hasOnlyInlineAttachments($message) {
1493
		$attachmentTable = @mapi_message_getattachmenttable($message);
1494
		if (!$attachmentTable) {
1495
			return false;
1496
		}
1497
1498
		$attachments = @mapi_table_queryallrows($attachmentTable, [PR_ATTACHMENT_HIDDEN]);
1499
		if (empty($attachments)) {
1500
			return false;
1501
		}
1502
1503
		foreach ($attachments as $attachmentRow) {
1504
			if (!isset($attachmentRow[PR_ATTACHMENT_HIDDEN]) || !$attachmentRow[PR_ATTACHMENT_HIDDEN]) {
1505
				return false;
1506
			}
1507
		}
1508
1509
		return true;
1510
	}
1511
1512
	/**
1513
	 * Retrieve and convert body content of a message.
1514
	 *
1515
	 * This function performs the heavy lifting of decompressing RTF, converting
1516
	 * code pages and extracting both the HTML and plain text bodies. It can be
1517
	 * called independently to lazily fetch body data when required.
1518
	 *
1519
	 * @param object $message   The MAPI Message Object
1520
	 * @param bool   $html2text true - body will be converted from html to text,
1521
	 *                          false - html body will be returned
1522
	 *
1523
	 * @return array associative array containing keys 'body', 'html_body' and 'isHTML'
1524
	 */
1525
	public function getMessageBody($message, $html2text = false) {
1526
		$result = [
1527
			'body' => '',
1528
			'isHTML' => false,
1529
		];
1530
1531
		if (!$message) {
0 ignored issues
show
introduced by
$message is of type object, thus it always evaluated to true.
Loading history...
1532
			return $result;
1533
		}
1534
1535
		$plaintext = $this->isPlainText($message);
1536
		$tmpProps = mapi_getprops($message, [PR_BODY, PR_HTML]);
1537
1538
		if (empty($tmpProps[PR_HTML])) {
1539
			$tmpProps = mapi_getprops($message, [PR_BODY, PR_RTF_COMPRESSED]);
1540
			if (isset($tmpProps[PR_RTF_COMPRESSED])) {
1541
				$tmpProps[PR_HTML] = mapi_decompressrtf($tmpProps[PR_RTF_COMPRESSED]);
1542
			}
1543
		}
1544
1545
		$htmlcontent = '';
1546
		if (!$plaintext && isset($tmpProps[PR_HTML])) {
1547
			$cpprops = mapi_message_getprops($message, [PR_INTERNET_CPID]);
1548
			$codepage = $cpprops[PR_INTERNET_CPID] ?? 65001;
1549
			$htmlcontent = Conversion::convertCodepageStringToUtf8($codepage, $tmpProps[PR_HTML]);
1550
			if (!empty($htmlcontent)) {
1551
				if ($html2text) {
1552
					$htmlcontent = '';
1553
				}
1554
				else {
1555
					$result['isHTML'] = true;
1556
				}
1557
			}
1558
1559
			$htmlcontent = trim($htmlcontent, "\0");
1560
		}
1561
1562
		if (isset($tmpProps[PR_BODY])) {
1563
			// only open property if it exists
1564
			$result['body'] = trim((string) mapi_message_openproperty($message, PR_BODY), "\0");
1565
		}
1566
		elseif ($html2text && isset($tmpProps[PR_HTML])) {
1567
			$result['body'] = strip_tags((string) $tmpProps[PR_HTML]);
1568
		}
1569
1570
		if (!empty($htmlcontent)) {
1571
			$result['html_body'] = $htmlcontent;
1572
		}
1573
1574
		return $result;
1575
	}
1576
1577
	/**
1578
	 * Read message properties.
1579
	 *
1580
	 * Reads a message and returns the data as an XML array structure with all data from the message that is needed
1581
	 * to show a message (for example in the preview pane)
1582
	 *
1583
	 * @param object $store      MAPI Message Store Object
1584
	 * @param object $message    The MAPI Message Object
1585
	 * @param array  $properties Mapping of properties that should be read
1586
	 * @param bool   $html2text  true - body will be converted from html to text, false - html body will be returned
1587
	 * @param bool   $loadBody   true - fetch body content, false - skip body retrieval
1588
	 *
1589
	 * @return array item properties
1590
	 *
1591
	 * @todo Function name is misleading as it doesn't just get message properties
1592
	 */
1593
	public function getMessageProps($store, $message, $properties, $html2text = false, $loadBody = false) {
1594
		$props = [];
1595
1596
		if ($message) {
0 ignored issues
show
introduced by
$message is of type object, thus it always evaluated to true.
Loading history...
1597
			$itemprops = mapi_getprops($message, $properties);
1598
1599
			/* If necessary stream the property, if it's > 8KB */
1600
			if (isset($itemprops[PR_TRANSPORT_MESSAGE_HEADERS]) || propIsError(PR_TRANSPORT_MESSAGE_HEADERS, $itemprops) == MAPI_E_NOT_ENOUGH_MEMORY) {
1601
				$itemprops[PR_TRANSPORT_MESSAGE_HEADERS] = mapi_openproperty($message, PR_TRANSPORT_MESSAGE_HEADERS);
1602
			}
1603
1604
			$props = Conversion::mapMAPI2XML($properties, $itemprops);
1605
1606
			// Get actual SMTP address for sent_representing_email_address and received_by_email_address
1607
			$smtpprops = mapi_getprops($message, [PR_SENT_REPRESENTING_ENTRYID, PR_RECEIVED_BY_ENTRYID, PR_SENDER_ENTRYID]);
1608
1609
			if (isset($smtpprops[PR_SENT_REPRESENTING_ENTRYID])) {
1610
				try {
1611
					$user = mapi_ab_openentry($GLOBALS['mapisession']->getAddressbook(true), $smtpprops[PR_SENT_REPRESENTING_ENTRYID]);
1612
					if (isset($user)) {
1613
						$user_props = mapi_getprops($user, [PR_EMS_AB_THUMBNAIL_PHOTO]);
1614
						if (isset($user_props[PR_EMS_AB_THUMBNAIL_PHOTO])) {
1615
							$props["props"]['thumbnail_photo'] = "data:image/jpeg;base64," . base64_encode((string) $user_props[PR_EMS_AB_THUMBNAIL_PHOTO]);
1616
						}
1617
					}
1618
				}
1619
				catch (MAPIException) {
1620
					// do nothing
1621
				}
1622
			}
1623
1624
			/*
1625
			 * Check that we have PR_SENT_REPRESENTING_ENTRYID for the item, and also
1626
			 * Check that we have sent_representing_email_address property there in the message,
1627
			 * but for contacts we are not using sent_representing_* properties so we are not
1628
			 * getting it from the message. So basically this will be used for mail items only
1629
			 */
1630
			if (isset($smtpprops[PR_SENT_REPRESENTING_ENTRYID], $props["props"]["sent_representing_email_address"])) {
1631
				$props["props"]["sent_representing_username"] = $props["props"]["sent_representing_email_address"];
1632
				$sentRepresentingSearchKey = isset($props['props']['sent_representing_search_key']) ? hex2bin($props['props']['sent_representing_search_key']) : false;
1633
				$props["props"]["sent_representing_email_address"] = $this->getEmailAddress($smtpprops[PR_SENT_REPRESENTING_ENTRYID], $sentRepresentingSearchKey);
1634
			}
1635
1636
			if (isset($smtpprops[PR_SENDER_ENTRYID], $props["props"]["sender_email_address"])) {
1637
				$props["props"]["sender_username"] = $props["props"]["sender_email_address"];
1638
				$senderSearchKey = isset($props['props']['sender_search_key']) ? hex2bin($props['props']['sender_search_key']) : false;
1639
				$props["props"]["sender_email_address"] = $this->getEmailAddress($smtpprops[PR_SENDER_ENTRYID], $senderSearchKey);
1640
			}
1641
1642
			if (isset($smtpprops[PR_RECEIVED_BY_ENTRYID], $props["props"]["received_by_email_address"])) {
1643
				$props["props"]["received_by_username"] = $props["props"]["received_by_email_address"];
1644
				$receivedSearchKey = isset($props['props']['received_by_search_key']) ? hex2bin($props['props']['received_by_search_key']) : false;
1645
				$props["props"]["received_by_email_address"] = $this->getEmailAddress($smtpprops[PR_RECEIVED_BY_ENTRYID], $receivedSearchKey);
1646
			}
1647
1648
			$props['props']['isHTML'] = false;
1649
			$htmlcontent = null;
1650
			if ($loadBody) {
1651
				$body = $this->getMessageBody($message, $html2text);
1652
				$props['props'] = array_merge($props['props'], $body);
1653
				$htmlcontent = $body['html_body'] ?? null;
1654
			}
1655
1656
			// Get reply-to information, otherwise consider the sender to be the reply-to person.
1657
			$props['reply-to'] = ['item' => []];
1658
			$messageprops = mapi_getprops($message, [PR_REPLY_RECIPIENT_ENTRIES]);
1659
			if (isset($messageprops[PR_REPLY_RECIPIENT_ENTRIES])) {
1660
				$props['reply-to']['item'] = $this->readReplyRecipientEntry($messageprops[PR_REPLY_RECIPIENT_ENTRIES]);
1661
			}
1662
			if (!isset($messageprops[PR_REPLY_RECIPIENT_ENTRIES]) || count($props['reply-to']['item']) === 0) {
1663
				if (isset($props['props']['sent_representing_email_address']) && !empty($props['props']['sent_representing_email_address'])) {
1664
					$props['reply-to']['item'][] = [
1665
						'rowid' => 0,
1666
						'props' => [
1667
							'entryid' => $props['props']['sent_representing_entryid'],
1668
							'display_name' => $props['props']['sent_representing_name'],
1669
							'smtp_address' => $props['props']['sent_representing_email_address'],
1670
							'address_type' => $props['props']['sent_representing_address_type'],
1671
							'object_type' => MAPI_MAILUSER,
1672
							'search_key' => $props['props']['sent_representing_search_key'] ?? '',
1673
						],
1674
					];
1675
				}
1676
				elseif (!empty($props['props']['sender_email_address'])) {
1677
					$props['reply-to']['item'][] = [
1678
						'rowid' => 0,
1679
						'props' => [
1680
							'entryid' => $props['props']['sender_entryid'],
1681
							'display_name' => $props['props']['sender_name'],
1682
							'smtp_address' => $props['props']['sender_email_address'],
1683
							'address_type' => $props['props']['sender_address_type'],
1684
							'object_type' => MAPI_MAILUSER,
1685
							'search_key' => $props['props']['sender_search_key'],
1686
						],
1687
					];
1688
				}
1689
			}
1690
1691
			// Get recipients
1692
			$recipients = $GLOBALS["operations"]->getRecipientsInfo($message);
1693
			if (!empty($recipients)) {
1694
				$props["recipients"] = [
1695
					"item" => $recipients,
1696
				];
1697
			}
1698
1699
			// Get attachments
1700
			$attachments = $GLOBALS["operations"]->getAttachmentsInfo($message);
1701
			if (!empty($attachments)) {
1702
				$props["attachments"] = [
1703
					"item" => $attachments,
1704
				];
1705
				$cid_found = false;
1706
				foreach ($attachments as $attachment) {
1707
					if (isset($attachment["props"]["cid"])) {
1708
						$cid_found = true;
1709
					}
1710
				}
1711
				if ($loadBody && $cid_found === true && $htmlcontent !== null) {
1712
					preg_match_all('/src="cid:(.*)"/Uims', $htmlcontent, $matches);
1713
					if (count($matches) > 0) {
1714
						$search = [];
1715
						$replace = [];
1716
						foreach ($matches[1] as $match) {
1717
							$idx = -1;
1718
							foreach ($attachments as $key => $attachment) {
1719
								if (isset($attachment["props"]["cid"]) &&
1720
									strcasecmp($match, $attachment["props"]["cid"]) == 0) {
1721
									$idx = $key;
1722
									$num = $attachment["props"]["attach_num"];
1723
								}
1724
							}
1725
							if ($idx == -1) {
1726
								continue;
1727
							}
1728
							$attach = mapi_message_openattach($message, $num);
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $num does not seem to be defined for all execution paths leading up to this point.
Loading history...
1729
							if (empty($attach)) {
1730
								continue;
1731
							}
1732
							$attachprop = mapi_getprops($attach, [PR_ATTACH_DATA_BIN, PR_ATTACH_MIME_TAG]);
1733
							if (empty($attachprop) || !isset($attachprop[PR_ATTACH_DATA_BIN])) {
1734
								continue;
1735
							}
1736
							if (!isset($attachprop[PR_ATTACH_MIME_TAG])) {
1737
								$mime_tag = "text/plain";
1738
							}
1739
							else {
1740
								$mime_tag = $attachprop[PR_ATTACH_MIME_TAG];
1741
							}
1742
							$search[] = "src=\"cid:{$match}\"";
1743
							$replace[] = "src=\"data:{$mime_tag};base64," . base64_encode((string) $attachprop[PR_ATTACH_DATA_BIN]) . "\"";
1744
							unset($props["attachments"]["item"][$idx]);
1745
						}
1746
						$props["attachments"]["item"] = array_values($props["attachments"]["item"]);
1747
						$htmlcontent = str_replace($search, $replace, $htmlcontent);
1748
						$props["props"]["html_body"] = $htmlcontent;
1749
					}
1750
				}
1751
			}
1752
1753
			// for distlists, we need to get members data
1754
			if (isset($props["props"]["oneoff_members"], $props["props"]["members"])) {
1755
				// remove non-client props
1756
				unset($props["props"]["members"], $props["props"]["oneoff_members"]);
1757
1758
				// get members
1759
				$members = $GLOBALS["operations"]->getMembersFromDistributionList($store, $message, $properties);
1760
				if (!empty($members)) {
1761
					$props["members"] = [
1762
						"item" => $members,
1763
					];
1764
				}
1765
			}
1766
		}
1767
1768
		return $props;
1769
	}
1770
1771
	/**
1772
	 * Get the email address either from entryid or search key. Function is helpful
1773
	 * to retrieve the email address of already deleted contact which is use as a
1774
	 * recipient in message.
1775
	 *
1776
	 * @param string      $entryId   the entryId of an item/recipient
1777
	 * @param bool|string $searchKey then search key of an item/recipient
1778
	 *
1779
	 * @return string email address if found else return empty string
1780
	 */
1781
	public function getEmailAddress($entryId, $searchKey = false) {
1782
		$emailAddress = $this->getEmailAddressFromEntryID($entryId);
1783
		if (empty($emailAddress) && $searchKey !== false) {
1784
			$emailAddress = $this->getEmailAddressFromSearchKey($searchKey);
0 ignored issues
show
Bug introduced by
It seems like $searchKey can also be of type true; however, parameter $searchKey of Operations::getEmailAddressFromSearchKey() does only seem to accept string, maybe add an additional type check? ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

1784
			$emailAddress = $this->getEmailAddressFromSearchKey(/** @scrutinizer ignore-type */ $searchKey);
Loading history...
1785
		}
1786
1787
		return $emailAddress;
1788
	}
1789
1790
	/**
1791
	 * Get and convert properties of a message into an XML array structure.
1792
	 *
1793
	 * @param object $item       The MAPI Object
1794
	 * @param array  $properties Mapping of properties that should be read
1795
	 *
1796
	 * @return array XML array structure
1797
	 *
1798
	 * @todo Function name is misleading, especially compared to getMessageProps()
1799
	 */
1800
	public function getProps($item, $properties) {
1801
		$props = [];
1802
1803
		if ($item) {
0 ignored issues
show
introduced by
$item is of type object, thus it always evaluated to true.
Loading history...
1804
			$itemprops = mapi_getprops($item, $properties);
1805
			$props = Conversion::mapMAPI2XML($properties, $itemprops);
1806
		}
1807
1808
		return $props;
1809
	}
1810
1811
	/**
1812
	 * Get embedded message data.
1813
	 *
1814
	 * Returns the same data as getMessageProps, but then for a specific sub/sub/sub message
1815
	 * of a MAPI message.
1816
	 *
1817
	 * @param object $store         MAPI Message Store Object
1818
	 * @param object $message       MAPI Message Object
1819
	 * @param array  $properties    a set of properties which will be selected
1820
	 * @param array  $parentMessage MAPI Message Object of parent
1821
	 * @param array  $attach_num    a list of attachment numbers (aka 2,1 means 'attachment nr 1 of attachment nr 2')
1822
	 *
1823
	 * @return array item XML array structure of the embedded message
1824
	 */
1825
	public function getEmbeddedMessageProps($store, $message, $properties, $parentMessage, $attach_num) {
1826
		$msgprops = mapi_getprops($message, [PR_MESSAGE_CLASS]);
1827
1828
		$html2text = match ($msgprops[PR_MESSAGE_CLASS]) {
1829
			'IPM.Note' => false,
1830
			default => true,
1831
		};
1832
1833
		$props = $this->getMessageProps($store, $message, $properties, $html2text, true);
1834
1835
		// sub message will not be having entryid, so use parent's entryid
1836
		$parentProps = mapi_getprops($parentMessage, [PR_ENTRYID, PR_PARENT_ENTRYID, PR_STORE_ENTRYID]);
1837
		$props['entryid'] = bin2hex((string) $parentProps[PR_ENTRYID]);
1838
		$props['parent_entryid'] = bin2hex((string) $parentProps[PR_PARENT_ENTRYID]);
1839
		$props['store_entryid'] = bin2hex((string) $parentProps[PR_STORE_ENTRYID]);
1840
		$props['attach_num'] = $attach_num;
1841
1842
		return $props;
1843
	}
1844
1845
	/**
1846
	 * Create a MAPI message.
1847
	 *
1848
	 * @param object $store         MAPI Message Store Object
1849
	 * @param string $parententryid The entryid of the folder in which the new message is to be created
1850
	 *
1851
	 * @return mapimessage Created MAPI message resource
1852
	 */
1853
	public function createMessage($store, $parententryid) {
1854
		$folder = mapi_msgstore_openentry($store, $parententryid);
1855
1856
		return mapi_folder_createmessage($folder);
1857
	}
1858
1859
	/**
1860
	 * Open a MAPI message.
1861
	 *
1862
	 * @param object $store       MAPI Message Store Object
1863
	 * @param string $entryid     entryid of the message
1864
	 * @param array  $attach_num  a list of attachment numbers (aka 2,1 means 'attachment nr 1 of attachment nr 2')
1865
	 * @param bool   $parse_smime (optional) call parse_smime on the opened message or not
1866
	 *
1867
	 * @return object MAPI Message
1868
	 */
1869
	public function openMessage($store, $entryid, $attach_num = false, $parse_smime = false) {
1870
		$message = mapi_msgstore_openentry($store, $entryid);
1871
1872
		// Needed for S/MIME messages with embedded message attachments
1873
		if ($parse_smime) {
1874
			parse_smime($store, $message);
1875
		}
1876
1877
		if ($message && $attach_num) {
1878
			for ($index = 0, $count = count($attach_num); $index < $count; ++$index) {
1879
				// attach_num cannot have value of -1
1880
				// if we get that then we are trying to open an embedded message which
1881
				// is not present in the attachment table to parent message (because parent message is unsaved yet)
1882
				// so return the message which is opened using entryid which will point to actual message which is
1883
				// attached as embedded message
1884
				if ($attach_num[$index] === -1) {
1885
					return $message;
1886
				}
1887
1888
				$attachment = mapi_message_openattach($message, $attach_num[$index]);
1889
1890
				if ($attachment) {
1891
					$message = mapi_attach_openobj($attachment);
1892
				}
1893
				else {
1894
					return false;
0 ignored issues
show
Bug Best Practice introduced by
The expression return false returns the type false which is incompatible with the documented return type object.
Loading history...
1895
				}
1896
			}
1897
		}
1898
1899
		return $message;
1900
	}
1901
1902
	/**
1903
	 * Save a MAPI message.
1904
	 *
1905
	 * The to-be-saved message can be of any type, including e-mail items, appointments, contacts, etc. The message may be pre-existing
1906
	 * or it may be a new message.
1907
	 *
1908
	 * The dialog_attachments parameter represents a unique ID which for the dialog in the client for which this function was called; This
1909
	 * is used as follows; Whenever a user uploads an attachment, the attachment is stored in a temporary place on the server. At the same time,
1910
	 * the temporary server location of the attachment is saved in the session information, accompanied by the $dialog_attachments unique ID. This
1911
	 * way, when we save the message into MAPI, we know which attachment was previously uploaded ready for this message, because when the user saves
1912
	 * the message, we pass the same $dialog_attachments ID as when we uploaded the file.
1913
	 *
1914
	 * @param object      $store                     MAPI Message Store Object
1915
	 * @param binary      $entryid                   entryid of the message
0 ignored issues
show
Bug introduced by
The type binary was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
1916
	 * @param binary      $parententryid             Parent entryid of the message
1917
	 * @param array       $props                     The MAPI properties to be saved
1918
	 * @param array       $messageProps              reference to an array which will be filled with PR_ENTRYID and PR_STORE_ENTRYID of the saved message
1919
	 * @param array       $recipients                XML array structure of recipients for the recipient table
1920
	 * @param array       $attachments               attachments array containing unique check number which checks if attachments should be added
1921
	 * @param array       $propertiesToDelete        Properties specified in this array are deleted from the MAPI message
1922
	 * @param MAPIMessage $copyFromMessage           resource of the message from which we should
0 ignored issues
show
Bug introduced by
The type MAPIMessage was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
1923
	 *                                               copy attachments and/or recipients to the current message
1924
	 * @param bool        $copyAttachments           if set we copy all attachments from the $copyFromMessage
1925
	 * @param bool        $copyRecipients            if set we copy all recipients from the $copyFromMessage
1926
	 * @param bool        $copyInlineAttachmentsOnly if true then copy only inline attachments
1927
	 * @param bool        $saveChanges               if true then save all change in mapi message
1928
	 * @param bool        $send                      true if this function is called from submitMessage else false
1929
	 * @param bool        $isPlainText               if true then message body will be generated using PR_BODY otherwise PR_HTML will be used in saveMessage() function
1930
	 *
1931
	 * @return mapimessage Saved MAPI message resource
1932
	 */
1933
	public function saveMessage($store, $entryid, $parententryid, $props, &$messageProps, $recipients = [], $attachments = [], $propertiesToDelete = [], $copyFromMessage = false, $copyAttachments = false, $copyRecipients = false, $copyInlineAttachmentsOnly = false, $saveChanges = true, $send = false, $isPlainText = false) {
1934
		$message = false;
1935
1936
		// Check if an entryid is set, otherwise create a new message
1937
		if ($entryid && !empty($entryid)) {
1938
			$message = $this->openMessage($store, $entryid);
1939
		}
1940
		else {
1941
			$message = $this->createMessage($store, $parententryid);
1942
		}
1943
1944
		if ($message) {
1945
			$property = false;
1946
			$body = "";
1947
1948
			// Check if the body is set.
1949
			if (isset($props[PR_BODY])) {
1950
				$body = $props[PR_BODY];
1951
				$property = PR_BODY;
1952
				$bodyPropertiesToDelete = [PR_HTML, PR_RTF_COMPRESSED];
1953
1954
				if (isset($props[PR_HTML])) {
1955
					$subject = '';
1956
					if (isset($props[PR_SUBJECT])) {
1957
						$subject = $props[PR_SUBJECT];
1958
					// If subject is not updated we need to get it from the message
1959
					}
1960
					else {
1961
						$subjectProp = mapi_getprops($message, [PR_SUBJECT]);
1962
						if (isset($subjectProp[PR_SUBJECT])) {
1963
							$subject = $subjectProp[PR_SUBJECT];
1964
						}
1965
					}
1966
					$body = $this->generateBodyHTML($isPlainText ? $props[PR_BODY] : $props[PR_HTML], $subject);
1967
					$property = PR_HTML;
1968
					$bodyPropertiesToDelete = [PR_BODY, PR_RTF_COMPRESSED];
1969
					unset($props[PR_HTML]);
1970
				}
1971
				unset($props[PR_BODY]);
1972
1973
				$propertiesToDelete = array_unique(array_merge($propertiesToDelete, $bodyPropertiesToDelete));
1974
			}
1975
1976
			if (!isset($props[PR_SENT_REPRESENTING_ENTRYID]) &&
1977
			   isset($props[PR_SENT_REPRESENTING_EMAIL_ADDRESS]) && !empty($props[PR_SENT_REPRESENTING_EMAIL_ADDRESS]) &&
1978
			   isset($props[PR_SENT_REPRESENTING_ADDRTYPE]) && !empty($props[PR_SENT_REPRESENTING_ADDRTYPE]) &&
1979
			   isset($props[PR_SENT_REPRESENTING_NAME]) && !empty($props[PR_SENT_REPRESENTING_NAME])) {
1980
				// Set FROM field properties
1981
				$props[PR_SENT_REPRESENTING_ENTRYID] = mapi_createoneoff($props[PR_SENT_REPRESENTING_NAME], $props[PR_SENT_REPRESENTING_ADDRTYPE], $props[PR_SENT_REPRESENTING_EMAIL_ADDRESS]);
1982
			}
1983
1984
			/*
1985
			 * Delete PR_SENT_REPRESENTING_ENTRYID and PR_SENT_REPRESENTING_SEARCH_KEY properties, if PR_SENT_REPRESENTING_* properties are configured with empty string.
1986
			 * Because, this is the case while user removes recipient from FROM field and send that particular draft without saving it.
1987
			 */
1988
			if (isset($props[PR_SENT_REPRESENTING_EMAIL_ADDRESS]) && empty($props[PR_SENT_REPRESENTING_EMAIL_ADDRESS]) &&
1989
			   isset($props[PR_SENT_REPRESENTING_ADDRTYPE]) && empty($props[PR_SENT_REPRESENTING_ADDRTYPE]) &&
1990
			   isset($props[PR_SENT_REPRESENTING_NAME]) && empty($props[PR_SENT_REPRESENTING_NAME])) {
1991
				array_push($propertiesToDelete, PR_SENT_REPRESENTING_ENTRYID, PR_SENT_REPRESENTING_SEARCH_KEY);
1992
			}
1993
1994
			// remove mv properties when needed
1995
			foreach ($props as $propTag => $propVal) {
1996
				switch (mapi_prop_type($propTag)) {
1997
					case PT_SYSTIME:
1998
						// Empty PT_SYSTIME values mean they should be deleted (there is no way to set an empty PT_SYSTIME)
1999
						// case PT_STRING8:	// not enabled at this moment
2000
						// Empty Strings
2001
					case PT_MV_LONG:
2002
						// Empty multivalued long
2003
						if (empty($propVal)) {
2004
							$propertiesToDelete[] = $propTag;
2005
						}
2006
						break;
2007
2008
					case PT_MV_STRING8:
2009
						// Empty multivalued string
2010
						if (empty($propVal)) {
2011
							$props[$propTag] = [];
2012
						}
2013
						break;
2014
				}
2015
			}
2016
2017
			foreach ($propertiesToDelete as $prop) {
2018
				unset($props[$prop]);
2019
			}
2020
2021
			// Set the properties
2022
			mapi_setprops($message, $props);
2023
2024
			// Delete the properties we don't need anymore
2025
			mapi_deleteprops($message, $propertiesToDelete);
2026
2027
			if ($property != false) {
2028
				// Stream the body to the PR_BODY or PR_HTML property
2029
				$stream = mapi_openproperty($message, $property, IID_IStream, 0, MAPI_CREATE | MAPI_MODIFY);
2030
				mapi_stream_setsize($stream, strlen((string) $body));
2031
				mapi_stream_write($stream, $body);
2032
				mapi_stream_commit($stream);
2033
			}
2034
2035
			/*
2036
			 * Save recipients
2037
			 *
2038
			 * If we are sending mail from delegator's folder, then we need to copy
2039
			 * all recipients from original message first - need to pass message
2040
			 *
2041
			 * if delegate has added or removed any recipients then they will be
2042
			 * added/removed using recipients array.
2043
			 */
2044
			if ($copyRecipients !== false && $copyFromMessage !== false) {
2045
				$this->copyRecipients($message, $copyFromMessage);
2046
			}
2047
2048
			$this->setRecipients($message, $recipients, $send);
2049
2050
			// Save the attachments with the $dialog_attachments, for attachments we have to obtain
2051
			// some additional information from the state.
2052
			if (!empty($attachments)) {
2053
				$attachment_state = new AttachmentState();
2054
				$attachment_state->open();
2055
2056
				if ($copyFromMessage !== false) {
2057
					$this->copyAttachments($message, $attachments, $copyFromMessage, $copyInlineAttachmentsOnly, $attachment_state);
0 ignored issues
show
Bug introduced by
$attachments of type array is incompatible with the type string expected by parameter $attachments of Operations::copyAttachments(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

2057
					$this->copyAttachments($message, /** @scrutinizer ignore-type */ $attachments, $copyFromMessage, $copyInlineAttachmentsOnly, $attachment_state);
Loading history...
2058
				}
2059
2060
				$this->setAttachments($message, $attachments, $attachment_state);
2061
2062
				$attachment_state->close();
2063
			}
2064
2065
			// Set 'hideattachments' if message has only inline attachments.
2066
			$properties = $GLOBALS['properties']->getMailProperties();
2067
			if ($this->hasOnlyInlineAttachments($message)) {
0 ignored issues
show
Deprecated Code introduced by
The function Operations::hasOnlyInlineAttachments() has been deprecated: This function is not used, because it is much too slow to run on all messages in your inbox ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-deprecated  annotation

2067
			if (/** @scrutinizer ignore-deprecated */ $this->hasOnlyInlineAttachments($message)) {

This function has been deprecated. The supplier of the function has supplied an explanatory message.

The explanatory message should give you some clue as to whether and when the function will be removed and what other function to use instead.

Loading history...
2068
				mapi_setprops($message, [$properties['hide_attachments'] => true]);
2069
			}
2070
			else {
2071
				mapi_deleteprops($message, [$properties['hide_attachments']]);
2072
			}
2073
2074
			$this->convertInlineImage($message);
2075
			// Save changes
2076
			if ($saveChanges) {
2077
				mapi_savechanges($message);
2078
			}
2079
2080
			// Get the PR_ENTRYID, PR_PARENT_ENTRYID and PR_STORE_ENTRYID properties of this message
2081
			$messageProps = mapi_getprops($message, [PR_ENTRYID, PR_PARENT_ENTRYID, PR_STORE_ENTRYID]);
2082
		}
2083
2084
		return $message;
2085
	}
2086
2087
	/**
2088
	 * Save an appointment item.
2089
	 *
2090
	 * This is basically the same as saving any other type of message with the added complexity that
2091
	 * we support saving exceptions to recurrence here. This means that if the client sends a basedate
2092
	 * in the action, that we will attempt to open an existing exception and change that, and if that
2093
	 * fails, create a new exception with the specified data.
2094
	 *
2095
	 * @param mapistore $store                       MAPI store of the message
0 ignored issues
show
Bug introduced by
The type mapistore was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
2096
	 * @param string    $entryid                     entryid of the message
2097
	 * @param string    $parententryid               Parent entryid of the message (folder entryid, NOT message entryid)
2098
	 * @param array     $action                      Action array containing XML request
2099
	 * @param string    $actionType                  The action type which triggered this action
2100
	 * @param bool      $directBookingMeetingRequest Indicates if a Meeting Request should use direct booking or not. Defaults to true.
2101
	 *
2102
	 * @return array of PR_ENTRYID, PR_PARENT_ENTRYID and PR_STORE_ENTRYID properties of modified item
2103
	 */
2104
	public function saveAppointment($store, $entryid, $parententryid, $action, $actionType = 'save', $directBookingMeetingRequest = true) {
2105
		$messageProps = [];
2106
		// It stores the values that is exception allowed or not false -> not allowed
2107
		$isExceptionAllowed = true;
2108
		$delete = $actionType == 'delete';	// Flag for MeetingRequest Class whether to send update or cancel mail.
2109
		$basedate = false;	// Flag for MeetingRequest Class whether to send an exception or not.
2110
		$isReminderTimeAllowed = true;	// Flag to check reminder minutes is in range of the occurrences
2111
		$properties = $GLOBALS['properties']->getAppointmentProperties();
2112
		$send = false;
2113
		$oldProps = [];
2114
		$pasteRecord = false;
2115
2116
		if (isset($action['message_action'], $action['message_action']['send'])) {
2117
			$send = $action['message_action']['send'];
2118
		}
2119
2120
		if (isset($action['message_action'], $action['message_action']['paste'])) {
2121
			$pasteRecord = true;
2122
		}
2123
2124
		if (!empty($action['recipients'])) {
2125
			$recips = $action['recipients'];
2126
		}
2127
		else {
2128
			$recips = false;
2129
		}
2130
2131
		// Set PidLidAppointmentTimeZoneDefinitionStartDisplay and
2132
		// PidLidAppointmentTimeZoneDefinitionEndDisplay so that the allday
2133
		// events are displayed correctly
2134
		if (!empty($action['props']['timezone_iana'])) {
2135
			try {
2136
				$tzdef = mapi_ianatz_to_tzdef($action['props']['timezone_iana']);
2137
			}
2138
			catch (Exception) {
0 ignored issues
show
Coding Style Comprehensibility introduced by
Consider adding a comment why this CATCH block is empty.
Loading history...
2139
			}
2140
			if ($tzdef !== false) {
2141
				$action['props']['tzdefstart'] = $action['props']['tzdefend'] = bin2hex($tzdef);
2142
				if (isset($action['props']['recurring']) && $action['props']['recurring'] == true) {
2143
					$action['props']['tzdefrecur'] = $action['props']['tzdefstart'];
2144
				}
2145
			}
2146
		}
2147
2148
		if ($store && $parententryid) {
2149
			// @FIXME: check for $action['props'] array
2150
			if (isset($entryid) && $entryid) {
2151
				// Modify existing or add/change exception
2152
				$message = mapi_msgstore_openentry($store, $entryid);
2153
2154
				if ($message) {
2155
					$props = mapi_getprops($message, $properties);
0 ignored issues
show
Unused Code introduced by
The assignment to $props is dead and can be removed.
Loading history...
2156
					// Do not update timezone information if the appointment times haven't changed
2157
					if (!isset($action['props']['commonstart']) &&
2158
						!isset($action['props']['commonend']) &&
2159
						!isset($action['props']['startdate']) &&
2160
						!isset($action['props']['enddate'])
2161
					) {
2162
						unset($action['props']['tzdefstart'], $action['props']['tzdefend'], $action['props']['tzdefrecur']);
2163
					}
2164
					// Check if appointment is an exception to a recurring item
2165
					if (isset($action['basedate']) && $action['basedate'] > 0) {
2166
						// Create recurrence object
2167
						$recurrence = new Recurrence($store, $message);
0 ignored issues
show
Bug introduced by
The type Recurrence was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
2168
2169
						$basedate = $action['basedate'];
2170
						$exceptionatt = $recurrence->getExceptionAttachment($basedate);
2171
						if ($exceptionatt) {
2172
							// get properties of existing exception.
2173
							$exceptionattProps = mapi_getprops($exceptionatt, [PR_ATTACH_NUM]);
2174
							$attach_num = $exceptionattProps[PR_ATTACH_NUM];
2175
						}
2176
2177
						if ($delete === true) {
2178
							$isExceptionAllowed = $recurrence->createException([], $basedate, true);
2179
						}
2180
						else {
2181
							$exception_recips = [];
2182
							if (isset($recips['add'])) {
2183
								$savedUnsavedRecipients = [];
2184
								foreach ($recips["add"] as $recip) {
2185
									$savedUnsavedRecipients["unsaved"][] = $recip;
2186
								}
2187
								// convert all local distribution list members to ideal recipient.
2188
								$members = $this->convertLocalDistlistMembersToRecipients($savedUnsavedRecipients);
2189
2190
								$recips['add'] = $members['add'];
2191
								$exception_recips['add'] = $this->createRecipientList($recips['add'], 'add', true, true);
2192
							}
2193
							if (isset($recips['remove'])) {
2194
								$exception_recips['remove'] = $this->createRecipientList($recips['remove'], 'remove');
2195
							}
2196
							if (isset($recips['modify'])) {
2197
								$exception_recips['modify'] = $this->createRecipientList($recips['modify'], 'modify', true, true);
2198
							}
2199
2200
							if (isset($action['props']['reminder_minutes'], $action['props']['startdate'])) {
2201
								$isReminderTimeAllowed = $recurrence->isValidReminderTime($basedate, $action['props']['reminder_minutes'], $action['props']['startdate']);
2202
							}
2203
2204
							// As the reminder minutes occurs before other occurrences don't modify the item.
2205
							if ($isReminderTimeAllowed) {
2206
								if ($recurrence->isException($basedate)) {
2207
									$oldProps = $recurrence->getExceptionProperties($recurrence->getChangeException($basedate));
2208
2209
									$isExceptionAllowed = $recurrence->modifyException(Conversion::mapXML2MAPI($properties, $action['props']), $basedate, $exception_recips);
2210
								}
2211
								else {
2212
									$oldProps[$properties['startdate']] = $recurrence->getOccurrenceStart($basedate);
2213
									$oldProps[$properties['duedate']] = $recurrence->getOccurrenceEnd($basedate);
2214
2215
									$isExceptionAllowed = $recurrence->createException(Conversion::mapXML2MAPI($properties, $action['props']), $basedate, false, $exception_recips);
2216
								}
2217
								mapi_savechanges($message);
2218
							}
2219
						}
2220
					}
2221
					else {
2222
						$oldProps = mapi_getprops($message, [$properties['startdate'], $properties['duedate']]);
2223
						// Modifying non-exception (the series) or normal appointment item
2224
						$message = $GLOBALS['operations']->saveMessage($store, $entryid, $parententryid, Conversion::mapXML2MAPI($properties, $action['props']), $messageProps, $recips ?: [], $action['attachments'] ?? [], [], false, false, false, false, false, false, $send);
2225
2226
						$recurrenceProps = mapi_getprops($message, [$properties['startdate_recurring'], $properties['enddate_recurring'], $properties["recurring"]]);
2227
						// Check if the meeting is recurring
2228
						if ($recips && $recurrenceProps[$properties["recurring"]] && isset($recurrenceProps[$properties['startdate_recurring']], $recurrenceProps[$properties['enddate_recurring']])) {
2229
							// If recipient of meeting is modified than that modification needs to be applied
2230
							// to recurring exception as well, if any.
2231
							$exception_recips = [];
2232
							if (isset($recips['add'])) {
2233
								$exception_recips['add'] = $this->createRecipientList($recips['add'], 'add', true, true);
2234
							}
2235
							if (isset($recips['remove'])) {
2236
								$exception_recips['remove'] = $this->createRecipientList($recips['remove'], 'remove');
2237
							}
2238
							if (isset($recips['modify'])) {
2239
								$exception_recips['modify'] = $this->createRecipientList($recips['modify'], 'modify', true, true);
2240
							}
2241
2242
							// Create recurrence object
2243
							$recurrence = new Recurrence($store, $message);
2244
2245
							$recurItems = $recurrence->getItems($recurrenceProps[$properties['startdate_recurring']], $recurrenceProps[$properties['enddate_recurring']]);
2246
2247
							foreach ($recurItems as $recurItem) {
2248
								if (isset($recurItem["exception"])) {
2249
									$recurrence->modifyException([], $recurItem["basedate"], $exception_recips);
2250
								}
2251
							}
2252
						}
2253
2254
						// Only save recurrence if it has been changed by the user (because otherwise we'll reset
2255
						// the exceptions)
2256
						if (isset($action['props']['recurring_reset']) && $action['props']['recurring_reset'] == true) {
2257
							$recur = new Recurrence($store, $message);
2258
2259
							if (isset($action['props']['timezone'])) {
2260
								$tzprops = ['timezone', 'timezonedst', 'dststartmonth', 'dststartweek', 'dststartday', 'dststarthour', 'dstendmonth', 'dstendweek', 'dstendday', 'dstendhour'];
2261
2262
								// Get timezone info
2263
								$tz = [];
2264
								foreach ($tzprops as $tzprop) {
2265
									$tz[$tzprop] = $action['props'][$tzprop];
2266
								}
2267
							}
2268
2269
							/**
2270
							 * Check if any recurrence property is missing, if yes then prepare
2271
							 * the set of properties required to update the recurrence. For more info
2272
							 * please refer detailed description of parseRecurrence function of
2273
							 * BaseRecurrence class".
2274
							 *
2275
							 * Note : this is a special case of changing the time of
2276
							 * recurrence meeting from scheduling tab.
2277
							 */
2278
							$recurrence = $recur->getRecurrence();
2279
							if (isset($recurrence)) {
2280
								unset($recurrence['changed_occurrences'], $recurrence['deleted_occurrences']);
2281
2282
								foreach ($recurrence as $key => $value) {
2283
									if (!isset($action['props'][$key])) {
2284
										$action['props'][$key] = $value;
2285
									}
2286
								}
2287
							}
2288
							// Act like the 'props' are the recurrence pattern; it has more information but that
2289
							// is ignored
2290
							$recur->setRecurrence($tz ?? false, $action['props']);
2291
						}
2292
					}
2293
2294
					// Get the properties of the main object of which the exception was changed, and post
2295
					// that message as being modified. This will cause the update function to update all
2296
					// occurrences of the item to the client
2297
					$messageProps = mapi_getprops($message, [PR_ENTRYID, PR_PARENT_ENTRYID, PR_STORE_ENTRYID]);
2298
2299
					// if opened appointment is exception then it will add
2300
					// the attach_num and basedate in messageProps.
2301
					if (isset($attach_num)) {
2302
						$messageProps[PR_ATTACH_NUM] = [$attach_num];
2303
						$messageProps[$properties["basedate"]] = $action['basedate'];
2304
					}
2305
				}
2306
			}
2307
			else {
2308
				$tz = null;
2309
				$hasRecipient = false;
2310
				$copyAttachments = false;
2311
				$sourceRecord = false;
2312
				if (isset($action['message_action'], $action['message_action']['source_entryid'])) {
2313
					$sourceEntryId = $action['message_action']['source_entryid'];
2314
					$sourceStoreEntryId = $action['message_action']['source_store_entryid'];
2315
2316
					$sourceStore = $GLOBALS['mapisession']->openMessageStore(hex2bin((string) $sourceStoreEntryId));
2317
					$sourceRecord = mapi_msgstore_openentry($sourceStore, hex2bin($sourceEntryId));
2318
					if ($pasteRecord) {
2319
						$sourceRecordProps = mapi_getprops($sourceRecord, [$properties["meeting"], $properties["responsestatus"]]);
2320
						// Don't copy recipient if source record is received message.
2321
						if ($sourceRecordProps[$properties["meeting"]] === olMeeting &&
2322
							$sourceRecordProps[$properties["meeting"]] === olResponseOrganized) {
2323
							$table = mapi_message_getrecipienttable($sourceRecord);
2324
							$hasRecipient = mapi_table_getrowcount($table) > 0;
2325
						}
2326
					}
2327
					else {
2328
						$copyAttachments = true;
2329
						// Set sender of new Appointment.
2330
						$this->setSenderAddress($store, $action);
2331
					}
2332
				}
2333
				else {
2334
					// Set sender of new Appointment.
2335
					$this->setSenderAddress($store, $action);
2336
				}
2337
2338
				$message = $this->saveMessage($store, $entryid, $parententryid, Conversion::mapXML2MAPI($properties, $action['props']), $messageProps, $recips ?: [], $action['attachments'] ?? [], [], $sourceRecord, $copyAttachments, $hasRecipient, false, false, false, $send);
0 ignored issues
show
Bug introduced by
$parententryid of type string is incompatible with the type binary expected by parameter $parententryid of Operations::saveMessage(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

2338
				$message = $this->saveMessage($store, $entryid, /** @scrutinizer ignore-type */ $parententryid, Conversion::mapXML2MAPI($properties, $action['props']), $messageProps, $recips ?: [], $action['attachments'] ?? [], [], $sourceRecord, $copyAttachments, $hasRecipient, false, false, false, $send);
Loading history...
2339
2340
				if (isset($action['props']['timezone'])) {
2341
					$tzprops = ['timezone', 'timezonedst', 'dststartmonth', 'dststartweek', 'dststartday', 'dststarthour', 'dstendmonth', 'dstendweek', 'dstendday', 'dstendhour'];
2342
2343
					// Get timezone info
2344
					$tz = [];
2345
					foreach ($tzprops as $tzprop) {
2346
						$tz[$tzprop] = $action['props'][$tzprop];
2347
					}
2348
				}
2349
2350
				// Set recurrence
2351
				if (isset($action['props']['recurring']) && $action['props']['recurring'] == true) {
2352
					$recur = new Recurrence($store, $message);
2353
					$recur->setRecurrence($tz, $action['props']);
2354
				}
2355
			}
2356
		}
2357
2358
		$result = false;
2359
		// Check to see if it should be sent as a meeting request
2360
		if ($send === true && $isExceptionAllowed) {
2361
			$savedUnsavedRecipients = [];
2362
			$remove = [];
2363
			if (!isset($action['basedate'])) {
2364
				// retrieve recipients from saved message
2365
				$savedRecipients = $GLOBALS['operations']->getRecipientsInfo($message);
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $message does not seem to be defined for all execution paths leading up to this point.
Loading history...
2366
				foreach ($savedRecipients as $recipient) {
2367
					$savedUnsavedRecipients["saved"][] = $recipient['props'];
2368
				}
2369
2370
				// retrieve removed recipients.
2371
				if (!empty($recips) && !empty($recips["remove"])) {
2372
					$remove = $recips["remove"];
2373
				}
2374
2375
				// convert all local distribution list members to ideal recipient.
2376
				$members = $this->convertLocalDistlistMembersToRecipients($savedUnsavedRecipients, $remove);
2377
2378
				// Before sending meeting request we set the recipient to message
2379
				// which are converted from local distribution list members.
2380
				$this->setRecipients($message, $members);
2381
			}
2382
2383
			$request = new Meetingrequest($store, $message, $GLOBALS['mapisession']->getSession(), $directBookingMeetingRequest);
0 ignored issues
show
Bug introduced by
The type Meetingrequest was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
2384
2385
			/*
2386
			 * check write access for delegate, make sure that we will not send meeting request
2387
			 * if we don't have permission to save calendar item
2388
			 */
2389
			if ($request->checkFolderWriteAccess($parententryid, $store) !== true) {
2390
				// Throw an exception that we don't have write permissions on calendar folder,
2391
				// error message will be filled by module
2392
				throw new MAPIException(null, MAPI_E_NO_ACCESS);
2393
			}
2394
2395
			$request->updateMeetingRequest($basedate);
2396
2397
			$isRecurrenceChanged = isset($action['props']['recurring_reset']) && $action['props']['recurring_reset'] == true;
2398
			$request->checkSignificantChanges($oldProps, $basedate, $isRecurrenceChanged);
2399
2400
			// Update extra body information
2401
			if (isset($action['message_action']['meetingTimeInfo']) && !empty($action['message_action']['meetingTimeInfo'])) {
2402
				// Append body if the request action requires this
2403
				if (isset($action['message_action'], $action['message_action']['append_body'])) {
2404
					$bodyProps = mapi_getprops($message, [PR_BODY]);
2405
					if (isset($bodyProps[PR_BODY]) || propIsError(PR_BODY, $bodyProps) == MAPI_E_NOT_ENOUGH_MEMORY) {
2406
						$bodyProps[PR_BODY] = streamProperty($message, PR_BODY);
2407
					}
2408
2409
					if (isset($action['message_action']['meetingTimeInfo'], $bodyProps[PR_BODY])) {
2410
						$action['message_action']['meetingTimeInfo'] .= $bodyProps[PR_BODY];
2411
					}
2412
				}
2413
2414
				$request->setMeetingTimeInfo($action['message_action']['meetingTimeInfo']);
2415
				unset($action['message_action']['meetingTimeInfo']);
2416
			}
2417
2418
			$modifiedRecipients = false;
2419
			$deletedRecipients = false;
2420
			if ($recips) {
2421
				if (isset($action['message_action']['send_update']) && $action['message_action']['send_update'] == 'modified') {
2422
					if (isset($recips['add']) && !empty($recips['add'])) {
2423
						$modifiedRecipients = $modifiedRecipients ?: [];
0 ignored issues
show
introduced by
The condition $modifiedRecipients is always false.
Loading history...
2424
						$modifiedRecipients = array_merge($modifiedRecipients, $this->createRecipientList($recips['add'], 'add'));
2425
					}
2426
2427
					if (isset($recips['modify']) && !empty($recips['modify'])) {
2428
						$modifiedRecipients = $modifiedRecipients ?: [];
2429
						$modifiedRecipients = array_merge($modifiedRecipients, $this->createRecipientList($recips['modify'], 'modify'));
2430
					}
2431
				}
2432
2433
				// lastUpdateCounter is represent that how many times this message is updated(send)
2434
				$lastUpdateCounter = $request->getLastUpdateCounter();
2435
				if ($lastUpdateCounter !== false && $lastUpdateCounter > 0) {
2436
					if (isset($recips['remove']) && !empty($recips['remove'])) {
2437
						$deletedRecipients = $deletedRecipients ?: [];
0 ignored issues
show
introduced by
The condition $deletedRecipients is always false.
Loading history...
2438
						$deletedRecipients = array_merge($deletedRecipients, $this->createRecipientList($recips['remove'], 'remove'));
2439
						if (isset($action['message_action']['send_update']) && $action['message_action']['send_update'] != 'all') {
2440
							$modifiedRecipients = $modifiedRecipients ?: [];
2441
						}
2442
					}
2443
				}
2444
			}
2445
2446
			$sendMeetingRequestResult = $request->sendMeetingRequest($delete, false, $basedate, $modifiedRecipients, $deletedRecipients);
2447
2448
			$this->addRecipientsToRecipientHistory($this->getRecipientsInfo($message));
2449
2450
			if ($sendMeetingRequestResult === true) {
2451
				$this->parseDistListAndAddToRecipientHistory($savedUnsavedRecipients, $remove);
2452
2453
				mapi_savechanges($message);
2454
2455
				// We want to sent the 'request_sent' property, to have it properly
2456
				// deserialized we must also send some type properties.
2457
				$props = mapi_getprops($message, [PR_MESSAGE_CLASS, PR_OBJECT_TYPE]);
2458
				$messageProps[PR_MESSAGE_CLASS] = $props[PR_MESSAGE_CLASS];
2459
				$messageProps[PR_OBJECT_TYPE] = $props[PR_OBJECT_TYPE];
2460
2461
				// Indicate that the message was correctly sent
2462
				$messageProps[$properties['request_sent']] = true;
2463
2464
				// Return message properties that can be sent to the bus to notify changes
2465
				$result = $messageProps;
2466
			}
2467
			else {
2468
				$sendMeetingRequestResult[PR_ENTRYID] = $messageProps[PR_ENTRYID];
2469
				$sendMeetingRequestResult[PR_PARENT_ENTRYID] = $messageProps[PR_PARENT_ENTRYID];
2470
				$sendMeetingRequestResult[PR_STORE_ENTRYID] = $messageProps[PR_STORE_ENTRYID];
2471
				$result = $sendMeetingRequestResult;
2472
			}
2473
		}
2474
		else {
2475
			mapi_savechanges($message);
2476
2477
			if (isset($isExceptionAllowed)) {
2478
				if ($isExceptionAllowed === false) {
2479
					$messageProps['isexceptionallowed'] = false;
2480
				}
2481
			}
2482
2483
			if (isset($isReminderTimeAllowed)) {
2484
				if ($isReminderTimeAllowed === false) {
2485
					$messageProps['remindertimeerror'] = false;
2486
				}
2487
			}
2488
			// Return message properties that can be sent to the bus to notify changes
2489
			$result = $messageProps;
2490
		}
2491
2492
		return $result;
2493
	}
2494
2495
	/**
2496
	 * Function is used to identify the local distribution list from all recipients and
2497
	 * convert all local distribution list members to recipients.
2498
	 *
2499
	 * @param array $recipients array of recipients either saved or add
2500
	 * @param array $remove     array of recipients that was removed
2501
	 *
2502
	 * @return array $newRecipients a list of recipients as XML array structure
2503
	 */
2504
	public function convertLocalDistlistMembersToRecipients($recipients, $remove = []) {
2505
		$addRecipients = [];
2506
		$removeRecipients = [];
2507
2508
		foreach ($recipients as $key => $recipient) {
2509
			foreach ($recipient as $recipientItem) {
2510
				$recipientEntryid = $recipientItem["entryid"];
2511
				$isExistInRemove = $this->isExistInRemove($recipientEntryid, $remove);
2512
2513
				/*
2514
				 * Condition is only gets true, if recipient is distribution list and it`s belongs
2515
				 * to shared/internal(belongs in contact folder) folder.
2516
				 */
2517
				if ($recipientItem['object_type'] == MAPI_DISTLIST && $recipientItem['address_type'] != 'EX') {
2518
					if (!$isExistInRemove) {
2519
						$recipientItems = $GLOBALS["operations"]->expandDistList($recipientEntryid, true);
2520
						foreach ($recipientItems as $recipient) {
0 ignored issues
show
Comprehensibility Bug introduced by
$recipient is overwriting a variable from outer foreach loop.
Loading history...
2521
							// set recipient type of each members as per the distribution list recipient type
2522
							$recipient['recipient_type'] = $recipientItem['recipient_type'];
2523
							array_push($addRecipients, $recipient);
2524
						}
2525
2526
						if ($key === "saved") {
2527
							array_push($removeRecipients, $recipientItem);
2528
						}
2529
					}
2530
				}
2531
				else {
2532
					/*
2533
					 * Only Add those recipients which are not saved earlier in message and
2534
					 * not present in remove array.
2535
					 */
2536
					if (!$isExistInRemove && $key === "unsaved") {
2537
						array_push($addRecipients, $recipientItem);
2538
					}
2539
				}
2540
			}
2541
		}
2542
		$newRecipients["add"] = $addRecipients;
0 ignored issues
show
Comprehensibility Best Practice introduced by
$newRecipients was never initialized. Although not strictly required by PHP, it is generally a good practice to add $newRecipients = array(); before regardless.
Loading history...
2543
		$newRecipients["remove"] = $removeRecipients;
2544
2545
		return $newRecipients;
2546
	}
2547
2548
	/**
2549
	 * Function used to identify given recipient was already available in remove array of recipients array or not.
2550
	 * which was sent from client side. If it is found the entry in the $remove array will be deleted, since
2551
	 * we do not want to find it again for other recipients. (if a user removes and adds an user again it
2552
	 * should be added once!).
2553
	 *
2554
	 * @param string $recipientEntryid recipient entryid
2555
	 * @param array  $remove           removed recipients array
2556
	 *
2557
	 * @return bool return false if recipient not exist in remove array else return true
2558
	 */
2559
	public function isExistInRemove($recipientEntryid, &$remove) {
2560
		if (!empty($remove)) {
2561
			foreach ($remove as $index => $removeItem) {
2562
				if (array_search($recipientEntryid, $removeItem, true)) {
2563
					unset($remove[$index]);
2564
2565
					return true;
2566
				}
2567
			}
2568
		}
2569
2570
		return false;
2571
	}
2572
2573
	/**
2574
	 * Function is used to identify the local distribution list from all recipients and
2575
	 * Add distribution list to recipient history.
2576
	 *
2577
	 * @param array $savedUnsavedRecipients array of recipients either saved or add
2578
	 * @param array $remove                 array of recipients that was removed
2579
	 */
2580
	public function parseDistListAndAddToRecipientHistory($savedUnsavedRecipients, $remove) {
2581
		$distLists = [];
2582
		foreach ($savedUnsavedRecipients as $key => $recipient) {
2583
			foreach ($recipient as $recipientItem) {
2584
				if ($recipientItem['address_type'] == 'MAPIPDL') {
2585
					$isExistInRemove = $this->isExistInRemove($recipientItem['entryid'], $remove);
2586
					if (!$isExistInRemove) {
2587
						array_push($distLists, ["props" => $recipientItem]);
2588
					}
2589
				}
2590
			}
2591
		}
2592
2593
		$this->addRecipientsToRecipientHistory($distLists);
2594
	}
2595
2596
	/**
2597
	 * Set sent_representing_email_address property of Appointment.
2598
	 *
2599
	 * Before saving any new appointment, sent_representing_email_address property of appointment
2600
	 * should contain email_address of user, who is the owner of store(in which the appointment
2601
	 * is created).
2602
	 *
2603
	 * @param mapistore $store  MAPI store of the message
2604
	 * @param array     $action reference to action array containing XML request
2605
	 */
2606
	public function setSenderAddress($store, &$action) {
2607
		$storeProps = mapi_getprops($store, [PR_MAILBOX_OWNER_ENTRYID]);
2608
		// check for public store
2609
		if (!isset($storeProps[PR_MAILBOX_OWNER_ENTRYID])) {
2610
			$store = $GLOBALS["mapisession"]->getDefaultMessageStore();
2611
			$storeProps = mapi_getprops($store, [PR_MAILBOX_OWNER_ENTRYID]);
2612
		}
2613
		$mailuser = mapi_ab_openentry($GLOBALS["mapisession"]->getAddressbook(), $storeProps[PR_MAILBOX_OWNER_ENTRYID]);
2614
		if ($mailuser) {
2615
			$userprops = mapi_getprops($mailuser, [PR_ADDRTYPE, PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_SMTP_ADDRESS]);
2616
			$action["props"]["sent_representing_entryid"] = bin2hex((string) $storeProps[PR_MAILBOX_OWNER_ENTRYID]);
2617
			// we do conversion here, because before passing props to saveMessage() props are converted from utf8-to-w
2618
			$action["props"]["sent_representing_name"] = $userprops[PR_DISPLAY_NAME];
2619
			$action["props"]["sent_representing_address_type"] = $userprops[PR_ADDRTYPE];
2620
			if ($userprops[PR_ADDRTYPE] == 'SMTP') {
2621
				$emailAddress = $userprops[PR_SMTP_ADDRESS];
2622
			}
2623
			else {
2624
				$emailAddress = $userprops[PR_EMAIL_ADDRESS];
2625
			}
2626
			$action["props"]["sent_representing_email_address"] = $emailAddress;
2627
			$action["props"]["sent_representing_search_key"] = bin2hex(strtoupper($userprops[PR_ADDRTYPE] . ':' . $emailAddress)) . '00';
2628
		}
2629
	}
2630
2631
	/**
2632
	 * Submit a message for sending.
2633
	 *
2634
	 * This function is an extension of the saveMessage() function, with the extra functionality
2635
	 * that the item is actually sent and queued for moving to 'Sent Items'. Also, the e-mail addresses
2636
	 * used in the message are processed for later auto-suggestion.
2637
	 *
2638
	 * @see Operations::saveMessage() for more information on the parameters, which are identical.
2639
	 *
2640
	 * @param mapistore   $store                     MAPI Message Store Object
2641
	 * @param binary      $entryid                   Entryid of the message
2642
	 * @param array       $props                     The properties to be saved
2643
	 * @param array       $messageProps              reference to an array which will be filled with PR_ENTRYID, PR_PARENT_ENTRYID and PR_STORE_ENTRYID
2644
	 * @param array       $recipients                XML array structure of recipients for the recipient table
2645
	 * @param array       $attachments               array of attachments consisting unique ID of attachments for this message
2646
	 * @param MAPIMessage $copyFromMessage           resource of the message from which we should
2647
	 *                                               copy attachments and/or recipients to the current message
2648
	 * @param bool        $copyAttachments           if set we copy all attachments from the $copyFromMessage
2649
	 * @param bool        $copyRecipients            if set we copy all recipients from the $copyFromMessage
2650
	 * @param bool        $copyInlineAttachmentsOnly if true then copy only inline attachments
2651
	 * @param bool        $isPlainText               if true then message body will be generated using PR_BODY otherwise PR_HTML will be used in saveMessage() function
2652
	 *
2653
	 * @return bool false if action succeeded, anything else indicates an error (e.g. a string)
2654
	 */
2655
	public function submitMessage($store, $entryid, $props, &$messageProps, $recipients = [], $attachments = [], $copyFromMessage = false, $copyAttachments = false, $copyRecipients = false, $copyInlineAttachmentsOnly = false, $isPlainText = false) {
2656
		$message = false;
2657
		$origStore = $store;
2658
		$reprMessage = false;
2659
		$delegateSentItemsStyle = $GLOBALS['settings']->get('zarafa/v1/contexts/mail/delegate_sent_items_style');
2660
		$saveBoth = strcasecmp((string) $delegateSentItemsStyle, 'both') == 0;
2661
		$saveRepresentee = strcasecmp((string) $delegateSentItemsStyle, 'representee') == 0;
2662
		$sendingAsDelegate = false;
2663
2664
		// Get the outbox and sent mail entryid, ignore the given $store, use the default store for submitting messages
2665
		$store = $GLOBALS["mapisession"]->getDefaultMessageStore();
2666
		$storeprops = mapi_getprops($store, [PR_IPM_OUTBOX_ENTRYID, PR_IPM_SENTMAIL_ENTRYID, PR_ENTRYID]);
2667
		$origStoreprops = mapi_getprops($origStore, [PR_ENTRYID, PR_IPM_SENTMAIL_ENTRYID]);
2668
2669
		if (!isset($storeprops[PR_IPM_OUTBOX_ENTRYID])) {
2670
			return false;
2671
		}
2672
		if (isset($storeprops[PR_IPM_SENTMAIL_ENTRYID])) {
2673
			$props[PR_SENTMAIL_ENTRYID] = $storeprops[PR_IPM_SENTMAIL_ENTRYID];
2674
		}
2675
2676
		// Check if replying then set PR_INTERNET_REFERENCES and PR_IN_REPLY_TO_ID properties in props.
2677
		// flag is probably used wrong here but the same flag indicates if this is reply or replyall
2678
		if ($copyInlineAttachmentsOnly) {
2679
			$origMsgProps = mapi_getprops($copyFromMessage, [PR_INTERNET_MESSAGE_ID, PR_INTERNET_REFERENCES]);
2680
			if (isset($origMsgProps[PR_INTERNET_MESSAGE_ID])) {
2681
				// The references header should indicate the message-id of the original
2682
				// header plus any of the references which were set on the previous mail.
2683
				$props[PR_INTERNET_REFERENCES] = $origMsgProps[PR_INTERNET_MESSAGE_ID];
2684
				if (isset($origMsgProps[PR_INTERNET_REFERENCES])) {
2685
					$props[PR_INTERNET_REFERENCES] = $origMsgProps[PR_INTERNET_REFERENCES] . ' ' . $props[PR_INTERNET_REFERENCES];
2686
				}
2687
				$props[PR_IN_REPLY_TO_ID] = $origMsgProps[PR_INTERNET_MESSAGE_ID];
2688
			}
2689
		}
2690
2691
		if (!$GLOBALS["entryid"]->compareEntryIds(bin2hex((string) $origStoreprops[PR_ENTRYID]), bin2hex((string) $storeprops[PR_ENTRYID]))) {
2692
			// set properties for "on behalf of" mails
2693
			$origStoreProps = mapi_getprops($origStore, [PR_MAILBOX_OWNER_ENTRYID, PR_MDB_PROVIDER, PR_IPM_SENTMAIL_ENTRYID]);
2694
2695
			// set PR_SENDER_* properties, which contains currently logged user's data
2696
			$ab = $GLOBALS['mapisession']->getAddressbook();
2697
			$abitem = mapi_ab_openentry($ab, $GLOBALS["mapisession"]->getUserEntryID());
2698
			$abitemprops = mapi_getprops($abitem, [PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_SEARCH_KEY]);
2699
2700
			$props[PR_SENDER_ENTRYID] = $GLOBALS["mapisession"]->getUserEntryID();
2701
			$props[PR_SENDER_NAME] = $abitemprops[PR_DISPLAY_NAME];
2702
			$props[PR_SENDER_EMAIL_ADDRESS] = $abitemprops[PR_EMAIL_ADDRESS];
2703
			$props[PR_SENDER_ADDRTYPE] = "EX";
2704
			$props[PR_SENDER_SEARCH_KEY] = $abitemprops[PR_SEARCH_KEY];
2705
2706
			// Use the PR_SENT_REPRESENTING_* properties sent by the client or set to the currently logged user's data
2707
			$props[PR_SENT_REPRESENTING_ENTRYID] ??= $props[PR_SENDER_ENTRYID];
2708
			$props[PR_SENT_REPRESENTING_NAME] ??= $props[PR_SENDER_NAME];
2709
			$props[PR_SENT_REPRESENTING_EMAIL_ADDRESS] ??= $props[PR_SENDER_EMAIL_ADDRESS];
2710
			$props[PR_SENT_REPRESENTING_ADDRTYPE] ??= $props[PR_SENDER_ADDRTYPE];
2711
			$props[PR_SENT_REPRESENTING_SEARCH_KEY] ??= $props[PR_SENDER_SEARCH_KEY];
2712
2713
			/**
2714
			 * we are sending mail from delegate's account, so we can't use delegate's outbox and sent items folder
2715
			 * so we have to copy the mail from delegate's store to logged user's store and in outbox folder and then
2716
			 * we can send mail from logged user's outbox folder.
2717
			 *
2718
			 * if we set $entryid to false before passing it to saveMessage function then it will assume
2719
			 * that item doesn't exist and it will create a new item (in outbox of logged in user)
2720
			 */
2721
			if ($entryid) {
0 ignored issues
show
introduced by
$entryid is of type binary, thus it always evaluated to true.
Loading history...
2722
				$oldEntryId = $entryid;
2723
				$entryid = false;
2724
2725
				// if we are sending mail from drafts folder then we have to copy
2726
				// its recipients and attachments also. $origStore and $oldEntryId points to mail
2727
				// saved in delegators draft folder
2728
				if ($copyFromMessage === false) {
2729
					$copyFromMessage = mapi_msgstore_openentry($origStore, $oldEntryId);
2730
					$copyRecipients = true;
2731
2732
					// Decode smime signed messages on this message
2733
					parse_smime($origStore, $copyFromMessage);
2734
				}
2735
			}
2736
2737
			if ($copyFromMessage) {
2738
				// Get properties of original message, to copy recipients and attachments in new message
2739
				$copyMessageProps = mapi_getprops($copyFromMessage);
2740
				$oldParentEntryId = $copyMessageProps[PR_PARENT_ENTRYID];
2741
2742
				// unset id properties before merging the props, so we will be creating new item instead of sending same item
2743
				unset($copyMessageProps[PR_ENTRYID], $copyMessageProps[PR_PARENT_ENTRYID], $copyMessageProps[PR_STORE_ENTRYID], $copyMessageProps[PR_SEARCH_KEY]);
2744
2745
				// grommunio generates PR_HTML on the fly, but it's necessary to unset it
2746
				// if the original message didn't have PR_HTML property.
2747
				if (!isset($props[PR_HTML]) && isset($copyMessageProps[PR_HTML])) {
2748
					unset($copyMessageProps[PR_HTML]);
2749
				}
2750
				/* New EMAIL_ADDRESSes were set (various cases above), kill off old SMTP_ADDRESS. */
2751
				unset($copyMessageProps[PR_SENDER_SMTP_ADDRESS], $copyMessageProps[PR_SENT_REPRESENTING_SMTP_ADDRESS]);
2752
2753
				// Merge original message props with props sent by client
2754
				$props = $props + $copyMessageProps;
2755
			}
2756
2757
			// Save the new message properties
2758
			$message = $this->saveMessage($store, $entryid, $storeprops[PR_IPM_OUTBOX_ENTRYID], $props, $messageProps, $recipients, $attachments, [], $copyFromMessage, $copyAttachments, $copyRecipients, $copyInlineAttachmentsOnly, true, true, $isPlainText);
0 ignored issues
show
Bug introduced by
$entryid of type false is incompatible with the type binary expected by parameter $entryid of Operations::saveMessage(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

2758
			$message = $this->saveMessage($store, /** @scrutinizer ignore-type */ $entryid, $storeprops[PR_IPM_OUTBOX_ENTRYID], $props, $messageProps, $recipients, $attachments, [], $copyFromMessage, $copyAttachments, $copyRecipients, $copyInlineAttachmentsOnly, true, true, $isPlainText);
Loading history...
2759
2760
			// FIXME: currently message is deleted from original store and new message is created
2761
			// in current user's store, but message should be moved
2762
2763
			// delete message from it's original location
2764
			if (!empty($oldEntryId) && !empty($oldParentEntryId)) {
2765
				$folder = mapi_msgstore_openentry($origStore, $oldParentEntryId);
2766
				mapi_folder_deletemessages($folder, [$oldEntryId], DELETE_HARD_DELETE);
2767
			}
2768
			if ($saveBoth || $saveRepresentee) {
2769
				if ($origStoreProps[PR_MDB_PROVIDER] === ZARAFA_STORE_PUBLIC_GUID) {
2770
					$userEntryid = $GLOBALS["mapisession"]->getStoreEntryIdOfUser(strtolower((string) $props[PR_SENT_REPRESENTING_EMAIL_ADDRESS]));
2771
					$origStore = $GLOBALS["mapisession"]->openMessageStore($userEntryid);
2772
					$origStoreprops = mapi_getprops($origStore, [PR_IPM_SENTMAIL_ENTRYID]);
2773
				}
2774
				$destfolder = mapi_msgstore_openentry($origStore, $origStoreprops[PR_IPM_SENTMAIL_ENTRYID]);
2775
				$reprMessage = mapi_folder_createmessage($destfolder);
2776
				mapi_copyto($message, [], [], $reprMessage, 0);
2777
			}
2778
		}
2779
		else {
2780
			// When the message is in your own store, just move it to your outbox. We move it manually so we know the new entryid after it has been moved.
2781
			$outbox = mapi_msgstore_openentry($store, $storeprops[PR_IPM_OUTBOX_ENTRYID]);
2782
2783
			// Open the old and the new message
2784
			$newmessage = mapi_folder_createmessage($outbox);
2785
			$oldEntryId = $entryid;
2786
2787
			// Remember the new entryid
2788
			$newprops = mapi_getprops($newmessage, [PR_ENTRYID]);
2789
			$entryid = $newprops[PR_ENTRYID];
2790
2791
			if (!empty($oldEntryId)) {
2792
				$message = mapi_msgstore_openentry($store, $oldEntryId);
2793
				// Copy the entire message
2794
				mapi_copyto($message, [], [], $newmessage);
2795
				$tmpProps = mapi_getprops($message);
2796
				$oldParentEntryId = $tmpProps[PR_PARENT_ENTRYID];
2797
				if ($storeprops[PR_IPM_OUTBOX_ENTRYID] == $oldParentEntryId) {
2798
					$folder = $outbox;
2799
				}
2800
				else {
2801
					$folder = mapi_msgstore_openentry($store, $oldParentEntryId);
2802
				}
2803
2804
				// Copy message_class for S/MIME plugin
2805
				if (isset($tmpProps[PR_MESSAGE_CLASS])) {
2806
					$props[PR_MESSAGE_CLASS] = $tmpProps[PR_MESSAGE_CLASS];
2807
				}
2808
				// Delete the old message
2809
				mapi_folder_deletemessages($folder, [$oldEntryId]);
2810
			}
2811
2812
			// save changes to new message created in outbox
2813
			mapi_savechanges($newmessage);
2814
2815
			$reprProps = mapi_getprops($newmessage, [PR_SENT_REPRESENTING_EMAIL_ADDRESS, PR_SENDER_EMAIL_ADDRESS, PR_SENT_REPRESENTING_ENTRYID]);
2816
			if (isset($reprProps[PR_SENT_REPRESENTING_EMAIL_ADDRESS], $reprProps[PR_SENDER_EMAIL_ADDRESS], $reprProps[PR_SENT_REPRESENTING_ENTRYID]) &&
2817
				strcasecmp((string) $reprProps[PR_SENT_REPRESENTING_EMAIL_ADDRESS], (string) $reprProps[PR_SENDER_EMAIL_ADDRESS]) != 0) {
2818
				$ab = $GLOBALS['mapisession']->getAddressbook();
2819
				$abitem = mapi_ab_openentry($ab, $reprProps[PR_SENT_REPRESENTING_ENTRYID]);
2820
				$abitemprops = mapi_getprops($abitem, [PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_SEARCH_KEY]);
2821
2822
				$props[PR_SENT_REPRESENTING_NAME] = $abitemprops[PR_DISPLAY_NAME];
2823
				$props[PR_SENT_REPRESENTING_EMAIL_ADDRESS] = $abitemprops[PR_EMAIL_ADDRESS];
2824
				$props[PR_SENT_REPRESENTING_ADDRTYPE] = "EX";
2825
				$props[PR_SENT_REPRESENTING_SEARCH_KEY] = $abitemprops[PR_SEARCH_KEY];
2826
				$sendingAsDelegate = true;
2827
			}
2828
			// Save the new message properties
2829
			$message = $this->saveMessage($store, $entryid, $storeprops[PR_IPM_OUTBOX_ENTRYID], $props, $messageProps, $recipients, $attachments, [], $copyFromMessage, $copyAttachments, $copyRecipients, $copyInlineAttachmentsOnly, true, true, $isPlainText);
0 ignored issues
show
Bug introduced by
It seems like $copyFromMessage can also be of type false; however, parameter $copyFromMessage of Operations::saveMessage() does only seem to accept MAPIMessage, maybe add an additional type check? ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

2829
			$message = $this->saveMessage($store, $entryid, $storeprops[PR_IPM_OUTBOX_ENTRYID], $props, $messageProps, $recipients, $attachments, [], /** @scrutinizer ignore-type */ $copyFromMessage, $copyAttachments, $copyRecipients, $copyInlineAttachmentsOnly, true, true, $isPlainText);
Loading history...
2830
			// Sending as delegate from drafts folder
2831
			if ($sendingAsDelegate && ($saveBoth || $saveRepresentee)) {
2832
				$userEntryid = $GLOBALS["mapisession"]->getStoreEntryIdOfUser(strtolower((string) $props[PR_SENT_REPRESENTING_EMAIL_ADDRESS]));
2833
				$origStore = $GLOBALS["mapisession"]->openMessageStore($userEntryid);
2834
				if ($origStore) {
2835
					$origStoreprops = mapi_getprops($origStore, [PR_ENTRYID, PR_IPM_SENTMAIL_ENTRYID]);
2836
					$destfolder = mapi_msgstore_openentry($origStore, $origStoreprops[PR_IPM_SENTMAIL_ENTRYID]);
2837
					$reprMessage = mapi_folder_createmessage($destfolder);
2838
					mapi_copyto($message, [], [], $reprMessage, 0);
2839
				}
2840
			}
2841
		}
2842
2843
		if (!$message) {
0 ignored issues
show
introduced by
$message is of type mapimessage, thus it always evaluated to true.
Loading history...
2844
			return false;
2845
		}
2846
		// Allowing to hook in just before the data sent away to be sent to the client
2847
		$GLOBALS['PluginManager']->triggerHook('server.core.operations.submitmessage', [
2848
			'moduleObject' => $this,
2849
			'store' => $store,
2850
			'entryid' => $entryid,
2851
			'message' => &$message,
2852
		]);
2853
2854
		// Submit the message (send)
2855
		try {
2856
			mapi_message_submitmessage($message);
2857
		}
2858
		catch (MAPIException $e) {
2859
			$username = $GLOBALS["mapisession"]->getUserName();
2860
			$errorName = get_mapi_error_name($e->getCode());
2861
			error_log(sprintf(
2862
				'Unable to submit message for %s, MAPI error: %s. ' .
2863
				'SMTP server may be down or it refused the message or the message' .
2864
				' is too large to submit or user does not have the permission ...',
2865
				$username,
2866
				$errorName
2867
			));
2868
2869
			return $errorName;
2870
		}
2871
2872
		$tmp_props = mapi_getprops($message, [PR_PARENT_ENTRYID, PR_MESSAGE_DELIVERY_TIME, PR_CLIENT_SUBMIT_TIME, PR_SEARCH_KEY, PR_MESSAGE_FLAGS]);
2873
		$messageProps[PR_PARENT_ENTRYID] = $tmp_props[PR_PARENT_ENTRYID];
2874
		if ($reprMessage !== false) {
2875
			mapi_setprops($reprMessage, [
2876
				PR_CLIENT_SUBMIT_TIME => $tmp_props[PR_CLIENT_SUBMIT_TIME] ?? time(),
2877
				PR_MESSAGE_DELIVERY_TIME => $tmp_props[PR_MESSAGE_DELIVERY_TIME] ?? time(),
2878
				PR_MESSAGE_FLAGS => $tmp_props[PR_MESSAGE_FLAGS] | MSGFLAG_READ,
2879
			]);
2880
			mapi_savechanges($reprMessage);
2881
			if ($saveRepresentee) {
2882
				// delete the message in the delegate's Sent Items folder
2883
				$sentFolder = mapi_msgstore_openentry($store, $storeprops[PR_IPM_SENTMAIL_ENTRYID]);
2884
				$sentTable = mapi_folder_getcontentstable($sentFolder, MAPI_DEFERRED_ERRORS);
2885
				$restriction = [RES_PROPERTY, [
2886
					RELOP => RELOP_EQ,
2887
					ULPROPTAG => PR_SEARCH_KEY,
2888
					VALUE => $tmp_props[PR_SEARCH_KEY],
2889
				]];
2890
				mapi_table_restrict($sentTable, $restriction);
2891
				$sentMessageProps = mapi_table_queryallrows($sentTable, [PR_ENTRYID, PR_SEARCH_KEY]);
2892
				if (mapi_table_getrowcount($sentTable) == 1) {
2893
					mapi_folder_deletemessages($sentFolder, [$sentMessageProps[0][PR_ENTRYID]], DELETE_HARD_DELETE);
2894
				}
2895
				else {
2896
					error_log(sprintf(
2897
						"Found multiple entries in Sent Items with the same PR_SEARCH_KEY (%d)." .
2898
						" Impossible to delete email from the delegate's Sent Items folder.",
2899
						mapi_table_getrowcount($sentTable)
2900
					));
2901
				}
2902
			}
2903
		}
2904
2905
		$this->addRecipientsToRecipientHistory($this->getRecipientsInfo($message));
2906
2907
		return false;
2908
	}
2909
2910
	/**
2911
	 * Delete messages.
2912
	 *
2913
	 * This function does what is needed when a user presses 'delete' on a MAPI message. This means that:
2914
	 *
2915
	 * - Items in the own store are moved to the wastebasket
2916
	 * - Items in the wastebasket are deleted
2917
	 * - Items in other users stores are moved to our own wastebasket
2918
	 * - Items in the public store are deleted
2919
	 *
2920
	 * @param mapistore $store         MAPI Message Store Object
2921
	 * @param string    $parententryid parent entryid of the messages to be deleted
2922
	 * @param array     $entryids      a list of entryids which will be deleted
2923
	 * @param bool      $softDelete    flag for soft-deleteing (when user presses Shift+Del)
2924
	 * @param bool      $unread        message is unread
2925
	 *
2926
	 * @return bool true if action succeeded, false if not
2927
	 */
2928
	public function deleteMessages($store, $parententryid, $entryids, $softDelete = false, $unread = false) {
2929
		$result = false;
2930
		if (!is_array($entryids)) {
0 ignored issues
show
introduced by
The condition is_array($entryids) is always true.
Loading history...
2931
			$entryids = [$entryids];
2932
		}
2933
2934
		$folder = mapi_msgstore_openentry($store, $parententryid);
2935
		$flags = $unread ? GX_DELMSG_NOTIFY_UNREAD : 0;
2936
		$msgprops = mapi_getprops($store, [PR_IPM_WASTEBASKET_ENTRYID, PR_MDB_PROVIDER, PR_IPM_OUTBOX_ENTRYID]);
2937
2938
		switch ($msgprops[PR_MDB_PROVIDER]) {
2939
			case ZARAFA_STORE_DELEGATE_GUID:
2940
				$softDelete = $softDelete || defined('ENABLE_DEFAULT_SOFT_DELETE') ? ENABLE_DEFAULT_SOFT_DELETE : false;
2941
				// with a store from an other user we need our own waste basket...
2942
				if (isset($msgprops[PR_IPM_WASTEBASKET_ENTRYID]) && $msgprops[PR_IPM_WASTEBASKET_ENTRYID] == $parententryid || $softDelete) {
0 ignored issues
show
introduced by
Consider adding parentheses for clarity. Current Interpretation: (IssetNode && $msgprops[...entryid) || $softDelete, Probably Intended Meaning: IssetNode && ($msgprops[...entryid || $softDelete)
Loading history...
2943
					// except when it is the waste basket itself
2944
					$result = mapi_folder_deletemessages($folder, $entryids, $flags);
2945
					break;
2946
				}
2947
				$defaultstore = $GLOBALS["mapisession"]->getDefaultMessageStore();
2948
				$msgprops = mapi_getprops($defaultstore, [PR_IPM_WASTEBASKET_ENTRYID, PR_MDB_PROVIDER]);
2949
2950
				if (!isset($msgprops[PR_IPM_WASTEBASKET_ENTRYID]) ||
2951
					$msgprops[PR_IPM_WASTEBASKET_ENTRYID] == $parententryid) {
2952
					$result = mapi_folder_deletemessages($folder, $entryids, $flags);
2953
					break;
2954
				}
2955
2956
				try {
2957
					$result = $this->copyMessages($store, $parententryid, $defaultstore, $msgprops[PR_IPM_WASTEBASKET_ENTRYID], $entryids, [], true);
2958
				}
2959
				catch (MAPIException $e) {
2960
					$e->setHandled();
2961
					// if moving fails, try normal delete
2962
					$result = mapi_folder_deletemessages($folder, $entryids, $flags);
2963
				}
2964
				break;
2965
2966
			case ZARAFA_STORE_ARCHIVER_GUID:
2967
			case ZARAFA_STORE_PUBLIC_GUID:
2968
				// always delete in public store and archive store
2969
				$result = mapi_folder_deletemessages($folder, $entryids, $flags);
2970
				break;
2971
2972
			case ZARAFA_SERVICE_GUID:
2973
				// delete message when in your own waste basket, else move it to the waste basket
2974
				if (isset($msgprops[PR_IPM_WASTEBASKET_ENTRYID]) && $msgprops[PR_IPM_WASTEBASKET_ENTRYID] == $parententryid || $softDelete === true) {
0 ignored issues
show
introduced by
Consider adding parentheses for clarity. Current Interpretation: (IssetNode && $msgprops[...|| $softDelete === true, Probably Intended Meaning: IssetNode && ($msgprops[...| $softDelete === true)
Loading history...
2975
					$result = mapi_folder_deletemessages($folder, $entryids, $flags);
2976
					break;
2977
				}
2978
2979
				try {
2980
					// if the message is deleting from outbox then first delete the
2981
					// message from an outgoing queue.
2982
					if (function_exists("mapi_msgstore_abortsubmit") && isset($msgprops[PR_IPM_OUTBOX_ENTRYID]) && $msgprops[PR_IPM_OUTBOX_ENTRYID] === $parententryid) {
2983
						foreach ($entryids as $entryid) {
2984
							$message = mapi_msgstore_openentry($store, $entryid);
2985
							$messageProps = mapi_getprops($message, [PR_DEFERRED_SEND_TIME]);
2986
							if (isset($messageProps[PR_DEFERRED_SEND_TIME])) {
2987
								mapi_msgstore_abortsubmit($store, $entryid);
2988
							}
2989
						}
2990
					}
2991
					$result = $this->copyMessages($store, $parententryid, $store, $msgprops[PR_IPM_WASTEBASKET_ENTRYID], $entryids, [], true);
2992
				}
2993
				catch (MAPIException $e) {
2994
					if ($e->getCode() === MAPI_E_NOT_IN_QUEUE || $e->getCode() === MAPI_E_UNABLE_TO_ABORT) {
2995
						throw $e;
2996
					}
2997
2998
					$e->setHandled();
2999
					// if moving fails, try normal delete
3000
					$result = mapi_folder_deletemessages($folder, $entryids, $flags);
3001
				}
3002
				break;
3003
		}
3004
3005
		return $result;
3006
	}
3007
3008
	/**
3009
	 * Copy or move messages.
3010
	 *
3011
	 * @param object $store         MAPI Message Store Object
3012
	 * @param string $parententryid parent entryid of the messages
3013
	 * @param string $destentryid   destination folder
3014
	 * @param array  $entryids      a list of entryids which will be copied or moved
3015
	 * @param array  $ignoreProps   a list of proptags which should not be copied over
3016
	 *                              to the new message
3017
	 * @param bool   $moveMessages  true - move messages, false - copy messages
3018
	 * @param array  $props         a list of proptags which should set in new messages
3019
	 * @param mixed  $destStore
3020
	 *
3021
	 * @return bool true if action succeeded, false if not
3022
	 */
3023
	public function copyMessages($store, $parententryid, $destStore, $destentryid, $entryids, $ignoreProps, $moveMessages, $props = []) {
3024
		$sourcefolder = mapi_msgstore_openentry($store, $parententryid);
3025
		$destfolder = mapi_msgstore_openentry($destStore, $destentryid);
3026
3027
		if (!$sourcefolder || !$destfolder) {
3028
			error_log("Could not open source or destination folder. Aborting.");
3029
3030
			return false;
3031
		}
3032
3033
		if (!is_array($entryids)) {
0 ignored issues
show
introduced by
The condition is_array($entryids) is always true.
Loading history...
3034
			$entryids = [$entryids];
3035
		}
3036
3037
		/*
3038
		 * If there are no properties to ignore as well as set then we can use mapi_folder_copymessages instead
3039
		 * of mapi_copyto. mapi_folder_copymessages is much faster then copyto since it executes
3040
		 * the copying on the server instead of in client.
3041
		 */
3042
		if (empty($ignoreProps) && empty($props)) {
3043
			try {
3044
				mapi_folder_copymessages($sourcefolder, $entryids, $destfolder, $moveMessages ? MESSAGE_MOVE : 0);
3045
			}
3046
			catch (MAPIException) {
3047
				error_log(sprintf("mapi_folder_copymessages failed with code: 0x%08X. Wait 250ms and try again", mapi_last_hresult()));
3048
				// wait 250ms before trying again
3049
				usleep(250000);
3050
3051
				try {
3052
					mapi_folder_copymessages($sourcefolder, $entryids, $destfolder, $moveMessages ? MESSAGE_MOVE : 0);
3053
				}
3054
				catch (MAPIException) {
3055
					error_log(sprintf("2nd attempt of mapi_folder_copymessages also failed with code: 0x%08X. Abort.", mapi_last_hresult()));
3056
3057
					return false;
3058
				}
3059
			}
3060
		}
3061
		else {
3062
			foreach ($entryids as $entryid) {
3063
				$oldmessage = mapi_msgstore_openentry($store, $entryid);
3064
				$newmessage = mapi_folder_createmessage($destfolder);
3065
3066
				mapi_copyto($oldmessage, [], $ignoreProps, $newmessage, 0);
3067
				if (!empty($props)) {
3068
					mapi_setprops($newmessage, $props);
3069
				}
3070
				mapi_savechanges($newmessage);
3071
			}
3072
			if ($moveMessages) {
3073
				// while moving message we actually copy that particular message into
3074
				// destination folder, and remove it from source folder. so we must have
3075
				// to hard delete the message.
3076
				mapi_folder_deletemessages($sourcefolder, $entryids, DELETE_HARD_DELETE);
3077
			}
3078
		}
3079
3080
		return true;
3081
	}
3082
3083
	/**
3084
	 * Set message read flag.
3085
	 *
3086
	 * @param object $store      MAPI Message Store Object
3087
	 * @param string $entryid    entryid of the message
3088
	 * @param int    $flags      Bitmask of values (read, has attachment etc.)
3089
	 * @param array  $props      properties of the message
3090
	 * @param mixed  $msg_action
3091
	 *
3092
	 * @return bool true if action succeeded, false if not
3093
	 */
3094
	public function setMessageFlag($store, $entryid, $flags, $msg_action = false, &$props = false) {
3095
		$message = $this->openMessage($store, $entryid);
3096
3097
		if ($message) {
0 ignored issues
show
introduced by
$message is of type object, thus it always evaluated to true.
Loading history...
3098
			/**
3099
			 * convert flags of PR_MESSAGE_FLAGS property to flags that is
3100
			 * used in mapi_message_setreadflag.
3101
			 */
3102
			$flag = MAPI_DEFERRED_ERRORS;		// set unread flag, read receipt will be sent
3103
3104
			if (($flags & MSGFLAG_RN_PENDING) && isset($msg_action['send_read_receipt']) && $msg_action['send_read_receipt'] == false) {
3105
				$flag |= SUPPRESS_RECEIPT;
3106
			}
3107
			else {
3108
				if (!($flags & MSGFLAG_READ)) {
3109
					$flag |= CLEAR_READ_FLAG;
3110
				}
3111
			}
3112
3113
			mapi_message_setreadflag($message, $flag);
3114
3115
			if (is_array($props)) {
3116
				$props = mapi_getprops($message, [PR_ENTRYID, PR_STORE_ENTRYID, PR_PARENT_ENTRYID]);
3117
			}
3118
		}
3119
3120
		return true;
3121
	}
3122
3123
	/**
3124
	 * Create a unique folder name based on a provided new folder name.
3125
	 *
3126
	 * checkFolderNameConflict() checks if a folder name conflict is caused by the given $foldername.
3127
	 * This function is used for copying of moving a folder to another folder. It returns
3128
	 * a unique foldername.
3129
	 *
3130
	 * @param object $store      MAPI Message Store Object
3131
	 * @param object $folder     MAPI Folder Object
3132
	 * @param string $foldername the folder name
3133
	 *
3134
	 * @return string correct foldername
3135
	 */
3136
	public function checkFolderNameConflict($store, $folder, $foldername) {
3137
		$folderNames = [];
3138
3139
		$hierarchyTable = mapi_folder_gethierarchytable($folder, MAPI_DEFERRED_ERRORS);
3140
		mapi_table_sort($hierarchyTable, [PR_DISPLAY_NAME => TABLE_SORT_ASCEND], TBL_BATCH);
3141
3142
		$subfolders = mapi_table_queryallrows($hierarchyTable, [PR_ENTRYID]);
3143
3144
		if (is_array($subfolders)) {
3145
			foreach ($subfolders as $subfolder) {
3146
				$folderObject = mapi_msgstore_openentry($store, $subfolder[PR_ENTRYID]);
3147
				$folderProps = mapi_getprops($folderObject, [PR_DISPLAY_NAME]);
3148
3149
				array_push($folderNames, strtolower((string) $folderProps[PR_DISPLAY_NAME]));
3150
			}
3151
		}
3152
3153
		if (array_search(strtolower($foldername), $folderNames) !== false) {
3154
			$i = 2;
3155
			while (array_search(strtolower($foldername) . " ({$i})", $folderNames) !== false) {
3156
				++$i;
3157
			}
3158
			$foldername .= " ({$i})";
3159
		}
3160
3161
		return $foldername;
3162
	}
3163
3164
	/**
3165
	 * Set the recipients of a MAPI message.
3166
	 *
3167
	 * @param object $message    MAPI Message Object
3168
	 * @param array  $recipients XML array structure of recipients
3169
	 * @param bool   $send       true if we are going to send this message else false
3170
	 */
3171
	public function setRecipients($message, $recipients, $send = false) {
3172
		if (empty($recipients)) {
3173
			// no recipients are sent from client
3174
			return;
3175
		}
3176
3177
		$newRecipients = [];
3178
		$removeRecipients = [];
3179
		$modifyRecipients = [];
3180
3181
		if (isset($recipients['add']) && !empty($recipients['add'])) {
3182
			$newRecipients = $this->createRecipientList($recipients['add'], 'add', false, $send);
3183
		}
3184
3185
		if (isset($recipients['remove']) && !empty($recipients['remove'])) {
3186
			$removeRecipients = $this->createRecipientList($recipients['remove'], 'remove');
3187
		}
3188
3189
		if (isset($recipients['modify']) && !empty($recipients['modify'])) {
3190
			$modifyRecipients = $this->createRecipientList($recipients['modify'], 'modify', false, $send);
3191
		}
3192
3193
		if (!empty($removeRecipients)) {
3194
			mapi_message_modifyrecipients($message, MODRECIP_REMOVE, $removeRecipients);
3195
		}
3196
3197
		if (!empty($modifyRecipients)) {
3198
			mapi_message_modifyrecipients($message, MODRECIP_MODIFY, $modifyRecipients);
3199
		}
3200
3201
		if (!empty($newRecipients)) {
3202
			mapi_message_modifyrecipients($message, MODRECIP_ADD, $newRecipients);
3203
		}
3204
	}
3205
3206
	/**
3207
	 * Copy recipients from original message.
3208
	 *
3209
	 * If we are sending mail from a delegator's folder, we need to copy all recipients from the original message
3210
	 *
3211
	 * @param object      $message         MAPI Message Object
3212
	 * @param MAPIMessage $copyFromMessage If set we copy all recipients from this message
3213
	 */
3214
	public function copyRecipients($message, $copyFromMessage = false) {
3215
		$recipienttable = mapi_message_getrecipienttable($copyFromMessage);
3216
		$messageRecipients = mapi_table_queryallrows($recipienttable, $GLOBALS["properties"]->getRecipientProperties());
3217
		if (!empty($messageRecipients)) {
3218
			mapi_message_modifyrecipients($message, MODRECIP_ADD, $messageRecipients);
3219
		}
3220
	}
3221
3222
	/**
3223
	 * Set attachments in a MAPI message.
3224
	 *
3225
	 * This function reads any attachments that have been previously uploaded and copies them into
3226
	 * the passed MAPI message resource. For a description of the dialog_attachments variable and
3227
	 * generally how attachments work when uploading, see Operations::saveMessage()
3228
	 *
3229
	 * @see Operations::saveMessage()
3230
	 *
3231
	 * @param object          $message          MAPI Message Object
3232
	 * @param array           $attachments      XML array structure of attachments
3233
	 * @param AttachmentState $attachment_state the state object in which the attachments are saved
3234
	 *                                          between different requests
3235
	 */
3236
	public function setAttachments($message, $attachments, $attachment_state) {
3237
		// Check if attachments should be deleted. This is set in the "upload_attachment.php" file
3238
		if (isset($attachments['dialog_attachments'])) {
3239
			$deleted = $attachment_state->getDeletedAttachments($attachments['dialog_attachments']);
3240
			if ($deleted) {
0 ignored issues
show
Bug Best Practice introduced by
The expression $deleted of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent.

Consider making the comparison explicit by using empty(..) or ! empty(...) instead.

Loading history...
3241
				foreach ($deleted as $attach_num) {
3242
					try {
3243
						mapi_message_deleteattach($message, (int) $attach_num);
3244
					}
3245
					catch (Exception) {
3246
						continue;
3247
					}
3248
				}
3249
				$attachment_state->clearDeletedAttachments($attachments['dialog_attachments']);
3250
			}
3251
		}
3252
3253
		$addedInlineAttachmentCidMapping = [];
3254
		if (is_array($attachments) && !empty($attachments)) {
3255
			// Set contentId to saved attachments.
3256
			if (isset($attachments['add']) && is_array($attachments['add']) && !empty($attachments['add'])) {
3257
				foreach ($attachments['add'] as $key => $attach) {
3258
					if ($attach && isset($attach['inline']) && $attach['inline']) {
3259
						$addedInlineAttachmentCidMapping[$attach['attach_num']] = $attach['cid'];
3260
						$msgattachment = mapi_message_openattach($message, $attach['attach_num']);
3261
						if ($msgattachment) {
3262
							$props = [PR_ATTACH_CONTENT_ID => $attach['cid'], PR_ATTACHMENT_HIDDEN => true];
3263
							mapi_setprops($msgattachment, $props);
3264
							mapi_savechanges($msgattachment);
3265
						}
3266
					}
3267
				}
3268
			}
3269
3270
			// Delete saved inline images if removed from body.
3271
			if (isset($attachments['remove']) && is_array($attachments['remove']) && !empty($attachments['remove'])) {
3272
				foreach ($attachments['remove'] as $key => $attach) {
3273
					if ($attach && isset($attach['inline']) && $attach['inline']) {
3274
						$msgattachment = mapi_message_openattach($message, $attach['attach_num']);
3275
						if ($msgattachment) {
3276
							mapi_message_deleteattach($message, $attach['attach_num']);
3277
							mapi_savechanges($message);
3278
						}
3279
					}
3280
				}
3281
			}
3282
		}
3283
3284
		if ($attachments['dialog_attachments']) {
3285
			$dialog_attachments = $attachments['dialog_attachments'];
3286
		}
3287
		else {
3288
			return;
3289
		}
3290
3291
		$files = $attachment_state->getAttachmentFiles($dialog_attachments);
3292
		if ($files) {
3293
			// Loop through the uploaded attachments
3294
			foreach ($files as $tmpname => $fileinfo) {
3295
				if ($fileinfo['sourcetype'] === 'embedded') {
3296
					// open message which needs to be embedded
3297
					$copyFromStore = $GLOBALS['mapisession']->openMessageStore(hex2bin((string) $fileinfo['store_entryid']));
3298
					$copyFrom = mapi_msgstore_openentry($copyFromStore, hex2bin((string) $fileinfo['entryid']));
3299
3300
					$msgProps = mapi_getprops($copyFrom, [PR_SUBJECT]);
3301
3302
					// get message and copy it to attachment table as embedded attachment
3303
					$props = [];
3304
					$props[PR_EC_WA_ATTACHMENT_ID] = $fileinfo['attach_id'];
3305
					$props[PR_ATTACH_METHOD] = ATTACH_EMBEDDED_MSG;
3306
					$props[PR_DISPLAY_NAME] = !empty($msgProps[PR_SUBJECT]) ? $msgProps[PR_SUBJECT] : _('Untitled');
3307
3308
					// Create new attachment.
3309
					$attachment = mapi_message_createattach($message);
3310
					mapi_setprops($attachment, $props);
3311
3312
					$imessage = mapi_attach_openobj($attachment, MAPI_CREATE | MAPI_MODIFY);
3313
3314
					// Copy the properties from the source message to the attachment
3315
					mapi_copyto($copyFrom, [], [], $imessage, 0); // includes attachments and recipients
3316
3317
					// save changes in the embedded message and the final attachment
3318
					mapi_savechanges($imessage);
3319
					mapi_savechanges($attachment);
3320
				}
3321
				elseif ($fileinfo['sourcetype'] === 'icsfile') {
3322
					$messageStore = $GLOBALS['mapisession']->openMessageStore(hex2bin((string) $fileinfo['store_entryid']));
3323
					$copyFrom = mapi_msgstore_openentry($messageStore, hex2bin((string) $fileinfo['entryid']));
3324
3325
					// Get addressbook for current session
3326
					$addrBook = $GLOBALS['mapisession']->getAddressbook();
3327
3328
					// get message properties.
3329
					$messageProps = mapi_getprops($copyFrom, [PR_SUBJECT]);
3330
3331
					// Read the appointment as RFC2445-formatted ics stream.
3332
					$appointmentStream = mapi_mapitoical($GLOBALS['mapisession']->getSession(), $addrBook, $copyFrom, []);
3333
3334
					$filename = (!empty($messageProps[PR_SUBJECT])) ? $messageProps[PR_SUBJECT] : _('Untitled');
3335
					$filename .= '.ics';
3336
3337
					$props = [
3338
						PR_ATTACH_LONG_FILENAME => $filename,
3339
						PR_DISPLAY_NAME => $filename,
3340
						PR_ATTACH_METHOD => ATTACH_BY_VALUE,
3341
						PR_ATTACH_DATA_BIN => "",
3342
						PR_ATTACH_MIME_TAG => "application/octet-stream",
3343
						PR_ATTACHMENT_HIDDEN => false,
3344
						PR_EC_WA_ATTACHMENT_ID => isset($fileinfo["attach_id"]) && !empty($fileinfo["attach_id"]) ? $fileinfo["attach_id"] : uniqid(),
3345
						PR_ATTACH_EXTENSION => pathinfo($filename, PATHINFO_EXTENSION),
3346
					];
3347
3348
					$attachment = mapi_message_createattach($message);
3349
					mapi_setprops($attachment, $props);
3350
3351
					// Stream the file to the PR_ATTACH_DATA_BIN property
3352
					$stream = mapi_openproperty($attachment, PR_ATTACH_DATA_BIN, IID_IStream, 0, MAPI_CREATE | MAPI_MODIFY);
3353
					mapi_stream_write($stream, $appointmentStream);
3354
3355
					// Commit the stream and save changes
3356
					mapi_stream_commit($stream);
3357
					mapi_savechanges($attachment);
3358
				}
3359
				else {
3360
					$filepath = $attachment_state->getAttachmentPath($tmpname);
3361
					if (is_file($filepath)) {
3362
						// Set contentId if attachment is inline
3363
						$cid = '';
3364
						if (isset($addedInlineAttachmentCidMapping[$tmpname])) {
3365
							$cid = $addedInlineAttachmentCidMapping[$tmpname];
3366
						}
3367
3368
						// If a .p7m file was manually uploaded by the user, we must change the mime type because
3369
						// otherwise mail applications will think the containing email is an encrypted email.
3370
						// That will make Outlook crash, and it will make grommunio Web show the original mail as encrypted
3371
						// without showing the attachment
3372
						$mimeType = $fileinfo["type"];
3373
						$smimeTags = ['multipart/signed', 'application/pkcs7-mime', 'application/x-pkcs7-mime'];
3374
						if (in_array($mimeType, $smimeTags)) {
3375
							$mimeType = "application/octet-stream";
3376
						}
3377
3378
						// Set attachment properties
3379
						$props = [
3380
							PR_ATTACH_LONG_FILENAME => $fileinfo["name"],
3381
							PR_DISPLAY_NAME => $fileinfo["name"],
3382
							PR_ATTACH_METHOD => ATTACH_BY_VALUE,
3383
							PR_ATTACH_DATA_BIN => "",
3384
							PR_ATTACH_MIME_TAG => $mimeType,
3385
							PR_ATTACHMENT_HIDDEN => !empty($cid) ? true : false,
3386
							PR_EC_WA_ATTACHMENT_ID => isset($fileinfo["attach_id"]) && !empty($fileinfo["attach_id"]) ? $fileinfo["attach_id"] : uniqid(),
3387
							PR_ATTACH_EXTENSION => pathinfo((string) $fileinfo["name"], PATHINFO_EXTENSION),
3388
						];
3389
3390
						if (isset($fileinfo['sourcetype']) && $fileinfo['sourcetype'] === 'contactphoto') {
3391
							$props[PR_ATTACHMENT_HIDDEN] = true;
3392
							$props[PR_ATTACHMENT_CONTACTPHOTO] = true;
3393
						}
3394
3395
						if (!empty($cid)) {
3396
							$props[PR_ATTACH_CONTENT_ID] = $cid;
3397
						}
3398
3399
						// Create attachment and set props
3400
						$attachment = mapi_message_createattach($message);
3401
						mapi_setprops($attachment, $props);
3402
3403
						// Stream the file to the PR_ATTACH_DATA_BIN property
3404
						$stream = mapi_openproperty($attachment, PR_ATTACH_DATA_BIN, IID_IStream, 0, MAPI_CREATE | MAPI_MODIFY);
3405
						$handle = fopen($filepath, "r");
3406
						while (!feof($handle)) {
3407
							$contents = fread($handle, BLOCK_SIZE);
3408
							mapi_stream_write($stream, $contents);
3409
						}
3410
3411
						// Commit the stream and save changes
3412
						mapi_stream_commit($stream);
3413
						mapi_savechanges($attachment);
3414
						fclose($handle);
3415
						unlink($filepath);
3416
					}
3417
				}
3418
			}
3419
3420
			// Delete all the files in the state.
3421
			$attachment_state->clearAttachmentFiles($dialog_attachments);
3422
		}
3423
	}
3424
3425
	/**
3426
	 * Copy attachments from original message.
3427
	 *
3428
	 * @see Operations::saveMessage()
3429
	 *
3430
	 * @param object          $message                   MAPI Message Object
3431
	 * @param string          $attachments
3432
	 * @param MAPIMessage     $copyFromMessage           if set, copy the attachments from this message in addition to the uploaded attachments
3433
	 * @param bool            $copyInlineAttachmentsOnly if true then copy only inline attachments
3434
	 * @param AttachmentState $attachment_state          the state object in which the attachments are saved
3435
	 *                                                   between different requests
3436
	 */
3437
	public function copyAttachments($message, $attachments, $copyFromMessage, $copyInlineAttachmentsOnly, $attachment_state) {
3438
		$attachmentTable = mapi_message_getattachmenttable($copyFromMessage);
3439
		if ($attachmentTable && isset($attachments['dialog_attachments'])) {
3440
			$existingAttachments = mapi_table_queryallrows($attachmentTable, [PR_ATTACH_NUM, PR_ATTACH_SIZE, PR_ATTACH_LONG_FILENAME, PR_ATTACHMENT_HIDDEN, PR_DISPLAY_NAME, PR_ATTACH_METHOD, PR_ATTACH_CONTENT_ID]);
3441
			$deletedAttachments = $attachment_state->getDeletedAttachments($attachments['dialog_attachments']);
3442
3443
			$plainText = $this->isPlainText($message);
3444
3445
			$properties = $GLOBALS['properties']->getMailProperties();
3446
			$blockStatus = mapi_getprops($copyFromMessage, [PR_BLOCK_STATUS]);
3447
			$blockStatus = Conversion::mapMAPI2XML($properties, $blockStatus);
3448
			$isSafeSender = false;
3449
3450
			// Here if message is HTML and block status is empty then and then call isSafeSender function
3451
			// to check that sender or sender's domain of original message was part of safe sender list.
3452
			if (!$plainText && empty($blockStatus)) {
3453
				$isSafeSender = $this->isSafeSender($copyFromMessage);
3454
			}
3455
3456
			$body = false;
3457
			foreach ($existingAttachments as $props) {
3458
				// check if this attachment is "deleted"
3459
3460
				if ($deletedAttachments && in_array($props[PR_ATTACH_NUM], $deletedAttachments)) {
0 ignored issues
show
Bug Best Practice introduced by
The expression $deletedAttachments of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent.

Consider making the comparison explicit by using empty(..) or ! empty(...) instead.

Loading history...
3461
					// skip attachment, remove reference from state as it no longer applies.
3462
					$attachment_state->removeDeletedAttachment($attachments['dialog_attachments'], $props[PR_ATTACH_NUM]);
3463
3464
					continue;
3465
				}
3466
3467
				$old = mapi_message_openattach($copyFromMessage, $props[PR_ATTACH_NUM]);
3468
				$isInlineAttachment = $attachment_state->isInlineAttachment($old);
3469
3470
				/*
3471
				 * If reply/reply all message, then copy only inline attachments.
3472
				 */
3473
				if ($copyInlineAttachmentsOnly) {
3474
					/*
3475
					 * if message is reply/reply all and format is plain text than ignore inline attachments
3476
					 * and normal attachments to copy from original mail.
3477
					 */
3478
					if ($plainText || !$isInlineAttachment) {
3479
						continue;
3480
					}
3481
				}
3482
				elseif ($plainText && $isInlineAttachment) {
3483
					/*
3484
					 * If message is forward and format of message is plain text then ignore only inline attachments from the
3485
					 * original mail.
3486
					 */
3487
					continue;
3488
				}
3489
3490
				/*
3491
				 * If the inline attachment is referenced with an content-id,
3492
				 * manually check if it's still referenced in the body otherwise remove it
3493
				 */
3494
				if ($isInlineAttachment) {
3495
					// Cache body, so we stream it once
3496
					if ($body === false) {
3497
						$body = streamProperty($message, PR_HTML);
3498
					}
3499
3500
					$contentID = $props[PR_ATTACH_CONTENT_ID];
3501
					if (!str_contains($body, (string) $contentID)) {
0 ignored issues
show
Bug introduced by
It seems like $body can also be of type false; however, parameter $haystack of str_contains() does only seem to accept string, maybe add an additional type check? ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

3501
					if (!str_contains(/** @scrutinizer ignore-type */ $body, (string) $contentID)) {
Loading history...
3502
						continue;
3503
					}
3504
				}
3505
3506
				/*
3507
				 * if message is reply/reply all or forward and format of message is HTML but
3508
				 * - inline attachments are not downloaded from external source
3509
				 * - sender of original message is not safe sender
3510
				 * - domain of sender is not part of safe sender list
3511
				 * then ignore inline attachments from original message.
3512
				 *
3513
				 * NOTE : blockStatus is only generated when user has download inline image from external source.
3514
				 * it should remains empty if user add the sender in to safe sender list.
3515
				 */
3516
				if (!$plainText && $isInlineAttachment && empty($blockStatus) && !$isSafeSender) {
3517
					continue;
3518
				}
3519
3520
				$new = mapi_message_createattach($message);
3521
3522
				try {
3523
					mapi_copyto($old, [], [], $new, 0);
3524
					mapi_savechanges($new);
3525
				}
3526
				catch (MAPIException $e) {
3527
					// This is a workaround for the grommunio-web issue 75
3528
					// Remove it after gromox issue 253 is resolved
3529
					if ($e->getCode() == ecMsgCycle) {
3530
						$oldstream = mapi_openproperty($old, PR_ATTACH_DATA_BIN, IID_IStream, 0, 0);
3531
						$stat = mapi_stream_stat($oldstream);
3532
						$props = mapi_attach_getprops($old, [PR_ATTACH_LONG_FILENAME, PR_ATTACH_MIME_TAG, PR_DISPLAY_NAME, PR_ATTACH_METHOD, PR_ATTACH_FILENAME, PR_ATTACHMENT_HIDDEN, PR_ATTACH_EXTENSION, PR_ATTACH_FLAGS]);
3533
3534
						mapi_setprops($new, [
3535
							PR_ATTACH_LONG_FILENAME => $props[PR_ATTACH_LONG_FILENAME] ?? '',
3536
							PR_ATTACH_MIME_TAG => $props[PR_ATTACH_MIME_TAG] ?? "application/octet-stream",
3537
							PR_DISPLAY_NAME => $props[PR_DISPLAY_NAME] ?? '',
3538
							PR_ATTACH_METHOD => $props[PR_ATTACH_METHOD] ?? ATTACH_BY_VALUE,
3539
							PR_ATTACH_FILENAME => $props[PR_ATTACH_FILENAME] ?? '',
3540
							PR_ATTACH_DATA_BIN => "",
3541
							PR_ATTACHMENT_HIDDEN => $props[PR_ATTACHMENT_HIDDEN] ?? false,
3542
							PR_ATTACH_EXTENSION => $props[PR_ATTACH_EXTENSION] ?? '',
3543
							PR_ATTACH_FLAGS => $props[PR_ATTACH_FLAGS] ?? 0,
3544
						]);
3545
						$newstream = mapi_openproperty($new, PR_ATTACH_DATA_BIN, IID_IStream, 0, MAPI_CREATE | MAPI_MODIFY);
3546
						mapi_stream_setsize($newstream, $stat['cb']);
3547
						for ($i = 0; $i < $stat['cb']; $i += BLOCK_SIZE) {
3548
							mapi_stream_write($newstream, mapi_stream_read($oldstream, BLOCK_SIZE));
3549
						}
3550
						mapi_stream_commit($newstream);
3551
						mapi_savechanges($new);
3552
					}
3553
				}
3554
			}
3555
		}
3556
	}
3557
3558
	/**
3559
	 * Function was used to identify the sender or domain of original mail in safe sender list.
3560
	 *
3561
	 * @param MAPIMessage $copyFromMessage resource of the message from which we should get
3562
	 *                                     the sender of message
3563
	 *
3564
	 * @return bool true if sender of original mail was safe sender else false
3565
	 */
3566
	public function isSafeSender($copyFromMessage) {
3567
		$safeSenderList = $GLOBALS['settings']->get('zarafa/v1/contexts/mail/safe_senders_list');
3568
		$senderEntryid = mapi_getprops($copyFromMessage, [PR_SENT_REPRESENTING_ENTRYID]);
3569
		$senderEntryid = $senderEntryid[PR_SENT_REPRESENTING_ENTRYID];
3570
3571
		// If sender is user himself (which happens in case of "Send as New message") consider sender as safe
3572
		if ($GLOBALS['entryid']->compareEntryIds($senderEntryid, $GLOBALS["mapisession"]->getUserEntryID())) {
3573
			return true;
3574
		}
3575
3576
		try {
3577
			$mailuser = mapi_ab_openentry($GLOBALS["mapisession"]->getAddressbook(), $senderEntryid);
3578
		}
3579
		catch (MAPIException) {
3580
			// The user might have a new uidNumber, which makes the user not resolve, see WA-7673
3581
			// FIXME: Lookup the user by PR_SENDER_NAME or another attribute if PR_SENDER_ADDRTYPE is "EX"
3582
			return false;
3583
		}
3584
3585
		$addressType = mapi_getprops($mailuser, [PR_ADDRTYPE]);
3586
3587
		// Here it will check that sender of original mail was address book user.
3588
		// If PR_ADDRTYPE is ZARAFA, it means sender of original mail was address book contact.
3589
		if ($addressType[PR_ADDRTYPE] === 'EX') {
3590
			$address = mapi_getprops($mailuser, [PR_SMTP_ADDRESS]);
3591
			$address = $address[PR_SMTP_ADDRESS];
3592
		}
3593
		elseif ($addressType[PR_ADDRTYPE] === 'SMTP') {
3594
			// If PR_ADDRTYPE is SMTP, it means sender of original mail was external sender.
3595
			$address = mapi_getprops($mailuser, [PR_EMAIL_ADDRESS]);
3596
			$address = $address[PR_EMAIL_ADDRESS];
3597
		}
3598
3599
		// Obtain the Domain address from smtp/email address.
3600
		$domain = substr((string) $address, strpos((string) $address, "@") + 1);
0 ignored issues
show
Comprehensibility Best Practice introduced by
The variable $address does not seem to be defined for all execution paths leading up to this point.
Loading history...
3601
3602
		if (!empty($safeSenderList)) {
3603
			foreach ($safeSenderList as $safeSender) {
3604
				if ($safeSender === $address || $safeSender === $domain) {
3605
					return true;
3606
				}
3607
			}
3608
		}
3609
3610
		return false;
3611
	}
3612
3613
	/**
3614
	 * get attachments information of a particular message.
3615
	 *
3616
	 * @param MapiMessage $message       MAPI Message Object
0 ignored issues
show
Bug introduced by
The type MapiMessage was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
3617
	 * @param bool        $excludeHidden exclude hidden attachments
3618
	 */
3619
	public function getAttachmentsInfo($message, $excludeHidden = false) {
3620
		$attachmentsInfo = [];
3621
3622
		$hasattachProp = mapi_getprops($message, [PR_HASATTACH]);
3623
		if (isset($hasattachProp[PR_HASATTACH]) && $hasattachProp[PR_HASATTACH]) {
3624
			$attachmentTable = mapi_message_getattachmenttable($message);
3625
3626
			$attachments = mapi_table_queryallrows($attachmentTable, [PR_ATTACH_NUM, PR_ATTACH_SIZE, PR_ATTACH_LONG_FILENAME,
3627
				PR_ATTACH_FILENAME, PR_ATTACHMENT_HIDDEN, PR_DISPLAY_NAME, PR_ATTACH_METHOD,
3628
				PR_ATTACH_CONTENT_ID, PR_ATTACH_MIME_TAG,
3629
				PR_ATTACHMENT_CONTACTPHOTO, PR_RECORD_KEY, PR_EC_WA_ATTACHMENT_ID, PR_OBJECT_TYPE, PR_ATTACH_EXTENSION, ]);
3630
			foreach ($attachments as $attachmentRow) {
3631
				$props = [];
3632
3633
				if (isset($attachmentRow[PR_ATTACH_MIME_TAG])) {
3634
					if ($attachmentRow[PR_ATTACH_MIME_TAG]) {
3635
						$props["filetype"] = $attachmentRow[PR_ATTACH_MIME_TAG];
3636
					}
3637
3638
					$smimeTags = ['multipart/signed', 'application/pkcs7-mime', 'application/x-pkcs7-mime'];
3639
					if (in_array($attachmentRow[PR_ATTACH_MIME_TAG], $smimeTags)) {
3640
						// Ignore the message with attachment types set as smime as they are for smime
3641
						continue;
3642
					}
3643
				}
3644
3645
				$attach_id = '';
3646
				if (isset($attachmentRow[PR_EC_WA_ATTACHMENT_ID])) {
3647
					$attach_id = $attachmentRow[PR_EC_WA_ATTACHMENT_ID];
3648
				}
3649
				elseif (isset($attachmentRow[PR_RECORD_KEY])) {
3650
					$attach_id = bin2hex((string) $attachmentRow[PR_RECORD_KEY]);
3651
				}
3652
				else {
3653
					$attach_id = uniqid();
3654
				}
3655
3656
				$props["object_type"] = $attachmentRow[PR_OBJECT_TYPE];
3657
				$props["attach_id"] = $attach_id;
3658
				$props["attach_num"] = $attachmentRow[PR_ATTACH_NUM];
3659
				$props["attach_method"] = $attachmentRow[PR_ATTACH_METHOD];
3660
				$props["size"] = $attachmentRow[PR_ATTACH_SIZE];
3661
3662
				if (isset($attachmentRow[PR_ATTACH_CONTENT_ID]) && $attachmentRow[PR_ATTACH_CONTENT_ID]) {
3663
					$props["cid"] = $attachmentRow[PR_ATTACH_CONTENT_ID];
3664
				}
3665
3666
				$props["hidden"] = $attachmentRow[PR_ATTACHMENT_HIDDEN] ?? false;
3667
				if ($excludeHidden && $props["hidden"]) {
3668
					continue;
3669
				}
3670
3671
				if (isset($attachmentRow[PR_ATTACH_LONG_FILENAME])) {
3672
					$props["name"] = $attachmentRow[PR_ATTACH_LONG_FILENAME];
3673
				}
3674
				elseif (isset($attachmentRow[PR_ATTACH_FILENAME])) {
3675
					$props["name"] = $attachmentRow[PR_ATTACH_FILENAME];
3676
				}
3677
				elseif (isset($attachmentRow[PR_DISPLAY_NAME])) {
3678
					$props["name"] = $attachmentRow[PR_DISPLAY_NAME];
3679
				}
3680
				else {
3681
					$props["name"] = "untitled";
3682
				}
3683
3684
				if (isset($attachmentRow[PR_ATTACH_EXTENSION]) && $attachmentRow[PR_ATTACH_EXTENSION]) {
3685
					$props["extension"] = $attachmentRow[PR_ATTACH_EXTENSION];
3686
				}
3687
				else {
3688
					// For backward compatibility where attachments doesn't have the extension property
3689
					$props["extension"] = pathinfo((string) $props["name"], PATHINFO_EXTENSION);
3690
				}
3691
3692
				if (isset($attachmentRow[PR_ATTACHMENT_CONTACTPHOTO]) && $attachmentRow[PR_ATTACHMENT_CONTACTPHOTO]) {
3693
					$props["attachment_contactphoto"] = $attachmentRow[PR_ATTACHMENT_CONTACTPHOTO];
3694
					$props["hidden"] = true;
3695
3696
					// Open contact photo attachment in binary format.
3697
					$attach = mapi_message_openattach($message, $props["attach_num"]);
0 ignored issues
show
Unused Code introduced by
The assignment to $attach is dead and can be removed.
Loading history...
3698
				}
3699
3700
				if ($props["attach_method"] == ATTACH_EMBEDDED_MSG) {
3701
					// open attachment to get the message class
3702
					$attach = mapi_message_openattach($message, $props["attach_num"]);
3703
					$embMessage = mapi_attach_openobj($attach);
3704
					$embProps = mapi_getprops($embMessage, [PR_MESSAGE_CLASS]);
3705
					if (isset($embProps[PR_MESSAGE_CLASS])) {
3706
						$props["attach_message_class"] = $embProps[PR_MESSAGE_CLASS];
3707
					}
3708
				}
3709
3710
				array_push($attachmentsInfo, ["props" => $props]);
3711
			}
3712
		}
3713
3714
		return $attachmentsInfo;
3715
	}
3716
3717
	/**
3718
	 * get recipients information of a particular message.
3719
	 *
3720
	 * @param MapiMessage $message        MAPI Message Object
3721
	 * @param bool        $excludeDeleted exclude deleted recipients
3722
	 */
3723
	public function getRecipientsInfo($message, $excludeDeleted = true) {
3724
		$recipientsInfo = [];
3725
3726
		$recipientTable = mapi_message_getrecipienttable($message);
3727
		if ($recipientTable) {
3728
			$recipients = mapi_table_queryallrows($recipientTable, $GLOBALS['properties']->getRecipientProperties());
3729
3730
			foreach ($recipients as $recipientRow) {
3731
				if ($excludeDeleted && isset($recipientRow[PR_RECIPIENT_FLAGS]) && (($recipientRow[PR_RECIPIENT_FLAGS] & recipExceptionalDeleted) == recipExceptionalDeleted)) {
3732
					continue;
3733
				}
3734
3735
				$props = [];
3736
				$props['rowid'] = $recipientRow[PR_ROWID];
3737
				$props['search_key'] = isset($recipientRow[PR_SEARCH_KEY]) ? bin2hex((string) $recipientRow[PR_SEARCH_KEY]) : '';
3738
				$props['display_name'] = $recipientRow[PR_DISPLAY_NAME] ?? '';
3739
				$props['email_address'] = $recipientRow[PR_EMAIL_ADDRESS] ?? '';
3740
				$props['smtp_address'] = $recipientRow[PR_SMTP_ADDRESS] ?? '';
3741
				$props['address_type'] = $recipientRow[PR_ADDRTYPE] ?? '';
3742
				$props['object_type'] = $recipientRow[PR_OBJECT_TYPE] ?? MAPI_MAILUSER;
3743
				$props['recipient_type'] = $recipientRow[PR_RECIPIENT_TYPE];
3744
				$props['display_type'] = $recipientRow[PR_DISPLAY_TYPE] ?? DT_MAILUSER;
3745
				$props['display_type_ex'] = $recipientRow[PR_DISPLAY_TYPE_EX] ?? DT_MAILUSER;
3746
3747
				if (isset($recipientRow[PR_RECIPIENT_FLAGS])) {
3748
					$props['recipient_flags'] = $recipientRow[PR_RECIPIENT_FLAGS];
3749
				}
3750
3751
				if (isset($recipientRow[PR_ENTRYID])) {
3752
					$props['entryid'] = bin2hex((string) $recipientRow[PR_ENTRYID]);
3753
3754
					// Get the SMTP address from the addressbook if no address is found
3755
					if (empty($props['smtp_address']) && ($recipientRow[PR_ADDRTYPE] == 'EX' || $props['address_type'] === 'ZARAFA')) {
3756
						$recipientSearchKey = $recipientRow[PR_SEARCH_KEY] ?? false;
3757
						$props['smtp_address'] = $this->getEmailAddress($recipientRow[PR_ENTRYID], $recipientSearchKey);
3758
					}
3759
				}
3760
3761
				// smtp address is still empty(in case of external email address) than
3762
				// value of email address is copied into smtp address.
3763
				if ($props['address_type'] == 'SMTP' && empty($props['smtp_address'])) {
3764
					$props['smtp_address'] = $props['email_address'];
3765
				}
3766
3767
				// PST importer imports items without an entryid and as SMTP recipient, this causes issues for
3768
				// opening meeting requests with removed users as recipient.
3769
				// gromox-kdb2mt might import items without an entryid and
3770
				// PR_ADDRTYPE 'ZARAFA' which causes issues when opening such messages.
3771
				if (empty($props['entryid']) && ($props['address_type'] === 'SMTP' || $props['address_type'] === 'ZARAFA')) {
3772
					$props['entryid'] = bin2hex(mapi_createoneoff($props['display_name'], $props['address_type'], $props['smtp_address'], MAPI_UNICODE));
3773
				}
3774
3775
				// Set propose new time properties
3776
				if (isset($recipientRow[PR_RECIPIENT_PROPOSED], $recipientRow[PR_RECIPIENT_PROPOSEDSTARTTIME], $recipientRow[PR_RECIPIENT_PROPOSEDENDTIME])) {
3777
					$props['proposednewtime_start'] = $recipientRow[PR_RECIPIENT_PROPOSEDSTARTTIME];
3778
					$props['proposednewtime_end'] = $recipientRow[PR_RECIPIENT_PROPOSEDENDTIME];
3779
					$props['proposednewtime'] = $recipientRow[PR_RECIPIENT_PROPOSED];
3780
				}
3781
				else {
3782
					$props['proposednewtime'] = false;
3783
				}
3784
3785
				$props['recipient_trackstatus'] = $recipientRow[PR_RECIPIENT_TRACKSTATUS] ?? olRecipientTrackStatusNone;
3786
				$props['recipient_trackstatus_time'] = $recipientRow[PR_RECIPIENT_TRACKSTATUS_TIME] ?? null;
3787
3788
				array_push($recipientsInfo, ["props" => $props]);
3789
			}
3790
		}
3791
3792
		return $recipientsInfo;
3793
	}
3794
3795
	/**
3796
	 * Extracts email address from PR_SEARCH_KEY property if possible.
3797
	 *
3798
	 * @param string $searchKey The PR_SEARCH_KEY property
3799
	 *
3800
	 * @return string email address if possible else return empty string
3801
	 */
3802
	public function getEmailAddressFromSearchKey($searchKey) {
3803
		if (str_contains($searchKey, ':') && str_contains($searchKey, '@')) {
3804
			return trim(strtolower(explode(':', $searchKey)[1]));
3805
		}
3806
3807
		return "";
3808
	}
3809
3810
	/**
3811
	 * Create a MAPI recipient list from an XML array structure.
3812
	 *
3813
	 * This functions is used for setting the recipient table of a message.
3814
	 *
3815
	 * @param array  $recipientList a list of recipients as XML array structure
3816
	 * @param string $opType        the type of operation that will be performed on this recipient list (add, remove, modify)
3817
	 * @param bool   $send          true if we are going to send this message else false
3818
	 * @param mixed  $isException
3819
	 *
3820
	 * @return array list of recipients with the correct MAPI properties ready for mapi_message_modifyrecipients()
3821
	 */
3822
	public function createRecipientList($recipientList, $opType = 'add', $isException = false, $send = false) {
3823
		$recipients = [];
3824
		$addrbook = $GLOBALS["mapisession"]->getAddressbook();
3825
3826
		foreach ($recipientList as $recipientItem) {
3827
			if ($isException) {
3828
				// We do not add organizer to exception msg in organizer's calendar.
3829
				if (isset($recipientItem[PR_RECIPIENT_FLAGS]) && $recipientItem[PR_RECIPIENT_FLAGS] == (recipSendable | recipOrganizer)) {
3830
					continue;
3831
				}
3832
3833
				$recipient[PR_RECIPIENT_FLAGS] = (recipSendable | recipExceptionalResponse | recipReserved);
3834
			}
3835
3836
			if (!empty($recipientItem["smtp_address"]) && empty($recipientItem["email_address"])) {
3837
				$recipientItem["email_address"] = $recipientItem["smtp_address"];
3838
			}
3839
3840
			// When saving a mail we can allow an empty email address or entryid, but not when sending it
3841
			if ($send && empty($recipientItem["email_address"]) && empty($recipientItem['entryid'])) {
3842
				return;
3843
			}
3844
3845
			// to modify or remove recipients we need PR_ROWID property
3846
			if ($opType !== 'add' && (!isset($recipientItem['rowid']) || !is_numeric($recipientItem['rowid']))) {
3847
				continue;
3848
			}
3849
3850
			if (isset($recipientItem['search_key']) && !empty($recipientItem['search_key'])) {
3851
				// search keys sent from client are in hex format so convert it to binary format
3852
				$recipientItem['search_key'] = hex2bin((string) $recipientItem['search_key']);
3853
			}
3854
3855
			if (isset($recipientItem["entryid"]) && !empty($recipientItem["entryid"])) {
3856
				// entryids sent from client are in hex format so convert it to binary format
3857
				$recipientItem["entryid"] = hex2bin((string) $recipientItem["entryid"]);
3858
3859
			// Only resolve the recipient when no entryid is set
3860
			}
3861
			else {
3862
				/**
3863
				 * For external contacts (DT_REMOTE_MAILUSER) email_address contains display name of contact
3864
				 * which is obviously not unique so for that we need to resolve address based on smtp_address
3865
				 * if provided.
3866
				 */
3867
				$addressToResolve = $recipientItem["email_address"];
3868
				if (!empty($recipientItem["smtp_address"])) {
3869
					$addressToResolve = $recipientItem["smtp_address"];
3870
				}
3871
3872
				// Resolve the recipient
3873
				$user = [[PR_DISPLAY_NAME => $addressToResolve]];
3874
3875
				try {
3876
					// resolve users based on email address with strict matching
3877
					$user = mapi_ab_resolvename($addrbook, $user, EMS_AB_ADDRESS_LOOKUP);
3878
					$recipientItem["display_name"] = $user[0][PR_DISPLAY_NAME];
3879
					$recipientItem["entryid"] = $user[0][PR_ENTRYID];
3880
					$recipientItem["search_key"] = $user[0][PR_SEARCH_KEY];
3881
					$recipientItem["email_address"] = $user[0][PR_EMAIL_ADDRESS];
3882
					$recipientItem["address_type"] = $user[0][PR_ADDRTYPE];
3883
				}
3884
				catch (MAPIException $e) {
3885
					// recipient is not resolved or it got multiple matches,
3886
					// so ignore this error and continue with normal processing
3887
					$e->setHandled();
3888
				}
3889
			}
3890
3891
			$recipient = [];
3892
			$recipient[PR_DISPLAY_NAME] = $recipientItem["display_name"];
3893
			$recipient[PR_DISPLAY_TYPE] = $recipientItem["display_type"];
3894
			$recipient[PR_DISPLAY_TYPE_EX] = $recipientItem["display_type_ex"];
3895
			$recipient[PR_EMAIL_ADDRESS] = $recipientItem["email_address"];
3896
			$recipient[PR_SMTP_ADDRESS] = $recipientItem["smtp_address"];
3897
			if (isset($recipientItem["search_key"])) {
3898
				$recipient[PR_SEARCH_KEY] = $recipientItem["search_key"];
3899
			}
3900
			$recipient[PR_ADDRTYPE] = $recipientItem["address_type"];
3901
			$recipient[PR_OBJECT_TYPE] = $recipientItem["object_type"];
3902
			$recipient[PR_RECIPIENT_TYPE] = $recipientItem["recipient_type"];
3903
			if ($opType != 'add') {
3904
				$recipient[PR_ROWID] = $recipientItem["rowid"];
3905
			}
3906
3907
			if (isset($recipientItem["recipient_status"]) && !empty($recipientItem["recipient_status"])) {
3908
				$recipient[PR_RECIPIENT_TRACKSTATUS] = $recipientItem["recipient_status"];
3909
			}
3910
3911
			if (isset($recipientItem["recipient_flags"]) && !empty($recipient["recipient_flags"])) {
3912
				$recipient[PR_RECIPIENT_FLAGS] = $recipientItem["recipient_flags"];
3913
			}
3914
			else {
3915
				$recipient[PR_RECIPIENT_FLAGS] = recipSendable;
3916
			}
3917
3918
			if (isset($recipientItem["proposednewtime"]) && !empty($recipientItem["proposednewtime"]) && isset($recipientItem["proposednewtime_start"], $recipientItem["proposednewtime_end"])) {
3919
				$recipient[PR_RECIPIENT_PROPOSED] = $recipientItem["proposednewtime"];
3920
				$recipient[PR_RECIPIENT_PROPOSEDSTARTTIME] = $recipientItem["proposednewtime_start"];
3921
				$recipient[PR_RECIPIENT_PROPOSEDENDTIME] = $recipientItem["proposednewtime_end"];
3922
			}
3923
			else {
3924
				$recipient[PR_RECIPIENT_PROPOSED] = false;
3925
			}
3926
3927
			// Use given entryid if possible, otherwise create a one-off entryid
3928
			if (isset($recipientItem["entryid"]) && !empty($recipientItem["entryid"])) {
3929
				$recipient[PR_ENTRYID] = $recipientItem["entryid"];
3930
			}
3931
			elseif ($send) {
3932
				// only create one-off entryid when we are actually sending the message not saving it
3933
				$recipient[PR_ENTRYID] = mapi_createoneoff($recipient[PR_DISPLAY_NAME], $recipient[PR_ADDRTYPE], $recipient[PR_EMAIL_ADDRESS]);
3934
			}
3935
3936
			array_push($recipients, $recipient);
3937
		}
3938
3939
		return $recipients;
3940
	}
3941
3942
	/**
3943
	 * Function which is get store of external resource from entryid.
3944
	 *
3945
	 * @param string $entryid entryid of the shared folder record
3946
	 *
3947
	 * @return object/boolean $store store of shared folder if found otherwise false
0 ignored issues
show
Documentation Bug introduced by
The doc comment object/boolean at position 0 could not be parsed: Unknown type name 'object/boolean' at position 0 in object/boolean.
Loading history...
3948
	 *
3949
	 * FIXME: this function is pretty inefficient, since it opens the store for every
3950
	 * shared user in the worst case. Might be that we could extract the guid from
3951
	 * the $entryid and compare it and fetch the guid from the userentryid.
3952
	 * C++ has a GetStoreGuidFromEntryId() function.
3953
	 */
3954
	public function getOtherStoreFromEntryid($entryid) {
3955
		// Get all external user from settings
3956
		$otherUsers = $GLOBALS['mapisession']->retrieveOtherUsersFromSettings();
3957
3958
		// Fetch the store of each external user and
3959
		// find the record with given entryid
3960
		foreach ($otherUsers as $sharedUser => $values) {
3961
			$userEntryid = mapi_msgstore_createentryid($GLOBALS['mapisession']->getDefaultMessageStore(), $sharedUser);
3962
			$store = $GLOBALS['mapisession']->openMessageStore($userEntryid);
3963
			if ($GLOBALS['entryid']->hasContactProviderGUID($entryid)) {
3964
				$entryid = $GLOBALS["entryid"]->unwrapABEntryIdObj($entryid);
3965
			}
3966
3967
			try {
3968
				$record = mapi_msgstore_openentry($store, hex2bin((string) $entryid));
3969
				if ($record) {
3970
					return $store;
3971
				}
3972
			}
3973
			catch (MAPIException) {
0 ignored issues
show
Coding Style Comprehensibility introduced by
Consider adding a comment why this CATCH block is empty.
Loading history...
3974
			}
3975
		}
3976
3977
		return false;
3978
	}
3979
3980
	/**
3981
	 * Function which is use to check the contact item (distribution list / contact)
3982
	 * belongs to any external folder or not.
3983
	 *
3984
	 * @param string $entryid entryid of contact item
3985
	 *
3986
	 * @return bool true if contact item from external folder otherwise false.
3987
	 *
3988
	 * FIXME: this function is broken and returns true if the user is a contact in a shared store.
3989
	 * Also research if we cannot just extract the GUID and compare it with our own GUID.
3990
	 * FIXME This function should be renamed, because it's also meant for normal shared folder contacts.
3991
	 */
3992
	public function isExternalContactItem($entryid) {
3993
		try {
3994
			if (!$GLOBALS['entryid']->hasContactProviderGUID(bin2hex($entryid))) {
3995
				$entryid = hex2bin((string) $GLOBALS['entryid']->wrapABEntryIdObj(bin2hex($entryid), MAPI_DISTLIST));
3996
			}
3997
			mapi_ab_openentry($GLOBALS["mapisession"]->getAddressbook(), $entryid);
3998
		}
3999
		catch (MAPIException) {
4000
			return true;
4001
		}
4002
4003
		return false;
4004
	}
4005
4006
	/**
4007
	 * Get object type from distlist type of member of distribution list.
4008
	 *
4009
	 * @param int $distlistType distlist type of distribution list
4010
	 *
4011
	 * @return int object type of distribution list
4012
	 */
4013
	public function getObjectTypeFromDistlistType($distlistType) {
4014
		return match ($distlistType) {
4015
			DL_DIST, DL_DIST_AB => MAPI_DISTLIST,
4016
			default => MAPI_MAILUSER,
4017
		};
4018
	}
4019
4020
	/**
4021
	 * Function which fetches all members of shared/internal(Local Contact Folder)
4022
	 * folder's distribution list.
4023
	 *
4024
	 * @param string $distlistEntryid entryid of distribution list
4025
	 * @param bool   $isRecursive     if there is/are distribution list(s) inside the distlist
4026
	 *                                to expand all the members, pass true to expand distlist recursively, false to not expand
4027
	 *
4028
	 * @return array $members all members of a distribution list
4029
	 */
4030
	public function expandDistList($distlistEntryid, $isRecursive = false) {
4031
		$properties = $GLOBALS['properties']->getDistListProperties();
4032
		$eidObj = $GLOBALS['entryid']->createABEntryIdObj($distlistEntryid);
4033
		$isMuidGuid = !$GLOBALS['entryid']->hasNoMuid('', $eidObj);
4034
		$extidObj = $isMuidGuid ?
4035
			$GLOBALS['entryid']->createMessageEntryIdObj($eidObj['extid']) :
4036
			$GLOBALS['entryid']->createMessageEntryIdObj($GLOBALS['entryid']->createMessageEntryId($eidObj));
4037
4038
		$store = $GLOBALS["mapisession"]->getDefaultMessageStore();
4039
		$contactFolderId = $this->getPropertiesFromStoreRoot($store, [PR_IPM_CONTACT_ENTRYID]);
4040
		$contactFolderidObj = $GLOBALS['entryid']->createFolderEntryIdObj(bin2hex((string) $contactFolderId[PR_IPM_CONTACT_ENTRYID]));
4041
4042
		if ($contactFolderidObj['providerguid'] != $extidObj['providerguid'] && $contactFolderidObj['folderdbguid'] != $extidObj['folderdbguid']) {
4043
			$storelist = $GLOBALS["mapisession"]->getAllMessageStores();
4044
			foreach ($storelist as $storeObj) {
4045
				$contactFolderId = $this->getPropertiesFromStoreRoot($storeObj, [PR_IPM_CONTACT_ENTRYID]);
4046
				if (isset($contactFolderId[PR_IPM_CONTACT_ENTRYID])) {
4047
					$contactFolderidObj = $GLOBALS['entryid']->createFolderEntryIdObj(bin2hex((string) $contactFolderId[PR_IPM_CONTACT_ENTRYID]));
4048
					if ($contactFolderidObj['providerguid'] == $extidObj['providerguid'] && $contactFolderidObj['folderdbguid'] == $extidObj['folderdbguid']) {
4049
						$store = $storeObj;
4050
						break;
4051
					}
4052
				}
4053
			}
4054
		}
4055
4056
		if ($isMuidGuid) {
4057
			$distlistEntryid = $GLOBALS["entryid"]->unwrapABEntryIdObj($distlistEntryid);
4058
		}
4059
4060
		try {
4061
			$distlist = $this->openMessage($store, hex2bin((string) $distlistEntryid));
4062
		}
4063
		catch (Exception) {
4064
			// the distribution list is in a public folder
4065
			$distlist = $this->openMessage($GLOBALS["mapisession"]->getPublicMessageStore(), hex2bin((string) $distlistEntryid));
4066
		}
4067
4068
		// Retrieve the members from distribution list.
4069
		$distlistMembers = $this->getMembersFromDistributionList($store, $distlist, $properties, $isRecursive);
0 ignored issues
show
Bug introduced by
$distlist of type object is incompatible with the type resource expected by parameter $message of Operations::getMembersFromDistributionList(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

4069
		$distlistMembers = $this->getMembersFromDistributionList($store, /** @scrutinizer ignore-type */ $distlist, $properties, $isRecursive);
Loading history...
4070
		$recipients = [];
4071
4072
		foreach ($distlistMembers as $member) {
4073
			$props = $this->convertDistlistMemberToRecipient($store, $member);
4074
			array_push($recipients, $props);
4075
		}
4076
4077
		return $recipients;
4078
	}
4079
4080
	/**
4081
	 * Function Which convert the shared/internal(local contact folder distlist)
4082
	 * folder's distlist members to recipient type.
4083
	 *
4084
	 * @param mapistore $store  MAPI store of the message
4085
	 * @param array     $member of distribution list contacts
4086
	 *
4087
	 * @return array members properties converted in to recipient
4088
	 */
4089
	public function convertDistlistMemberToRecipient($store, $member) {
4090
		$entryid = $member["props"]["entryid"];
4091
		$memberProps = $member["props"];
4092
		$props = [];
4093
4094
		$distlistType = $memberProps["distlist_type"];
4095
		$addressType = $memberProps["address_type"];
4096
4097
		$isGABDistlList = $distlistType == DL_DIST_AB && $addressType === "EX";
4098
		$isLocalDistlist = $distlistType == DL_DIST && $addressType === "MAPIPDL";
4099
4100
		$isGABContact = $memberProps["address_type"] === 'EX';
4101
		// If distlist_type is 0 then it means distlist member is external contact.
4102
		// For mare please read server/core/constants.php
4103
		$isLocalContact = !$isGABContact && $distlistType !== 0;
4104
4105
		/*
4106
		 * If distribution list belongs to the local contact folder then open that contact and
4107
		 * retrieve all properties which requires to prepare ideal recipient to send mail.
4108
		 */
4109
		if ($isLocalDistlist) {
4110
			try {
4111
				$distlist = $this->openMessage($store, hex2bin((string) $entryid));
4112
			}
4113
			catch (Exception) {
4114
				$distlist = $this->openMessage($GLOBALS["mapisession"]->getPublicMessageStore(), hex2bin((string) $entryid));
4115
			}
4116
4117
			$abProps = $this->getProps($distlist, $GLOBALS['properties']->getRecipientProperties());
4118
			$props = $abProps["props"];
4119
4120
			$props["entryid"] = $GLOBALS["entryid"]->wrapABEntryIdObj($abProps["entryid"], MAPI_DISTLIST);
4121
			$props["display_type"] = DT_DISTLIST;
4122
			$props["display_type_ex"] = DT_DISTLIST;
4123
			$props["address_type"] = $memberProps["address_type"];
4124
			$emailAddress = !empty($memberProps["email_address"]) ? $memberProps["email_address"] : "";
4125
			$props["smtp_address"] = $emailAddress;
4126
			$props["email_address"] = $emailAddress;
4127
		}
4128
		elseif ($isGABContact || $isGABDistlList) {
4129
			/*
4130
			 * If contact or distribution list belongs to GAB then open that contact and
4131
			 * retrieve all properties which requires to prepare ideal recipient to send mail.
4132
			 */
4133
			try {
4134
				$abentry = mapi_ab_openentry($GLOBALS["mapisession"]->getAddressbook(), hex2bin((string) $entryid));
4135
				$abProps = $this->getProps($abentry, $GLOBALS['properties']->getRecipientProperties());
4136
				$props = $abProps["props"];
4137
				$props["entryid"] = $abProps["entryid"];
4138
			}
4139
			catch (Exception $e) {
4140
				// Throw MAPI_E_NOT_FOUND or MAPI_E_UNKNOWN_ENTRYID it may possible that contact is already
4141
				// deleted from server. so just create recipient
4142
				// with existing information of distlist member.
4143
				// recipient is not valid so sender get report mail for that
4144
				// particular recipient to inform that recipient is not exist.
4145
				if ($e->getCode() == MAPI_E_NOT_FOUND || $e->getCode() == MAPI_E_UNKNOWN_ENTRYID) {
4146
					$props["entryid"] = $memberProps["entryid"];
4147
					$props["display_type"] = DT_MAILUSER;
4148
					$props["display_type_ex"] = DT_MAILUSER;
4149
					$props["display_name"] = $memberProps["display_name"];
4150
					$props["smtp_address"] = $memberProps["email_address"];
4151
					$props["email_address"] = $memberProps["email_address"];
4152
					$props["address_type"] = !empty($memberProps["address_type"]) ? $memberProps["address_type"] : 'SMTP';
4153
				}
4154
				else {
4155
					throw $e;
4156
				}
4157
			}
4158
		}
4159
		else {
4160
			/*
4161
			 * If contact is belongs to local/shared folder then prepare ideal recipient to send mail
4162
			 * as per the contact type.
4163
			 */
4164
			$props["entryid"] = $isLocalContact ? $GLOBALS["entryid"]->wrapABEntryIdObj($entryid, MAPI_MAILUSER) : $memberProps["entryid"];
4165
			$props["display_type"] = DT_MAILUSER;
4166
			$props["display_type_ex"] = $isLocalContact ? DT_MAILUSER : DT_REMOTE_MAILUSER;
4167
			$props["display_name"] = $memberProps["display_name"];
4168
			$props["smtp_address"] = $memberProps["email_address"];
4169
			$props["email_address"] = $memberProps["email_address"];
4170
			$props["address_type"] = !empty($memberProps["address_type"]) ? $memberProps["address_type"] : 'SMTP';
4171
		}
4172
4173
		// Set object type property into each member of distribution list
4174
		$props["object_type"] = $this->getObjectTypeFromDistlistType($memberProps["distlist_type"]);
4175
4176
		return $props;
4177
	}
4178
4179
	/**
4180
	 * Parse reply-to value from PR_REPLY_RECIPIENT_ENTRIES property.
4181
	 *
4182
	 * @param string $flatEntryList the PR_REPLY_RECIPIENT_ENTRIES value
4183
	 *
4184
	 * @return array list of recipients in array structure
4185
	 */
4186
	public function readReplyRecipientEntry($flatEntryList) {
4187
		$addressbook = $GLOBALS["mapisession"]->getAddressbook();
4188
		$entryids = [];
4189
4190
		// Unpack number of entries, the byte count and the entries
4191
		$unpacked = unpack('V1cEntries/V1cbEntries/a*', $flatEntryList);
4192
4193
		// $unpacked consists now of the following fields:
4194
		//	'cEntries' => The number of entryids in our list
4195
		//	'cbEntries' => The total number of bytes inside 'abEntries'
4196
		//	'abEntries' => The list of Entryids
4197
		//
4198
		// Each 'abEntries' can be broken down into groups of 2 fields
4199
		//	'cb' => The length of the entryid
4200
		//	'entryid' => The entryid
4201
4202
		$position = 8; // sizeof(cEntries) + sizeof(cbEntries);
4203
4204
		for ($i = 0, $len = $unpacked['cEntries']; $i < $len; ++$i) {
4205
			// Obtain the size for the current entry
4206
			$size = unpack('a' . $position . '/V1cb/a*', $flatEntryList);
4207
4208
			// We have the size, now can obtain the bytes
4209
			$entryid = unpack('a' . $position . '/V1cb/a' . $size['cb'] . 'entryid/a*', $flatEntryList);
4210
4211
			// unpack() will remove the NULL characters, re-add
4212
			// them until we match the 'cb' length.
4213
			while ($entryid['cb'] > strlen((string) $entryid['entryid'])) {
4214
				$entryid['entryid'] .= chr(0x00);
4215
			}
4216
4217
			$entryids[] = $entryid['entryid'];
4218
4219
			// sizeof(cb) + strlen(entryid)
4220
			$position += 4 + $entryid['cb'];
4221
		}
4222
4223
		$recipients = [];
4224
		foreach ($entryids as $entryid) {
4225
			// Check if entryid extracted, since unpack errors can not be caught.
4226
			if (!$entryid) {
4227
				continue;
4228
			}
4229
4230
			// Handle malformed entryids
4231
			try {
4232
				$entry = mapi_ab_openentry($addressbook, $entryid);
4233
				$props = mapi_getprops($entry, [PR_ENTRYID, PR_SEARCH_KEY, PR_OBJECT_TYPE, PR_DISPLAY_NAME, PR_ADDRTYPE, PR_EMAIL_ADDRESS]);
4234
4235
				// Put data in recipient array
4236
				$recipients[] = $this->composeRecipient(count($recipients), $props);
4237
			}
4238
			catch (MAPIException $e) {
4239
				try {
4240
					$oneoff = mapi_parseoneoff($entryid);
4241
				}
4242
				catch (MAPIException $ex) {
4243
					error_log(sprintf(
4244
						"readReplyRecipientEntry unable to open AB entry and mapi_parseoneoff failed: %s - %s",
4245
						get_mapi_error_name($ex->getCode()),
4246
						$ex->getDisplayMessage()
4247
					));
4248
4249
					continue;
4250
				}
4251
				if (!isset($oneoff['address'])) {
4252
					error_log(sprintf(
4253
						"readReplyRecipientEntry unable to open AB entry and oneoff address is not available: %s - %s ",
4254
						get_mapi_error_name($e->getCode()),
4255
						$e->getDisplayMessage()
4256
					));
4257
4258
					continue;
4259
				}
4260
4261
				$entryid = mapi_createoneoff($oneoff['name'] ?? '', $oneoff['type'] ?? 'SMTP', $oneoff['address']);
4262
				$props = [
4263
					PR_ENTRYID => $entryid,
4264
					PR_DISPLAY_NAME => !empty($oneoff['name']) ? $oneoff['name'] : $oneoff['address'],
4265
					PR_ADDRTYPE => $oneoff['type'] ?? 'SMTP',
4266
					PR_EMAIL_ADDRESS => $oneoff['address'],
4267
				];
4268
				$recipients[] = $this->composeRecipient(count($recipients), $props);
4269
			}
4270
		}
4271
4272
		return $recipients;
4273
	}
4274
4275
	private function composeRecipient($rowid, $props) {
4276
		return [
4277
			'rowid' => $rowid,
4278
			'props' => [
4279
				'entryid' => !empty($props[PR_ENTRYID]) ? bin2hex((string) $props[PR_ENTRYID]) : '',
4280
				'object_type' => $props[PR_OBJECT_TYPE] ?? MAPI_MAILUSER,
4281
				'search_key' => $props[PR_SEARCH_KEY] ?? '',
4282
				'display_name' => !empty($props[PR_DISPLAY_NAME]) ? $props[PR_DISPLAY_NAME] : $props[PR_EMAIL_ADDRESS],
4283
				'address_type' => $props[PR_ADDRTYPE] ?? 'SMTP',
4284
				'email_address' => $props[PR_EMAIL_ADDRESS] ?? '',
4285
				'smtp_address' => $props[PR_EMAIL_ADDRESS] ?? '',
4286
			],
4287
		];
4288
	}
4289
4290
	/**
4291
	 * Build full-page HTML from the TinyMCE HTML.
4292
	 *
4293
	 * This function basically takes the generated HTML from TinyMCE and embeds it in
4294
	 * a standalone HTML page (including header and CSS) to form.
4295
	 *
4296
	 * @param string $body  This is the HTML created by the TinyMCE
4297
	 * @param string $title Optional, this string is placed in the <title>
4298
	 *
4299
	 * @return string full HTML message
4300
	 */
4301
	public function generateBodyHTML($body, $title = "grommunio-web") {
4302
		$html = "<!DOCTYPE html>" .
4303
				"<html>\n" .
4304
				"<head>\n" .
4305
				"  <meta name=\"Generator\" content=\"grommunio-web v" . trim(file_get_contents('version')) . "\">\n" .
4306
				"  <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n" .
4307
				"  <title>" . htmlspecialchars($title) . "</title>\n";
4308
4309
		$html .= "</head>\n" .
4310
				"<body>\n" .
4311
				$body . "\n" .
4312
				"</body>\n" .
4313
				"</html>";
4314
4315
		return $html;
4316
	}
4317
4318
	/**
4319
	 * Calculate the total size for all items in the given folder.
4320
	 *
4321
	 * @param mapifolder $folder The folder for which the size must be calculated
0 ignored issues
show
Bug introduced by
The type mapifolder was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
4322
	 *
4323
	 * @return number The folder size
4324
	 */
4325
	public function calcFolderMessageSize($folder) {
4326
		$folderProps = mapi_getprops($folder, [PR_MESSAGE_SIZE_EXTENDED]);
4327
4328
		return $folderProps[PR_MESSAGE_SIZE_EXTENDED] ?? 0;
4329
	}
4330
4331
	/**
4332
	 * Detect plaintext body type of message.
4333
	 *
4334
	 * @param mapimessage $message MAPI message resource to check
4335
	 *
4336
	 * @return bool TRUE if the message is a plaintext message, FALSE if otherwise
4337
	 */
4338
	public function isPlainText($message) {
4339
		$props = mapi_getprops($message, [PR_NATIVE_BODY_INFO]);
4340
		if (isset($props[PR_NATIVE_BODY_INFO]) && $props[PR_NATIVE_BODY_INFO] == 1) {
4341
			return true;
4342
		}
4343
4344
		return false;
4345
	}
4346
4347
	/**
4348
	 * Parse email recipient list and add all e-mail addresses to the recipient history.
4349
	 *
4350
	 * The recipient history is used for auto-suggestion when writing e-mails. This function
4351
	 * opens the recipient history property (PR_EC_RECIPIENT_HISTORY_JSON) and updates or appends
4352
	 * it with the passed email addresses.
4353
	 *
4354
	 * @param array $recipients list of recipients
4355
	 */
4356
	public function addRecipientsToRecipientHistory($recipients) {
4357
		if (empty($recipients) || !is_array($recipients)) {
4358
			return;
4359
		}
4360
4361
		$emailAddresses = [];
4362
		foreach ($recipients as $recipient) {
4363
			if (isset($recipient['props']) && is_array($recipient['props'])) {
4364
				$emailAddresses[] = $recipient['props'];
4365
			}
4366
		}
4367
4368
		if (empty($emailAddresses)) {
4369
			return;
4370
		}
4371
4372
		// Retrieve the recipient history
4373
		$store = $GLOBALS["mapisession"]->getDefaultMessageStore();
4374
		$storeProps = mapi_getprops($store, [PR_EC_RECIPIENT_HISTORY_JSON]);
4375
		$recipient_history = [];
4376
4377
		if (isset($storeProps[PR_EC_RECIPIENT_HISTORY_JSON]) || propIsError(PR_EC_RECIPIENT_HISTORY_JSON, $storeProps) == MAPI_E_NOT_ENOUGH_MEMORY) {
4378
			$datastring = streamProperty($store, PR_EC_RECIPIENT_HISTORY_JSON);
4379
4380
			if (!empty($datastring)) {
4381
				$recipient_history = json_decode_data($datastring, true);
4382
			}
4383
		}
4384
4385
		if (!isset($recipient_history['recipients']) || !is_array($recipient_history['recipients'])) {
4386
			$recipient_history['recipients'] = [];
4387
		}
4388
4389
		$l_aNewHistoryItems = [];
4390
		foreach ($emailAddresses as $emailProps) {
4391
			$emailAddress = $this->resolveEmailAddressFromProps($emailProps);
4392
			if ($emailAddress === '') {
4393
				continue;
4394
			}
4395
4396
			$timestamp = time();
4397
			if ($this->updateRecipientHistoryEntry($recipient_history['recipients'], $emailProps, $emailAddress, $timestamp)) {
4398
				continue;
4399
			}
4400
4401
			if (!isset($l_aNewHistoryItems[$emailAddress])) {
4402
				$l_aNewHistoryItems[$emailAddress] = $this->buildRecipientHistoryEntry($emailProps, $timestamp);
4403
			}
4404
		}
4405
4406
		if (!empty($l_aNewHistoryItems)) {
4407
			foreach ($l_aNewHistoryItems as $l_aValue) {
4408
				$recipient_history['recipients'][] = $l_aValue;
4409
			}
4410
		}
4411
4412
		$l_sNewRecipientHistoryJSON = json_encode($recipient_history);
4413
4414
		$stream = mapi_openproperty($store, PR_EC_RECIPIENT_HISTORY_JSON, IID_IStream, 0, MAPI_CREATE | MAPI_MODIFY);
4415
		mapi_stream_setsize($stream, strlen($l_sNewRecipientHistoryJSON));
4416
		mapi_stream_write($stream, $l_sNewRecipientHistoryJSON);
4417
		mapi_stream_commit($stream);
4418
		mapi_savechanges($store);
4419
	}
4420
4421
	/**
4422
	 * Resolve the effective email address from a recipient property set.
4423
	 *
4424
	 * @param array $props raw properties extracted from the recipient row
4425
	 *
4426
	 * @return string trimmed email address or empty string when none available
4427
	 */
4428
	private function resolveEmailAddressFromProps(array $props) {
4429
		$addressType = $props['address_type'] ?? '';
4430
		if ($addressType === 'SMTP') {
4431
			$emailAddress = $props['smtp_address'] ?? '';
4432
			if ($emailAddress === '') {
4433
				$emailAddress = $props['email_address'] ?? '';
4434
			}
4435
		}
4436
		else {
4437
			$emailAddress = $props['email_address'] ?? '';
4438
			if ($emailAddress === '') {
4439
				$emailAddress = $props['smtp_address'] ?? '';
4440
			}
4441
		}
4442
4443
		return trim((string) $emailAddress);
4444
	}
4445
4446
	/**
4447
	 * Update an existing history entry when the address already exists.
4448
	 *
4449
	 * @param array  &$historyRecipients Reference to the recipient history array
4450
	 * @param array  $emailProps         current recipient properties
4451
	 * @param string $emailAddress       resolved email address
4452
	 * @param int    $timestamp          current timestamp used for counters
4453
	 *
4454
	 * @return bool TRUE when a matching history entry was updated, FALSE otherwise
4455
	 */
4456
	private function updateRecipientHistoryEntry(array &$historyRecipients, array $emailProps, $emailAddress, $timestamp) {
4457
		if (empty($historyRecipients)) {
4458
			return false;
4459
		}
4460
4461
		foreach ($historyRecipients as &$recipient) {
4462
			if (($emailProps['address_type'] ?? null) !== ($recipient['address_type'] ?? null)) {
4463
				continue;
4464
			}
4465
4466
			if (
4467
				$emailAddress !== ($recipient['email_address'] ?? '') &&
4468
				$emailAddress !== ($recipient['smtp_address'] ?? '')
4469
			) {
4470
				continue;
4471
			}
4472
4473
			$this->updateRecipientDisplayName($emailProps, $recipient);
4474
			$recipient['count'] = isset($recipient['count']) ? $recipient['count'] + 1 : 1;
4475
			$recipient['last_used'] = $timestamp;
4476
4477
			return true;
4478
		}
4479
		unset($recipient);
4480
4481
		return false;
4482
	}
4483
4484
	/**
4485
	 * Refresh the display name on a history entry when a better candidate is available.
4486
	 *
4487
	 * @param array $emailProps current recipient properties
4488
	 * @param array &$recipient Matched history entry to update
4489
	 */
4490
	private function updateRecipientDisplayName(array $emailProps, array &$recipient) {
4491
		$newDisplayName = trim((string) ($emailProps['display_name'] ?? ''));
4492
		if ($newDisplayName === '') {
4493
			return;
4494
		}
4495
4496
		$oldDisplayName = trim((string) ($recipient['display_name'] ?? ''));
4497
		$smtpAddress = $emailProps['smtp_address'] ?? '';
4498
4499
		if ($newDisplayName !== $smtpAddress || $oldDisplayName === '') {
4500
			$recipient['display_name'] = $newDisplayName;
4501
		}
4502
	}
4503
4504
	/**
4505
	 * Create a new history entry structure for a recipient address.
4506
	 *
4507
	 * @param array $emailProps recipient properties used for the entry
4508
	 * @param int   $timestamp  creation timestamp that seeds usage metrics
4509
	 *
4510
	 * @return array normalized recipient history entry payload
4511
	 */
4512
	private function buildRecipientHistoryEntry(array $emailProps, $timestamp) {
4513
		return [
4514
			'display_name' => $emailProps['display_name'] ?? '',
4515
			'smtp_address' => $emailProps['smtp_address'] ?? '',
4516
			'email_address' => $emailProps['email_address'] ?? '',
4517
			'address_type' => $emailProps['address_type'] ?? '',
4518
			'count' => 1,
4519
			'last_used' => $timestamp,
4520
			'object_type' => $emailProps['object_type'] ?? null,
4521
		];
4522
	}
4523
4524
	/**
4525
	 * Get the SMTP e-mail of an addressbook entry.
4526
	 *
4527
	 * @param string $entryid Addressbook entryid of object
4528
	 *
4529
	 * @return string SMTP e-mail address of that entry or FALSE on error
4530
	 */
4531
	public function getEmailAddressFromEntryID($entryid) {
4532
		try {
4533
			$mailuser = mapi_ab_openentry($GLOBALS["mapisession"]->getAddressbook(), $entryid);
4534
		}
4535
		catch (MAPIException $e) {
4536
			// if any invalid entryid is passed in this function then it should silently ignore it
4537
			// and continue with execution
4538
			if ($e->getCode() == MAPI_E_UNKNOWN_ENTRYID) {
4539
				$e->setHandled();
4540
4541
				return "";
4542
			}
4543
		}
4544
4545
		if (!isset($mailuser)) {
4546
			return "";
4547
		}
4548
4549
		$abprops = mapi_getprops($mailuser, [PR_SMTP_ADDRESS, PR_EMAIL_ADDRESS]);
4550
4551
		return $abprops[PR_SMTP_ADDRESS] ?? $abprops[PR_EMAIL_ADDRESS] ?? "";
4552
	}
4553
4554
	/**
4555
	 * Function which fetches all members of a distribution list recursively.
4556
	 *
4557
	 * @param resource $store        MAPI Message Store Object
4558
	 * @param resource $message      the distribution list message
4559
	 * @param array    $properties   array of properties to get properties of distlist
4560
	 * @param bool     $isRecursive  function will be called recursively if there is/are
4561
	 *                               distribution list inside the distlist to expand all the members,
4562
	 *                               pass true to expand distlist recursively, false to not expand
4563
	 * @param array    $listEntryIDs list of already expanded Distribution list from contacts folder,
4564
	 *                               This parameter is used for recursive call of the function
4565
	 *
4566
	 * @return object $items all members of a distlist
4567
	 */
4568
	public function getMembersFromDistributionList($store, $message, $properties, $isRecursive = false, $listEntryIDs = []) {
4569
		$items = [];
4570
4571
		$props = mapi_getprops($message, [$properties['oneoff_members'], $properties['members'], PR_ENTRYID]);
4572
4573
		// only continue when we have something to expand
4574
		if (!isset($props[$properties['oneoff_members']]) || !isset($props[$properties['members']])) {
4575
			return [];
0 ignored issues
show
Bug Best Practice introduced by
The expression return array() returns the type array which is incompatible with the documented return type object.
Loading history...
4576
		}
4577
4578
		if ($isRecursive) {
4579
			// when opening sub message we will not have entryid, so use entryid only when we have it
4580
			if (isset($props[PR_ENTRYID])) {
4581
				// for preventing recursion we need to store entryids, and check if the same distlist is going to be expanded again
4582
				if (in_array($props[PR_ENTRYID], $listEntryIDs)) {
4583
					// don't expand a distlist that is already expanded
4584
					return [];
0 ignored issues
show
Bug Best Practice introduced by
The expression return array() returns the type array which is incompatible with the documented return type object.
Loading history...
4585
				}
4586
4587
				$listEntryIDs[] = $props[PR_ENTRYID];
4588
			}
4589
		}
4590
4591
		$members = $props[$properties['members']];
4592
4593
		// parse oneoff members
4594
		$oneoffmembers = [];
4595
		foreach ($props[$properties['oneoff_members']] as $key => $item) {
4596
			$oneoffmembers[$key] = mapi_parseoneoff($item);
4597
		}
4598
4599
		foreach ($members as $key => $item) {
4600
			/*
4601
			 * PHP 5.5.0 and greater has made the unpack function incompatible with previous versions by changing:
4602
			 * - a = code now retains trailing NULL bytes.
4603
			 * - A = code now strips all trailing ASCII whitespace (spaces, tabs, newlines, carriage
4604
			 * returns, and NULL bytes).
4605
			 * for more http://php.net/manual/en/function.unpack.php
4606
			 */
4607
			if (version_compare(PHP_VERSION, '5.5.0', '>=')) {
4608
				$parts = unpack('Vnull/A16guid/Ctype/a*entryid', (string) $item);
4609
			}
4610
			else {
4611
				$parts = unpack('Vnull/A16guid/Ctype/A*entryid', (string) $item);
4612
			}
4613
4614
			$memberItem = [];
4615
			$memberItem['props'] = [];
4616
			$memberItem['props']['distlist_type'] = $parts['type'];
4617
4618
			if ($parts['guid'] === hex2bin('812b1fa4bea310199d6e00dd010f5402')) {
4619
				// custom e-mail address (no user or contact)
4620
				$oneoff = mapi_parseoneoff($item);
4621
4622
				$memberItem['props']['display_name'] = $oneoff['name'];
4623
				$memberItem['props']['address_type'] = $oneoff['type'];
4624
				$memberItem['props']['email_address'] = $oneoff['address'];
4625
				$memberItem['props']['smtp_address'] = $oneoff['address'];
4626
				$memberItem['props']['entryid'] = bin2hex((string) $members[$key]);
4627
4628
				$items[] = $memberItem;
4629
			}
4630
			else {
4631
				if ($parts['type'] === DL_DIST && $isRecursive) {
4632
					// Expand distribution list to get distlist members inside the distributionlist.
4633
					$distlist = mapi_msgstore_openentry($store, $parts['entryid']);
4634
					$items = array_merge($items, $this->getMembersFromDistributionList($store, $distlist, $properties, true, $listEntryIDs));
0 ignored issues
show
Bug introduced by
$this->getMembersFromDis...s, true, $listEntryIDs) of type object is incompatible with the type array expected by parameter $arrays of array_merge(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

4634
					$items = array_merge($items, /** @scrutinizer ignore-type */ $this->getMembersFromDistributionList($store, $distlist, $properties, true, $listEntryIDs));
Loading history...
4635
				}
4636
				else {
4637
					$memberItem['props']['entryid'] = bin2hex((string) $parts['entryid']);
4638
					$memberItem['props']['display_name'] = $oneoffmembers[$key]['name'];
4639
					$memberItem['props']['address_type'] = $oneoffmembers[$key]['type'];
4640
					// distribution lists don't have valid email address so ignore that property
4641
4642
					if ($parts['type'] !== DL_DIST) {
4643
						$memberItem['props']['email_address'] = $oneoffmembers[$key]['address'];
4644
4645
						// internal members in distribution list don't have smtp address so add add that property
4646
						$memberProps = $this->convertDistlistMemberToRecipient($store, $memberItem);
0 ignored issues
show
Bug introduced by
$store of type resource is incompatible with the type mapistore expected by parameter $store of Operations::convertDistlistMemberToRecipient(). ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-type  annotation

4646
						$memberProps = $this->convertDistlistMemberToRecipient(/** @scrutinizer ignore-type */ $store, $memberItem);
Loading history...
4647
						$memberItem['props']['smtp_address'] = $memberProps["smtp_address"] ?? $memberProps["email_address"];
4648
					}
4649
4650
					$items[] = $memberItem;
4651
				}
4652
			}
4653
		}
4654
4655
		return $items;
4656
	}
4657
4658
	/**
4659
	 * Convert inline image <img src="data:image/mimetype;.date> links in HTML email
4660
	 * to CID embedded images. Which are supported in major mail clients or
4661
	 * providers such as outlook.com or gmail.com.
4662
	 *
4663
	 * grommunio Web now extracts the base64 image, saves it as hidden attachment,
4664
	 * replace the img src tag with the 'cid' which corresponds with the attachments
4665
	 * cid.
4666
	 *
4667
	 * @param MAPIMessage $message the distribution list message
4668
	 */
4669
	public function convertInlineImage($message) {
4670
		$body = streamProperty($message, PR_HTML);
4671
		$imageIDs = [];
4672
4673
		// Only load the DOM if the HTML contains a img or data:text/plain due to a bug
4674
		// in Chrome on Windows in combination with TinyMCE.
4675
		if (str_contains($body, "img") || str_contains($body, "data:text/plain")) {
4676
			$doc = new DOMDocument();
4677
			$cpprops = mapi_message_getprops($message, [PR_INTERNET_CPID]);
4678
			$codepage = $cpprops[PR_INTERNET_CPID] ?? 1252;
4679
			$hackEncoding = '<meta http-equiv="Content-Type" content="text/html; charset=' . Conversion::getCodepageCharset($codepage) . '">';
4680
			// TinyMCE does not generate valid HTML, so we must suppress warnings.
4681
			@$doc->loadHTML($hackEncoding . $body);
0 ignored issues
show
Security Best Practice introduced by
It seems like you do not handle an error condition for loadHTML(). This can introduce security issues, and is generally not recommended. ( Ignorable by Annotation )

If this is a false-positive, you can also ignore this issue in your code via the ignore-unhandled  annotation

4681
			/** @scrutinizer ignore-unhandled */ @$doc->loadHTML($hackEncoding . $body);

If you suppress an error, we recommend checking for the error condition explicitly:

// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
Loading history...
4682
			$images = $doc->getElementsByTagName('img');
4683
			$saveChanges = false;
4684
4685
			foreach ($images as $image) {
4686
				$src = $image->getAttribute('src');
4687
4688
				if (!str_contains($src, "cid:") && (str_contains($src, "data:image") ||
4689
					str_contains($body, "data:text/plain"))) {
4690
					$saveChanges = true;
4691
4692
					// Extract mime type data:image/jpeg;
4693
					$firstOffset = strpos($src, '/') + 1;
4694
					$endOffset = strpos($src, ';');
4695
					$mimeType = substr($src, $firstOffset, $endOffset - $firstOffset);
4696
4697
					$dataPosition = strpos($src, ",");
4698
					// Extract encoded data
4699
					$rawImage = base64_decode(substr($src, $dataPosition + 1, strlen($src)));
4700
4701
					$uniqueId = uniqid();
4702
					$image->setAttribute('src', 'cid:' . $uniqueId);
4703
					// TinyMCE adds an extra inline image for some reason, remove it.
4704
					$image->setAttribute('data-mce-src', '');
4705
4706
					array_push($imageIDs, $uniqueId);
4707
4708
					// Create hidden attachment with CID
4709
					$inlineImage = mapi_message_createattach($message);
4710
					$props = [
4711
						PR_ATTACH_METHOD => ATTACH_BY_VALUE,
4712
						PR_ATTACH_CONTENT_ID => $uniqueId,
4713
						PR_ATTACHMENT_HIDDEN => true,
4714
						PR_ATTACH_FLAGS => 4,
4715
						PR_ATTACH_MIME_TAG => $mimeType !== 'plain' ? 'image/' . $mimeType : 'image/png',
4716
					];
4717
					mapi_setprops($inlineImage, $props);
4718
4719
					$stream = mapi_openproperty($inlineImage, PR_ATTACH_DATA_BIN, IID_IStream, 0, MAPI_CREATE | MAPI_MODIFY);
4720
					mapi_stream_setsize($stream, strlen($rawImage));
4721
					mapi_stream_write($stream, $rawImage);
4722
					mapi_stream_commit($stream);
4723
					mapi_savechanges($inlineImage);
4724
				}
4725
				elseif (str_contains($src, "cid:")) {
4726
					// Check for the cid(there may be http: ) is in the image src. push the cid
4727
					// to $imageIDs array. which further used in clearDeletedInlineAttachments function.
4728
4729
					$firstOffset = strpos($src, ":") + 1;
4730
					$cid = substr($src, $firstOffset);
4731
					array_push($imageIDs, $cid);
4732
				}
4733
			}
4734
4735
			if ($saveChanges) {
4736
				// Write the <img src="cid:data"> changes to the HTML property
4737
				$body = $doc->saveHTML();
4738
				$stream = mapi_openproperty($message, PR_HTML, IID_IStream, 0, MAPI_MODIFY);
4739
				mapi_stream_setsize($stream, strlen($body));
4740
				mapi_stream_write($stream, $body);
4741
				mapi_stream_commit($stream);
4742
				mapi_savechanges($message);
4743
			}
4744
		}
4745
		$this->clearDeletedInlineAttachments($message, $imageIDs);
4746
	}
4747
4748
	/**
4749
	 * Delete the deleted inline image attachment from attachment store.
4750
	 *
4751
	 * @param MAPIMessage $message  the distribution list message
4752
	 * @param array       $imageIDs Array of existing inline image PR_ATTACH_CONTENT_ID
4753
	 */
4754
	public function clearDeletedInlineAttachments($message, $imageIDs = []) {
4755
		$attachmentTable = mapi_message_getattachmenttable($message);
4756
4757
		$restriction = [RES_AND, [
4758
			[RES_PROPERTY,
4759
				[
4760
					RELOP => RELOP_EQ,
4761
					ULPROPTAG => PR_ATTACHMENT_HIDDEN,
4762
					VALUE => [PR_ATTACHMENT_HIDDEN => true],
4763
				],
4764
			],
4765
			[RES_EXIST,
4766
				[
4767
					ULPROPTAG => PR_ATTACH_CONTENT_ID,
4768
				],
4769
			],
4770
		]];
4771
4772
		$attachments = mapi_table_queryallrows($attachmentTable, [PR_ATTACH_CONTENT_ID, PR_ATTACH_NUM], $restriction);
4773
		foreach ($attachments as $attachment) {
4774
			$clearDeletedInlineAttach = array_search($attachment[PR_ATTACH_CONTENT_ID], $imageIDs) === false;
4775
			if ($clearDeletedInlineAttach) {
4776
				mapi_message_deleteattach($message, $attachment[PR_ATTACH_NUM]);
4777
			}
4778
		}
4779
	}
4780
4781
	/**
4782
	 * This function will fetch the user from mapi session and retrieve its LDAP image.
4783
	 * It will return the compressed image using php's GD library.
4784
	 *
4785
	 * @param string $userEntryId       The user entryid which is going to open
4786
	 * @param int    $compressedQuality The compression factor ranges from 0 (high) to 100 (low)
4787
	 *                                  Default value is set to 10 which is nearly
4788
	 *                                  extreme compressed image
4789
	 *
4790
	 * @return string A base64 encoded string (data url)
4791
	 */
4792
	public function getCompressedUserImage($userEntryId, $compressedQuality = 10) {
4793
		try {
4794
			$user = $GLOBALS['mapisession']->getUser($userEntryId);
4795
		}
4796
		catch (Exception $e) {
4797
			$msg = "Problem while getting a user from the addressbook. Error %s : %s.";
4798
			$formattedMsg = sprintf($msg, $e->getCode(), $e->getMessage());
4799
			error_log($formattedMsg);
4800
			Log::Write(LOGLEVEL_ERROR, "Operations:getCompressedUserImage() " . $formattedMsg);
4801
4802
			return "";
4803
		}
4804
4805
		$userImageProp = mapi_getprops($user, [PR_EMS_AB_THUMBNAIL_PHOTO]);
4806
		if (isset($userImageProp[PR_EMS_AB_THUMBNAIL_PHOTO])) {
4807
			return $this->compressedImage($userImageProp[PR_EMS_AB_THUMBNAIL_PHOTO], $compressedQuality);
4808
		}
4809
4810
		return "";
4811
	}
4812
4813
	/**
4814
	 * Function used to compressed the image.
4815
	 *
4816
	 * @param string $image the image which is going to compress
4817
	 * @param int compressedQuality The compression factor range from 0 (high) to 100 (low)
0 ignored issues
show
Bug introduced by
The type compressedQuality was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
4818
	 * Default value is set to 10 which is nearly extreme compressed image
4819
	 * @param mixed $compressedQuality
4820
	 *
4821
	 * @return string A base64 encoded string (data url)
4822
	 */
4823
	public function compressedImage($image, $compressedQuality = 10) {
4824
		// Proceed only when GD library's functions and user image data are available.
4825
		if (function_exists('imagecreatefromstring')) {
4826
			try {
4827
				$image = imagecreatefromstring($image);
4828
			}
4829
			catch (Exception $e) {
4830
				$msg = "Problem while creating image from string. Error %s : %s.";
4831
				$formattedMsg = sprintf($msg, $e->getCode(), $e->getMessage());
4832
				error_log($formattedMsg);
4833
				Log::Write(LOGLEVEL_ERROR, "Operations:compressedImage() " . $formattedMsg);
4834
			}
4835
4836
			if ($image !== false) {
4837
				// We need to use buffer because imagejpeg will give output as image in browser or file.
4838
				ob_start();
4839
				imagejpeg($image, null, $compressedQuality);
4840
				$compressedImg = ob_get_contents();
4841
				ob_end_clean();
4842
4843
				// Free up memory space acquired by image.
4844
				imagedestroy($image);
4845
4846
				return strlen($compressedImg) > 0 ? "data:image/jpg;base64," . base64_encode($compressedImg) : "";
4847
			}
4848
		}
4849
4850
		return "";
4851
	}
4852
4853
	public function getPropertiesFromStoreRoot($store, $props) {
4854
		$root = mapi_msgstore_openentry($store);
4855
4856
		return mapi_getprops($root, $props);
4857
	}
4858
4859
	/**
4860
	 * Returns the encryption key for sodium functions.
4861
	 *
4862
	 * It will generate a new one if the user doesn't have an encryption key yet.
4863
	 * It will also save the key into EncryptionStore for this session if the key
4864
	 * wasn't there yet.
4865
	 *
4866
	 * @return string
4867
	 */
4868
	public function getFilesEncryptionKey() {
4869
		// fallback if FILES_ACCOUNTSTORE_V1_SECRET_KEY is defined globally
4870
		$key = defined('FILES_ACCOUNTSTORE_V1_SECRET_KEY') ? hex2bin((string) constant('FILES_ACCOUNTSTORE_V1_SECRET_KEY')) : null;
4871
		if ($key === null) {
4872
			$encryptionStore = EncryptionStore::getInstance();
4873
			$key = $encryptionStore->get('filesenckey');
4874
			if ($key === null) {
4875
				$store = $GLOBALS["mapisession"]->getDefaultMessageStore();
4876
				$props = mapi_getprops($store, [PR_EC_WA_FILES_ENCRYPTION_KEY]);
4877
				if (isset($props[PR_EC_WA_FILES_ENCRYPTION_KEY])) {
4878
					$key = $props[PR_EC_WA_FILES_ENCRYPTION_KEY];
4879
				}
4880
				else {
4881
					$key = sodium_crypto_secretbox_keygen();
4882
					$encryptionStore->add('filesenckey', $key);
4883
					mapi_setprops($store, [PR_EC_WA_FILES_ENCRYPTION_KEY => $key]);
4884
					mapi_savechanges($store);
4885
				}
4886
			}
4887
		}
4888
4889
		return $key;
4890
	}
4891
}
4892