|
1
|
|
|
<?php |
|
2
|
|
|
/** |
|
3
|
|
|
* EGroupware: CalDAV/CardDAV/GroupDAV access |
|
4
|
|
|
* |
|
5
|
|
|
* @link http://www.egroupware.org |
|
6
|
|
|
* @license http://opensource.org/licenses/gpl-license.php GPL - GNU General Public License |
|
7
|
|
|
* @package api |
|
8
|
|
|
* @subpackage caldav |
|
9
|
|
|
* @author Ralf Becker <RalfBecker-AT-outdoor-training.de> |
|
10
|
|
|
* @copyright (c) 2007-16 by Ralf Becker <RalfBecker-AT-outdoor-training.de> |
|
11
|
|
|
* @version $Id$ |
|
12
|
|
|
*/ |
|
13
|
|
|
|
|
14
|
|
|
namespace EGroupware\Api; |
|
15
|
|
|
|
|
16
|
|
|
use EGroupware\Api\CalDAV\Handler; |
|
17
|
|
|
use EGroupware\Api\CalDAV\Principals; |
|
18
|
|
|
|
|
19
|
|
|
// explicit import non-namespaced classes |
|
20
|
|
|
require_once(__DIR__.'/WebDAV/Server.php'); |
|
21
|
|
|
use HTTP_WebDAV_Server; |
|
22
|
|
|
use calendar_hooks; |
|
23
|
|
|
|
|
24
|
|
|
/** |
|
25
|
|
|
* EGroupware: GroupDAV access |
|
26
|
|
|
* |
|
27
|
|
|
* Using a modified PEAR HTTP/WebDAV/Server class from API! |
|
28
|
|
|
* |
|
29
|
|
|
* One can use the following url's releative (!) to http://domain.com/egroupware/groupdav.php |
|
30
|
|
|
* |
|
31
|
|
|
* - / base of Cal|Card|GroupDAV tree, only certain clients (KDE, Apple) can autodetect folders from here |
|
32
|
|
|
* - /principals/ principal-collection-set for WebDAV ACL |
|
33
|
|
|
* - /principals/users/<username>/ |
|
34
|
|
|
* - /principals/groups/<groupname>/ |
|
35
|
|
|
* - /<username>/ users home-set with |
|
36
|
|
|
* - /<username>/addressbook/ addressbook of user or group <username> given the user has rights to view it |
|
37
|
|
|
* - /<current-username>/addressbook-<other-username>/ shared addressbooks from other user or group |
|
38
|
|
|
* - /<current-username>/addressbook-accounts/ all accounts current user has rights to see |
|
39
|
|
|
* - /<username>/calendar/ calendar of user <username> given the user has rights to view it |
|
40
|
|
|
* - /<username>/calendar/?download download whole calendar as .ics file (GET request!) |
|
41
|
|
|
* - /<current-username>/calendar-<other-username>/ shared calendar from other user or group (only current <username>!) |
|
42
|
|
|
* - /<username>/inbox/ scheduling inbox of user <username> |
|
43
|
|
|
* - /<username>/outbox/ scheduling outbox of user <username> |
|
44
|
|
|
* - /<username>/infolog/ InfoLog's of user <username> given the user has rights to view it |
|
45
|
|
|
* - /addressbook/ all addressbooks current user has rights to, announced as directory-gateway now |
|
46
|
|
|
* - /addressbook-accounts/ all accounts current user has rights to see |
|
47
|
|
|
* - /calendar/ calendar of current user |
|
48
|
|
|
* - /infolog/ infologs of current user |
|
49
|
|
|
* - /(resources|locations)/<resource-name>/calendar calendar of a resource/location, if user has rights to view |
|
50
|
|
|
* - /<current-username>/(resource|location)-<resource-name> shared calendar from a resource/location |
|
51
|
|
|
* |
|
52
|
|
|
* Shared addressbooks or calendars are only shown in in users home-set, if he subscribed to it via his CalDAV preferences! |
|
53
|
|
|
* |
|
54
|
|
|
* Calling one of the above collections with a GET request / regular browser generates an automatic index |
|
55
|
|
|
* from the data of a allprop PROPFIND, allow to browse CalDAV/CardDAV/GroupDAV tree with a regular browser. |
|
56
|
|
|
* |
|
57
|
|
|
* Permanent error_log() calls should use groupdav->log($str) instead, to be send to PHP error_log() |
|
58
|
|
|
* and our request-log (prefixed with "### " after request and response, like exceptions). |
|
59
|
|
|
* |
|
60
|
|
|
* @link http://www.groupdav.org/ GroupDAV spec |
|
61
|
|
|
* @link http://caldav.calconnect.org/ CalDAV resources |
|
62
|
|
|
* @link http://carddav.calconnect.org/ CardDAV resources |
|
63
|
|
|
* @link http://calendarserver.org/ Apple calendar and contacts server |
|
64
|
|
|
*/ |
|
65
|
|
|
class CalDAV extends HTTP_WebDAV_Server |
|
66
|
|
|
{ |
|
67
|
|
|
/** |
|
68
|
|
|
* DAV namespace |
|
69
|
|
|
*/ |
|
70
|
|
|
const DAV = 'DAV:'; |
|
71
|
|
|
/** |
|
72
|
|
|
* GroupDAV namespace |
|
73
|
|
|
*/ |
|
74
|
|
|
const GROUPDAV = 'http://groupdav.org/'; |
|
75
|
|
|
/** |
|
76
|
|
|
* CalDAV namespace |
|
77
|
|
|
*/ |
|
78
|
|
|
const CALDAV = 'urn:ietf:params:xml:ns:caldav'; |
|
79
|
|
|
/** |
|
80
|
|
|
* CardDAV namespace |
|
81
|
|
|
*/ |
|
82
|
|
|
const CARDDAV = 'urn:ietf:params:xml:ns:carddav'; |
|
83
|
|
|
/** |
|
84
|
|
|
* Apple Calendarserver namespace (eg. for ctag) |
|
85
|
|
|
*/ |
|
86
|
|
|
const CALENDARSERVER = 'http://calendarserver.org/ns/'; |
|
87
|
|
|
/** |
|
88
|
|
|
* Apple Addressbookserver namespace (eg. for ctag) |
|
89
|
|
|
*/ |
|
90
|
|
|
const ADDRESSBOOKSERVER = 'http://addressbookserver.org/ns/'; |
|
91
|
|
|
/** |
|
92
|
|
|
* Apple iCal namespace (eg. for calendar color) |
|
93
|
|
|
*/ |
|
94
|
|
|
const ICAL = 'http://apple.com/ns/ical/'; |
|
95
|
|
|
/** |
|
96
|
|
|
* Realm and powered by string |
|
97
|
|
|
*/ |
|
98
|
|
|
const REALM = 'EGroupware CalDAV/CardDAV/GroupDAV server'; |
|
99
|
|
|
|
|
100
|
|
|
var $dav_powered_by = self::REALM; |
|
101
|
|
|
var $http_auth_realm = self::REALM; |
|
102
|
|
|
|
|
103
|
|
|
/** |
|
104
|
|
|
* Folders in root or user home |
|
105
|
|
|
* |
|
106
|
|
|
* @var array |
|
107
|
|
|
*/ |
|
108
|
|
|
var $root = array( |
|
109
|
|
|
'addressbook' => array( |
|
110
|
|
|
'resourcetype' => array(self::GROUPDAV => 'vcard-collection', self::CARDDAV => 'addressbook'), |
|
111
|
|
|
'component-set' => array(self::GROUPDAV => 'VCARD'), |
|
112
|
|
|
), |
|
113
|
|
|
'calendar' => array( |
|
114
|
|
|
'resourcetype' => array(self::GROUPDAV => 'vevent-collection', self::CALDAV => 'calendar'), |
|
115
|
|
|
'component-set' => array(self::GROUPDAV => 'VEVENT'), |
|
116
|
|
|
), |
|
117
|
|
|
'inbox' => array( |
|
118
|
|
|
'resourcetype' => array(self::CALDAV => 'schedule-inbox'), |
|
119
|
|
|
'app' => 'calendar', |
|
120
|
|
|
'user-only' => true, // display just in user home |
|
121
|
|
|
), |
|
122
|
|
|
'outbox' => array( |
|
123
|
|
|
'resourcetype' => array(self::CALDAV => 'schedule-outbox'), |
|
124
|
|
|
'app' => 'calendar', |
|
125
|
|
|
'user-only' => true, // display just in user home |
|
126
|
|
|
), |
|
127
|
|
|
'infolog' => array( |
|
128
|
|
|
'resourcetype' => array(self::GROUPDAV => 'vtodo-collection', self::CALDAV => 'calendar'), |
|
129
|
|
|
'component-set' => array(self::GROUPDAV => 'VTODO'), |
|
130
|
|
|
), |
|
131
|
|
|
); |
|
132
|
|
|
/** |
|
133
|
|
|
* Debug level: 0 = nothing, 1 = function calls, 2 = more info, 3 = complete $_SERVER array |
|
134
|
|
|
* |
|
135
|
|
|
* Can now be enabled on a per user basis in GroupDAV prefs, if it is set here to 0! |
|
136
|
|
|
* |
|
137
|
|
|
* The debug messages are send to the apache error_log |
|
138
|
|
|
* |
|
139
|
|
|
* @var integer |
|
140
|
|
|
*/ |
|
141
|
|
|
var $debug = 0; |
|
142
|
|
|
|
|
143
|
|
|
/** |
|
144
|
|
|
* eGW's charset |
|
145
|
|
|
* |
|
146
|
|
|
* @var string |
|
147
|
|
|
*/ |
|
148
|
|
|
var $egw_charset; |
|
149
|
|
|
/** |
|
150
|
|
|
* Instance of our application specific handler |
|
151
|
|
|
* |
|
152
|
|
|
* @var Handler |
|
153
|
|
|
*/ |
|
154
|
|
|
var $handler; |
|
155
|
|
|
/** |
|
156
|
|
|
* current-user-principal URL |
|
157
|
|
|
* |
|
158
|
|
|
* @var string |
|
159
|
|
|
*/ |
|
160
|
|
|
var $current_user_principal; |
|
161
|
|
|
/** |
|
162
|
|
|
* Reference to the accounts class |
|
163
|
|
|
* |
|
164
|
|
|
* @var accounts |
|
165
|
|
|
*/ |
|
166
|
|
|
var $accounts; |
|
167
|
|
|
/** |
|
168
|
|
|
* Supported privileges with name and description |
|
169
|
|
|
* |
|
170
|
|
|
* privileges are hierarchical |
|
171
|
|
|
* |
|
172
|
|
|
* @var array |
|
173
|
|
|
*/ |
|
174
|
|
|
var $supported_privileges = array( |
|
175
|
|
|
'all' => array( |
|
176
|
|
|
'*description*' => 'all privileges', |
|
177
|
|
|
'read' => array( |
|
178
|
|
|
'*description*' => 'read resource', |
|
179
|
|
|
'read-free-busy' => array( |
|
180
|
|
|
'*ns*' => self::CALDAV, |
|
181
|
|
|
'*description*' => 'allow free busy report query', |
|
182
|
|
|
'*only*' => '/calendar/', |
|
183
|
|
|
), |
|
184
|
|
|
), |
|
185
|
|
|
'write' => array( |
|
186
|
|
|
'*description*' => 'write resource', |
|
187
|
|
|
'write-properties' => 'write resource properties', |
|
188
|
|
|
'write-content' => 'write resource content', |
|
189
|
|
|
'bind' => 'add child resource', |
|
190
|
|
|
'unbind' => 'remove child resource', |
|
191
|
|
|
), |
|
192
|
|
|
'unlock' => 'unlock resource without ownership of lock', |
|
193
|
|
|
'read-acl' => 'read resource access control list', |
|
194
|
|
|
'write-acl' => 'write resource access control list', |
|
195
|
|
|
'read-current-user-privilege-set' => 'read privileges for current principal', |
|
196
|
|
|
'schedule-deliver' => array( |
|
197
|
|
|
'*ns*' => self::CALDAV, |
|
198
|
|
|
'*description*' => 'schedule privileges for current principal', |
|
199
|
|
|
'*only*' => '/inbox/', |
|
200
|
|
|
), |
|
201
|
|
|
'schedule-send' => array( |
|
202
|
|
|
'*ns*' => self::CALDAV, |
|
203
|
|
|
'*description*' => 'schedule privileges for current principal', |
|
204
|
|
|
'*only*' => '/outbox/', |
|
205
|
|
|
), |
|
206
|
|
|
), |
|
207
|
|
|
); |
|
208
|
|
|
/** |
|
209
|
|
|
* $options parameter to PROPFIND request, eg. to check what props are requested |
|
210
|
|
|
* |
|
211
|
|
|
* @var array |
|
212
|
|
|
*/ |
|
213
|
|
|
var $propfind_options; |
|
214
|
|
|
|
|
215
|
|
|
/** |
|
216
|
|
|
* Reference to active instance, used by exception handler |
|
217
|
|
|
* |
|
218
|
|
|
* @var groupdav |
|
|
|
|
|
|
219
|
|
|
*/ |
|
220
|
|
|
protected static $instance; |
|
221
|
|
|
|
|
222
|
|
|
function __construct() |
|
223
|
|
|
{ |
|
224
|
|
|
// log which CalDAVTester test is currently running, set as User-Agent header |
|
225
|
|
|
if (substr($_SERVER['HTTP_USER_AGENT'], 0, 14) == 'scripts/tests/') error_log('****** '.$_SERVER['HTTP_USER_AGENT']); |
|
226
|
|
|
|
|
227
|
|
|
if (!$this->debug) $this->debug = (int)$GLOBALS['egw_info']['user']['preferences']['groupdav']['debug_level']; |
|
228
|
|
|
|
|
229
|
|
|
if ($this->debug > 2) error_log('groupdav: $_SERVER='.array2string($_SERVER)); |
|
230
|
|
|
|
|
231
|
|
|
// setting our own exception handler, to be able to still log the requests |
|
232
|
|
|
set_exception_handler(array(__CLASS__,'exception_handler')); |
|
233
|
|
|
|
|
234
|
|
|
// crrnd: client refuses redundand namespace declarations |
|
235
|
|
|
// setting redundand namespaces as the default for (Cal|Card|Group)DAV, as the majority of the clients either require or can live with it |
|
236
|
|
|
$this->crrnd = false; |
|
237
|
|
|
|
|
238
|
|
|
// identify clients, which do NOT support path AND full url in <D:href> of PROPFIND request |
|
239
|
|
|
switch(($agent = Handler::get_agent())) |
|
240
|
|
|
{ |
|
241
|
|
|
case 'kde': // KAddressbook (at least in 3.5 can NOT subscribe / does NOT find addressbook) |
|
242
|
|
|
$this->client_require_href_as_url = true; |
|
243
|
|
|
break; |
|
244
|
|
|
case 'cfnetwork': // Apple addressbook app |
|
245
|
|
|
case 'dataaccess': // iPhone addressbook |
|
246
|
|
|
$this->client_require_href_as_url = false; |
|
247
|
|
|
break; |
|
248
|
|
|
case 'davkit': // iCal app in OS X 10.6 created wrong request, if full url given |
|
249
|
|
|
case 'coredav': // iCal app in OS X 10.7 |
|
250
|
|
|
case 'calendarstore': // Apple iCal 5.0.1 under OS X 10.7.2 |
|
251
|
|
|
$this->client_require_href_as_url = false; |
|
252
|
|
|
break; |
|
253
|
|
|
case 'cfnetwork_old': |
|
254
|
|
|
$this->crrnd = true; // Older Apple Addressbook.app does not cope with namespace redundancy |
|
255
|
|
|
break; |
|
256
|
|
|
} |
|
257
|
|
|
if ($this->debug) error_log(__METHOD__."() HTTP_USER_AGENT='$_SERVER[HTTP_USER_AGENT]' --> '$agent' --> client_requires_href_as_url=$this->client_require_href_as_url, crrnd(client refuses redundand namespace declarations)=$this->crrnd"); |
|
258
|
|
|
|
|
259
|
|
|
// adding EGroupware version to X-Dav-Powered-By header eg. "EGroupware 1.8.001 CalDAV/CardDAV/GroupDAV server" |
|
260
|
|
|
$this->dav_powered_by = str_replace('EGroupware','EGroupware '.$GLOBALS['egw_info']['server']['versions']['phpgwapi'], |
|
261
|
|
|
$this->dav_powered_by); |
|
262
|
|
|
|
|
263
|
|
|
parent::__construct(); |
|
264
|
|
|
// hack to allow to use query parameters in WebDAV, which HTTP_WebDAV_Server interprets as part of the path |
|
265
|
|
|
list($this->_SERVER['REQUEST_URI']) = explode('?',$this->_SERVER['REQUEST_URI']); |
|
266
|
|
|
// OSX Addressbook sends ?add-member url-encoded |
|
267
|
|
|
if (substr($this->_SERVER['REQUEST_URI'], -14) == '/%3Fadd-member') |
|
268
|
|
|
{ |
|
269
|
|
|
$_GET['add-member'] = ''; |
|
270
|
|
|
$this->_SERVER['REQUEST_URI'] = substr($this->_SERVER['REQUEST_URI'], 0, -14); |
|
271
|
|
|
} |
|
272
|
|
|
//error_log($_SERVER['REQUEST_URI']." --> ".$this->_SERVER['REQUEST_URI']); |
|
273
|
|
|
|
|
274
|
|
|
$this->egw_charset = Translation::charset(); |
|
275
|
|
|
if (strpos($this->base_uri, 'http') === 0) |
|
276
|
|
|
{ |
|
277
|
|
|
$this->current_user_principal = $this->_slashify($this->base_uri); |
|
278
|
|
|
} |
|
279
|
|
|
else |
|
280
|
|
|
{ |
|
281
|
|
|
$this->current_user_principal = Framework::getUrl($_SERVER['SCRIPT_NAME']) . '/'; |
|
282
|
|
|
} |
|
283
|
|
|
$this->current_user_principal .= 'principals/users/'.$GLOBALS['egw_info']['user']['account_lid'].'/'; |
|
284
|
|
|
|
|
285
|
|
|
// if client requires pathes instead of URLs |
|
286
|
|
|
if (!$this->client_require_href_as_url) |
|
287
|
|
|
{ |
|
288
|
|
|
$this->current_user_principal = parse_url($this->current_user_principal,PHP_URL_PATH); |
|
289
|
|
|
} |
|
290
|
|
|
$this->accounts = $GLOBALS['egw']->accounts; |
|
291
|
|
|
|
|
292
|
|
|
self::$instance = $this; |
|
|
|
|
|
|
293
|
|
|
} |
|
294
|
|
|
|
|
295
|
|
|
/** |
|
296
|
|
|
* get the handler for $app |
|
297
|
|
|
* |
|
298
|
|
|
* @param string $app |
|
299
|
|
|
* @return Handler |
|
300
|
|
|
*/ |
|
301
|
|
|
function app_handler($app) |
|
302
|
|
|
{ |
|
303
|
|
|
if (isset($this->root[$app]['app'])) $app = $this->root[$app]['app']; |
|
304
|
|
|
|
|
305
|
|
|
return Handler::app_handler($app,$this); |
|
306
|
|
|
} |
|
307
|
|
|
|
|
308
|
|
|
/** |
|
309
|
|
|
* OPTIONS request, allow to modify the standard responses from the pear-class |
|
310
|
|
|
* |
|
311
|
|
|
* @param string $path |
|
312
|
|
|
* @param array &$dav |
|
313
|
|
|
* @param array &$allow |
|
314
|
|
|
*/ |
|
315
|
|
|
function OPTIONS($path, &$dav, &$allow) |
|
316
|
|
|
{ |
|
317
|
|
|
unset($allow); // not used, but required by function signature |
|
318
|
|
|
|
|
319
|
|
|
// locking support |
|
320
|
|
|
if (!in_array('2', $dav)) $dav[] = '2'; |
|
321
|
|
|
|
|
322
|
|
|
if (preg_match('#/(calendar(-[^/]+)?|inbox|outbox)/#', $path)) // eg. /<username>/calendar-<otheruser>/ |
|
323
|
|
|
{ |
|
324
|
|
|
$app = 'calendar'; |
|
325
|
|
|
} |
|
326
|
|
|
elseif (preg_match('#/addressbook(-[^/]+)?/#', $path)) // eg. /<username>/addressbook-<otheruser>/ |
|
327
|
|
|
{ |
|
328
|
|
|
$app = 'addressbook'; |
|
329
|
|
|
} |
|
330
|
|
|
// CalDAV and CardDAV |
|
331
|
|
|
$dav[] = 'access-control'; |
|
332
|
|
|
|
|
333
|
|
|
if ($app !== 'addressbook') // CalDAV |
|
334
|
|
|
{ |
|
335
|
|
|
$dav[] = 'calendar-access'; |
|
336
|
|
|
$dav[] = 'calendar-auto-schedule'; |
|
337
|
|
|
$dav[] = 'calendar-proxy'; |
|
338
|
|
|
// required by iOS iCal to use principal-property-search to autocomplete participants (and locations) |
|
339
|
|
|
$dav[] = 'calendarserver-principal-property-search'; |
|
340
|
|
|
// required by iOS & OS X iCal to show private checkbox (X-CALENDARSERVER-ACCESS: CONFIDENTIAL on VCALENDAR) |
|
341
|
|
|
$dav[] = 'calendarserver-private-events'; |
|
342
|
|
|
// managed attachments |
|
343
|
|
|
$dav[] = 'calendar-managed-attachments'; |
|
344
|
|
|
// other capabilities calendarserver announces |
|
345
|
|
|
//$dav[] = 'calendar-schedule'; |
|
346
|
|
|
//$dav[] = 'calendar-availability'; |
|
347
|
|
|
//$dav[] = 'inbox-availability'; |
|
348
|
|
|
//$dav[] = 'calendarserver-private-comments'; |
|
349
|
|
|
//$dav[] = 'calendarserver-sharing'; |
|
350
|
|
|
//$dav[] = 'calendarserver-sharing-no-scheduling'; |
|
351
|
|
|
} |
|
352
|
|
|
if ($app !== 'calendar') // CardDAV |
|
353
|
|
|
{ |
|
354
|
|
|
$dav[] = 'addressbook'; // CardDAV uses "addressbook" NOT "addressbook-access" |
|
355
|
|
|
} |
|
356
|
|
|
//error_log(__METHOD__."('$path') --> app='$app' --> DAV: ".implode(', ', $dav)); |
|
357
|
|
|
} |
|
358
|
|
|
|
|
359
|
|
|
/** |
|
360
|
|
|
* PROPFIND and REPORT method handler |
|
361
|
|
|
* |
|
362
|
|
|
* @param array general parameter passing array |
|
363
|
|
|
* @param array return array for file properties |
|
|
|
|
|
|
364
|
|
|
* @return bool true on success |
|
365
|
|
|
*/ |
|
366
|
|
|
function PROPFIND(&$options, &$files, $method='PROPFIND') |
|
367
|
|
|
{ |
|
368
|
|
|
if ($this->debug) error_log(__CLASS__."::$method(".array2string($options).')'); |
|
369
|
|
|
|
|
370
|
|
|
// make options (readonly) available to all class methods, eg. prop_requested |
|
371
|
|
|
$this->propfind_options = $options; |
|
372
|
|
|
|
|
373
|
|
|
// parse path in form [/account_lid]/app[/more] |
|
374
|
|
|
$id = $app = $user = $user_prefix = null; |
|
375
|
|
|
if (!self::_parse_path($options['path'],$id,$app,$user,$user_prefix) && $app && !$user && $user !== 0) |
|
|
|
|
|
|
376
|
|
|
{ |
|
377
|
|
|
if ($this->debug > 1) error_log(__CLASS__."::$method: user='$user', app='$app', id='$id': 404 not found!"); |
|
378
|
|
|
return '404 Not Found'; |
|
379
|
|
|
} |
|
380
|
|
|
if ($this->debug > 1) error_log(__CLASS__."::$method(path='$options[path]'): user='$user', user_prefix='$user_prefix', app='$app', id='$id'"); |
|
381
|
|
|
|
|
382
|
|
|
$files = array('files' => array()); |
|
383
|
|
|
$path = $user_prefix = $this->_slashify($user_prefix); |
|
|
|
|
|
|
384
|
|
|
|
|
385
|
|
|
if (!$app) // user root folder containing apps |
|
386
|
|
|
{ |
|
387
|
|
|
// add root with current users apps |
|
388
|
|
|
$this->add_home($files, $path, $user, $options['depth']); |
|
389
|
|
|
|
|
390
|
|
|
if ($path == '/') |
|
391
|
|
|
{ |
|
392
|
|
|
Hooks::process(array( |
|
393
|
|
|
'location' => 'groupdav_root_props', |
|
394
|
|
|
'props' => &$files['files'][0]['props'], |
|
395
|
|
|
'options' => $options, |
|
396
|
|
|
'caldav' => $this, |
|
397
|
|
|
)); |
|
398
|
|
|
} |
|
399
|
|
|
|
|
400
|
|
|
// add principals and user-homes |
|
401
|
|
|
if ($path == '/' && $options['depth']) |
|
402
|
|
|
{ |
|
403
|
|
|
// principals collection |
|
404
|
|
|
$files['files'][] = $this->add_collection('/principals/', array( |
|
405
|
|
|
'displayname' => lang('Accounts'), |
|
406
|
|
|
)); |
|
407
|
|
|
foreach($this->accounts->search(array('type' => 'both','order'=>'account_lid')) as $account) |
|
408
|
|
|
{ |
|
409
|
|
|
$this->add_home($files, $path.$account['account_lid'].'/', $account['account_id'], $options['depth'] == 'infinity' ? 'infinity' : $options['depth']-1); |
|
410
|
|
|
} |
|
411
|
|
|
} |
|
412
|
|
|
return true; |
|
413
|
|
|
} |
|
414
|
|
|
if ($path == '/' && ($app == 'resources' || $app == 'locations')) |
|
415
|
|
|
{ |
|
416
|
|
|
return $this->add_resources_collection($files, '/'.$app.'/', $options['depth']); |
|
417
|
|
|
} |
|
418
|
|
|
if ($app != 'principals' && !isset($GLOBALS['egw_info']['user']['apps'][$this->root[$app]['app'] ? $this->root[$app]['app'] : $app])) |
|
419
|
|
|
{ |
|
420
|
|
|
if ($this->debug) error_log(__CLASS__."::$method(path=$options[path]) 403 Forbidden: no app rights for '$app'"); |
|
421
|
|
|
return "403 Forbidden: no app rights for '$app'"; // no rights for the given app |
|
422
|
|
|
} |
|
423
|
|
|
if (($handler = self::app_handler($app))) |
|
|
|
|
|
|
424
|
|
|
{ |
|
425
|
|
|
if ($method != 'REPORT' && !$id) // no self URL for REPORT requests (only PROPFIND) or propfinds on an id |
|
426
|
|
|
{ |
|
427
|
|
|
// KAddressbook doubles the folder, if the self URL contains the GroupDAV/CalDAV resourcetypes |
|
428
|
|
|
$files['files'][0] = $this->add_app($app,$app=='addressbook'&&$handler->get_agent()=='kde',$user, |
|
429
|
|
|
$this->_slashify($options['path'])); |
|
430
|
|
|
|
|
431
|
|
|
// Hack for iOS 5.0.1 addressbook to stop asking directory gateway permissions with depth != 0 |
|
432
|
|
|
// values for depth are 0, 1, "infinit" or not set which has to be interpreted as "infinit" |
|
433
|
|
|
if ($method == 'PROPFIND' && $options['path'] == '/addressbook/' && |
|
434
|
|
|
(!isset($options['depth']) || $options['depth']) && $handler->get_agent() == 'dataaccess') |
|
435
|
|
|
{ |
|
436
|
|
|
$this->log(__CLASS__."::$method(".array2string($options).') Enabling hack for iOS 5.0.1 addressbook: force Depth: 0 on PROPFIND for directory gateway!'); |
|
437
|
|
|
return true; |
|
438
|
|
|
} |
|
439
|
|
|
if (!$options['depth']) return true; // depth 0 --> show only the self url |
|
440
|
|
|
} |
|
441
|
|
|
return $handler->propfind($this->_slashify($options['path']),$options,$files,$user,$id); |
|
|
|
|
|
|
442
|
|
|
} |
|
443
|
|
|
return '501 Not Implemented'; |
|
444
|
|
|
} |
|
445
|
|
|
|
|
446
|
|
|
/** |
|
447
|
|
|
* Add a collection to a PROPFIND request |
|
448
|
|
|
* |
|
449
|
|
|
* @param string $path |
|
450
|
|
|
* @param array $props =array() extra properties 'resourcetype' is added anyway, name => value pairs or name => HTTP_WebDAV_Server([namespace,]name,value) |
|
451
|
|
|
* @param array $privileges =array('read') values for current-user-privilege-set |
|
452
|
|
|
* @param array $supported_privileges =null default $this->supported_privileges |
|
453
|
|
|
* @return array with values for keys 'path' and 'props' |
|
454
|
|
|
*/ |
|
455
|
|
|
public function add_collection($path, array $props = array(), array $privileges=array('read','read-acl','read-current-user-privilege-set'), array $supported_privileges=null) |
|
456
|
|
|
{ |
|
457
|
|
|
// resourcetype: collection |
|
458
|
|
|
$props['resourcetype'][] = self::mkprop('collection',''); |
|
459
|
|
|
|
|
460
|
|
|
if (!isset($props['getcontenttype'])) $props['getcontenttype'] = 'httpd/unix-directory'; |
|
461
|
|
|
|
|
462
|
|
|
return $this->add_resource($path, $props, $privileges, $supported_privileges); |
|
463
|
|
|
} |
|
464
|
|
|
|
|
465
|
|
|
/** |
|
466
|
|
|
* Add a resource to a PROPFIND request |
|
467
|
|
|
* |
|
468
|
|
|
* @param string $path |
|
469
|
|
|
* @param array $props =array() extra properties 'resourcetype' is added anyway, name => value pairs or name => HTTP_WebDAV_Server([namespace,]name,value) |
|
470
|
|
|
* @param array $privileges =array('read') values for current-user-privilege-set |
|
471
|
|
|
* @param array $supported_privileges =null default $this->supported_privileges |
|
472
|
|
|
* @return array with values for keys 'path' and 'props' |
|
473
|
|
|
*/ |
|
474
|
|
|
public function add_resource($path, array $props = array(), array $privileges=array('read','read-current-user-privilege-set'), array $supported_privileges=null) |
|
475
|
|
|
{ |
|
476
|
|
|
// props for all collections: current-user-principal and principal-collection-set |
|
477
|
|
|
$props['current-user-principal'] = array( |
|
478
|
|
|
self::mkprop('href',$this->current_user_principal)); |
|
479
|
|
|
$props['principal-collection-set'] = array( |
|
480
|
|
|
self::mkprop('href',$this->base_uri.'/principals/')); |
|
481
|
|
|
|
|
482
|
|
|
// required props per WebDAV standard |
|
483
|
|
|
foreach(array( |
|
484
|
|
|
'displayname' => basename($path), |
|
485
|
|
|
'getetag' => 'none', |
|
486
|
|
|
'getcontentlength' => '', |
|
487
|
|
|
'getlastmodified' => '', |
|
488
|
|
|
'getcontenttype' => '', |
|
489
|
|
|
'resourcetype' => '', |
|
490
|
|
|
) as $name => $default) |
|
491
|
|
|
{ |
|
492
|
|
|
if (!isset($props[$name])) $props[$name] = $default; |
|
493
|
|
|
} |
|
494
|
|
|
|
|
495
|
|
|
// if requested add privileges |
|
496
|
|
|
if (is_null($supported_privileges)) $supported_privileges = $this->supported_privileges; |
|
497
|
|
|
if ($this->prop_requested('current-user-privilege-set') === true) |
|
498
|
|
|
{ |
|
499
|
|
|
foreach($privileges as $name) |
|
500
|
|
|
{ |
|
501
|
|
|
$props['current-user-privilege-set'][] = self::mkprop('privilege', array( |
|
502
|
|
|
is_array($name) ? self::mkprop($name['ns'], $name['name'], '') : self::mkprop($name, ''))); |
|
503
|
|
|
} |
|
504
|
|
|
} |
|
505
|
|
|
if ($this->prop_requested('supported-privilege-set') === true) |
|
506
|
|
|
{ |
|
507
|
|
|
foreach($supported_privileges as $name => $data) |
|
508
|
|
|
{ |
|
509
|
|
|
$props['supported-privilege-set'][] = $this->supported_privilege($name, $data, $path); |
|
510
|
|
|
} |
|
511
|
|
|
} |
|
512
|
|
|
if (!isset($props['owner']) && $this->prop_requested('owner') === true) |
|
513
|
|
|
{ |
|
514
|
|
|
$props['owner'] = ''; |
|
515
|
|
|
} |
|
516
|
|
|
|
|
517
|
|
|
if ($this->debug > 1) error_log(__METHOD__."(path='$path', props=".array2string($props).')'); |
|
518
|
|
|
|
|
519
|
|
|
// convert simple associative properties to HTTP_WebDAV_Server ones |
|
520
|
|
|
foreach($props as $name => &$prop) |
|
521
|
|
|
{ |
|
522
|
|
|
if (!is_array($prop) || !isset($prop['name'])) |
|
523
|
|
|
{ |
|
524
|
|
|
$prop = self::mkprop($name, $prop); |
|
525
|
|
|
} |
|
526
|
|
|
// add quotes around etag, if they are not already there |
|
527
|
|
|
if ($prop['name'] == 'getetag' && $prop['val'][0] != '"') |
|
528
|
|
|
{ |
|
529
|
|
|
$prop['val'] = '"'.$prop['val'].'"'; |
|
530
|
|
|
} |
|
531
|
|
|
} |
|
532
|
|
|
|
|
533
|
|
|
return array( |
|
534
|
|
|
'path' => $path, |
|
535
|
|
|
'props' => $props, |
|
536
|
|
|
); |
|
537
|
|
|
} |
|
538
|
|
|
|
|
539
|
|
|
/** |
|
540
|
|
|
* Generate (hierachical) supported-privilege property |
|
541
|
|
|
* |
|
542
|
|
|
* @param string $name name of privilege |
|
543
|
|
|
* @param string|array $data string with describtion or array with agregated privileges plus value for key '*description*', '*ns*', '*only*' |
|
544
|
|
|
* @param string $path =null path to match with $data['*only*'] |
|
545
|
|
|
* @return array of self::mkprop() arrays |
|
546
|
|
|
*/ |
|
547
|
|
|
protected function supported_privilege($name, $data, $path=null) |
|
548
|
|
|
{ |
|
549
|
|
|
$props = array(); |
|
550
|
|
|
$props[] = self::mkprop('privilege', array(is_array($data) && $data['*ns*'] ? |
|
551
|
|
|
self::mkprop($data['*ns*'], $name, '') : self::mkprop($name, ''))); |
|
552
|
|
|
$props[] = self::mkprop('description', is_array($data) ? $data['*description*'] : $data); |
|
553
|
|
|
if (is_array($data)) |
|
554
|
|
|
{ |
|
555
|
|
|
foreach($data as $name => $data) |
|
|
|
|
|
|
556
|
|
|
{ |
|
557
|
|
|
if ($name[0] == '*') continue; |
|
558
|
|
|
if (is_array($data) && $data['*only*'] && strpos($path, $data['*only*']) === false) |
|
559
|
|
|
{ |
|
560
|
|
|
continue; // wrong path |
|
561
|
|
|
} |
|
562
|
|
|
$props[] = $this->supported_privilege($name, $data, $path); |
|
563
|
|
|
} |
|
564
|
|
|
} |
|
565
|
|
|
return self::mkprop('supported-privilege', $props); |
|
566
|
|
|
} |
|
567
|
|
|
|
|
568
|
|
|
/** |
|
569
|
|
|
* Checks if a given property was requested in propfind request |
|
570
|
|
|
* |
|
571
|
|
|
* @param string $name property name |
|
572
|
|
|
* @param string $ns =null namespace, if that is to be checked too |
|
573
|
|
|
* @param boolean $return_prop =false if true return the property array with values for 'name', 'xmlns', 'attrs', 'children' |
|
574
|
|
|
* @return boolean|string|array true: $name explicitly requested (or autoindex), "all": allprop or "names": propname requested, false: $name was not requested |
|
575
|
|
|
*/ |
|
576
|
|
|
function prop_requested($name, $ns=null, $return_prop=false) |
|
577
|
|
|
{ |
|
578
|
|
|
if (!is_array($this->propfind_options) || !isset($this->propfind_options['props'])) |
|
|
|
|
|
|
579
|
|
|
{ |
|
580
|
|
|
$ret = true; // no props set, should happen only in autoindex, we return true to show all available props |
|
581
|
|
|
} |
|
582
|
|
|
elseif (!is_array($this->propfind_options['props'])) |
|
583
|
|
|
{ |
|
584
|
|
|
$ret = $this->propfind_options['props']; // "all": allprop or "names": propname |
|
585
|
|
|
} |
|
586
|
|
|
else |
|
587
|
|
|
{ |
|
588
|
|
|
$ret = false; |
|
589
|
|
|
foreach($this->propfind_options['props'] as $prop) |
|
590
|
|
|
{ |
|
591
|
|
|
if ($prop['name'] == $name && (is_null($ns) || $prop['xmlns'] == $ns)) |
|
592
|
|
|
{ |
|
593
|
|
|
$ret = $return_prop ? $prop : true; |
|
594
|
|
|
break; |
|
595
|
|
|
} |
|
596
|
|
|
} |
|
597
|
|
|
} |
|
598
|
|
|
//error_log(__METHOD__."('$name', '$ns', $return_prop) propfind_options=".array2string($this->propfind_options)); |
|
599
|
|
|
return $ret; |
|
600
|
|
|
} |
|
601
|
|
|
|
|
602
|
|
|
/** |
|
603
|
|
|
* Add user home with addressbook, calendar, infolog |
|
604
|
|
|
* |
|
605
|
|
|
* @param array $files |
|
606
|
|
|
* @param string $path / or /<username>/ |
|
607
|
|
|
* @param int $user |
|
608
|
|
|
* @param int $depth |
|
609
|
|
|
* @return string|boolean http status or true|false |
|
610
|
|
|
*/ |
|
611
|
|
|
protected function add_home(array &$files, $path, $user, $depth) |
|
612
|
|
|
{ |
|
613
|
|
|
if ($user) |
|
614
|
|
|
{ |
|
615
|
|
|
$account_lid = $this->accounts->id2name($user); |
|
616
|
|
|
} |
|
617
|
|
|
else |
|
618
|
|
|
{ |
|
619
|
|
|
$account_lid = $GLOBALS['egw_info']['user']['account_lid']; |
|
620
|
|
|
} |
|
621
|
|
|
$account = $this->accounts->read($account_lid); |
|
622
|
|
|
|
|
623
|
|
|
$calendar_user_address_set = array( |
|
624
|
|
|
self::mkprop('href','urn:uuid:'.$account['account_lid']), |
|
625
|
|
|
); |
|
626
|
|
|
if ($user < 0) |
|
627
|
|
|
{ |
|
628
|
|
|
$principalType = 'groups'; |
|
629
|
|
|
$displayname = lang('Group').' '.$account['account_lid']; |
|
630
|
|
|
} |
|
631
|
|
|
else |
|
632
|
|
|
{ |
|
633
|
|
|
$principalType = 'users'; |
|
634
|
|
|
$displayname = $account['account_fullname']; |
|
635
|
|
|
$calendar_user_address_set[] = self::mkprop('href','mailto:'.$account['account_email']); |
|
636
|
|
|
} |
|
637
|
|
|
$calendar_user_address_set[] = self::mkprop('href',$this->base_uri.'/principals/'.$principalType.'/'.$account['account_lid'].'/'); |
|
638
|
|
|
|
|
639
|
|
|
if ($depth && $path == '/') |
|
640
|
|
|
{ |
|
641
|
|
|
$displayname = 'EGroupware (Cal|Card|Group)DAV server'; |
|
642
|
|
|
} |
|
643
|
|
|
|
|
644
|
|
|
$displayname = Translation::convert($displayname, Translation::charset(),'utf-8'); |
|
645
|
|
|
// self url |
|
646
|
|
|
$props = array( |
|
647
|
|
|
'displayname' => $displayname, |
|
648
|
|
|
'owner' => $path == '/' ? '' : array(self::mkprop('href',$this->base_uri.'/principals/'.$principalType.'/'.$account_lid.'/')), |
|
649
|
|
|
); |
|
650
|
|
|
|
|
651
|
|
|
if ($path != '/') |
|
652
|
|
|
{ |
|
653
|
|
|
// add props modifyable via proppatch from client, eg. jqcalendar stores it's preferences there |
|
654
|
|
|
foreach((array)$GLOBALS['egw_info']['user']['preferences']['groupdav'] as $name => $value) |
|
655
|
|
|
{ |
|
656
|
|
|
list($prop,$prop4path,$ns) = explode(':', $name, 3); |
|
657
|
|
|
if ($prop4path == $path && (!in_array($ns,self::$ns_needs_explicit_named_props) || |
|
658
|
|
|
isset(self::$proppatch_props[$prop]) && self::$proppatch_props[$prop] === $ns)) |
|
659
|
|
|
{ |
|
660
|
|
|
$props[] = self::mkprop($ns, $prop, $value); |
|
661
|
|
|
//error_log(__METHOD__."() arbitrary $ns:$prop=".array2string($value)); |
|
662
|
|
|
} |
|
663
|
|
|
} |
|
664
|
|
|
} |
|
665
|
|
|
$files['files'][] = $this->add_collection($path, $props); |
|
666
|
|
|
|
|
667
|
|
|
if ($depth) |
|
668
|
|
|
{ |
|
669
|
|
|
foreach($this->root as $app => $data) |
|
670
|
|
|
{ |
|
671
|
|
|
if (!$GLOBALS['egw_info']['user']['apps'][$data['app'] ? $data['app'] : $app]) continue; // no rights for the given app |
|
672
|
|
|
if (!empty($data['user-only']) && ($path == '/' || $user < 0)) continue; |
|
673
|
|
|
|
|
674
|
|
|
$files['files'][] = $this->add_app($app,false,$user,$path.$app.'/'); |
|
675
|
|
|
|
|
676
|
|
|
// only add global /addressbook-accounts/ as the one in home-set is added (and controled) by add_shared |
|
677
|
|
|
if ($path == '/' && $app == 'addressbook' && |
|
678
|
|
|
$GLOBALS['egw_info']['user']['preferences']['addressbook']['hide_accounts'] !== '1') |
|
679
|
|
|
{ |
|
680
|
|
|
$file = $this->add_app($app,false,0,$path.$app.'-accounts/'); |
|
681
|
|
|
$file['props']['resourcetype']['val'][] = self::mkprop(self::CALENDARSERVER,'shared',''); |
|
682
|
|
|
$files['files'][] = $file; |
|
683
|
|
|
} |
|
684
|
|
|
// added shared calendars or addressbooks |
|
685
|
|
|
$this->add_shared($files['files'], $path, $app, $user); |
|
686
|
|
|
} |
|
687
|
|
|
if ($path == '/' && $GLOBALS['egw_info']['user']['apps']['resources']) |
|
688
|
|
|
{ |
|
689
|
|
|
$this->add_resources_collection($files, $path.'resources/'); |
|
690
|
|
|
$this->add_resources_collection($files, $path.'locations/'); |
|
691
|
|
|
} |
|
692
|
|
|
} |
|
693
|
|
|
return true; |
|
694
|
|
|
} |
|
695
|
|
|
|
|
696
|
|
|
/** |
|
697
|
|
|
* Add collection with available resources or locations calendar-home-sets |
|
698
|
|
|
* |
|
699
|
|
|
* @param array &$files |
|
700
|
|
|
* @param string $path / or /<username>/ |
|
701
|
|
|
* @param int $depth =0 |
|
702
|
|
|
* @return string|boolean http status or true|false |
|
703
|
|
|
*/ |
|
704
|
|
|
protected function add_resources_collection(array &$files, $path, $depth=0) |
|
705
|
|
|
{ |
|
706
|
|
|
if (!isset($GLOBALS['egw_info']['user']['apps']['resources'])) |
|
707
|
|
|
{ |
|
708
|
|
|
if ($this->debug) error_log(__METHOD__."(path=$path) 403 Forbidden: no app rights for 'resources'"); |
|
709
|
|
|
return "403 Forbidden: no app rights for 'resources'"; // no rights for the given app |
|
710
|
|
|
} |
|
711
|
|
|
list(,$what) = explode('/', $path); |
|
712
|
|
|
if (($is_location = ($what == 'locations'))) |
|
713
|
|
|
{ |
|
714
|
|
|
$files['files'][] = $this->add_collection('/locations/', array('displayname' => lang('Location calendars'))); |
|
715
|
|
|
} |
|
716
|
|
|
else |
|
717
|
|
|
{ |
|
718
|
|
|
$files['files'][] = $this->add_collection('/resources/', array('displayname' => lang('Resource calendars'))); |
|
719
|
|
|
} |
|
720
|
|
|
if ($depth) |
|
721
|
|
|
{ |
|
722
|
|
|
foreach(Principals::get_resources() as $resource) |
|
723
|
|
|
{ |
|
724
|
|
|
if ($is_location == Principals::resource_is_location($resource)) |
|
725
|
|
|
{ |
|
726
|
|
|
$files['files'][] = $this->add_app('calendar', false, 'r'.$resource['res_id'], |
|
727
|
|
|
'/'.Principals::resource2name($resource, $is_location).'/'); |
|
728
|
|
|
} |
|
729
|
|
|
} |
|
730
|
|
|
} |
|
731
|
|
|
return true; |
|
732
|
|
|
} |
|
733
|
|
|
|
|
734
|
|
|
/** |
|
735
|
|
|
* Add shared addressbook, calendar, infolog to user home |
|
736
|
|
|
* |
|
737
|
|
|
* @param array &$files |
|
738
|
|
|
* @param string $path /<username>/ |
|
739
|
|
|
* @param int $app |
|
740
|
|
|
* @param int $user |
|
741
|
|
|
* @return string|boolean http status or true|false |
|
742
|
|
|
*/ |
|
743
|
|
|
protected function add_shared(array &$files, $path, $app, $user) |
|
744
|
|
|
{ |
|
745
|
|
|
// currently only show shared calendars/addressbooks for current user and not in the root |
|
746
|
|
|
if ($path == '/' || $user != $GLOBALS['egw_info']['user']['account_id'] || |
|
747
|
|
|
!isset($GLOBALS['egw_info']['user']['apps'][$app])) // also avoids principals, inbox and outbox |
|
748
|
|
|
{ |
|
749
|
|
|
return true; |
|
750
|
|
|
} |
|
751
|
|
|
$handler = $this->app_handler($app); |
|
752
|
|
|
if (($shared = $handler->get_shared())) |
|
753
|
|
|
{ |
|
754
|
|
|
foreach($shared as $id => $owner) |
|
755
|
|
|
{ |
|
756
|
|
|
$file = $this->add_app($app,false,$id,$path.$owner.'/'); |
|
757
|
|
|
// mark other users calendar as shared (iOS 5.0.1 AB does NOT display AB marked as shared!) |
|
758
|
|
|
if ($app == 'calendar') $file['props']['resourcetype']['val'][] = self::mkprop(self::CALENDARSERVER,'shared',''); |
|
759
|
|
|
$files[] = $file; |
|
760
|
|
|
} |
|
761
|
|
|
} |
|
762
|
|
|
return true; |
|
763
|
|
|
} |
|
764
|
|
|
|
|
765
|
|
|
/** |
|
766
|
|
|
* Format an account-name for use in displayname |
|
767
|
|
|
* |
|
768
|
|
|
* @param int|array $account |
|
769
|
|
|
* @return string |
|
770
|
|
|
*/ |
|
771
|
|
|
public function account_name($account) |
|
772
|
|
|
{ |
|
773
|
|
|
if (is_array($account)) |
|
774
|
|
|
{ |
|
775
|
|
|
if ($account['account_id'] < 0) |
|
776
|
|
|
{ |
|
777
|
|
|
$name = lang('Group').' '.$account['account_lid']; |
|
778
|
|
|
} |
|
779
|
|
|
else |
|
780
|
|
|
{ |
|
781
|
|
|
$name = $account['account_fullname']; |
|
782
|
|
|
} |
|
783
|
|
|
} |
|
784
|
|
|
else |
|
785
|
|
|
{ |
|
786
|
|
|
if ($account < 0) |
|
787
|
|
|
{ |
|
788
|
|
|
$name = lang('Group').' '.$this->accounts->id2name($account,'account_lid'); |
|
789
|
|
|
} |
|
790
|
|
|
else |
|
791
|
|
|
{ |
|
792
|
|
|
$name = $this->accounts->id2name($account,'account_fullname'); |
|
793
|
|
|
} |
|
794
|
|
|
if (empty($name)) $name = '#'.$account; |
|
795
|
|
|
} |
|
796
|
|
|
return $name; |
|
797
|
|
|
} |
|
798
|
|
|
|
|
799
|
|
|
/** |
|
800
|
|
|
* Add an application collection to a user home or the root |
|
801
|
|
|
* |
|
802
|
|
|
* @param string $app |
|
803
|
|
|
* @param boolean $no_extra_types =false should the GroupDAV and CalDAV types be added (KAddressbook has problems with it in self URL) |
|
804
|
|
|
* @param int $user =null owner of the collection, default current user |
|
805
|
|
|
* @param string $path ='/' |
|
806
|
|
|
* @return array with values for keys 'path' and 'props' |
|
807
|
|
|
*/ |
|
808
|
|
|
protected function add_app($app,$no_extra_types=false,$user=null,$path='/') |
|
809
|
|
|
{ |
|
810
|
|
|
if ($this->debug) error_log(__METHOD__."(app='$app', no_extra_types=$no_extra_types, user='$user', path='$path')"); |
|
811
|
|
|
$user_preferences = $GLOBALS['egw_info']['user']['preferences']; |
|
|
|
|
|
|
812
|
|
|
if (is_string($user) && $user[0] == 'r' && ($resource = Principals::read_resource(substr($user, 1)))) |
|
|
|
|
|
|
813
|
|
|
{ |
|
814
|
|
|
$is_location = Principals::resource_is_location($resource); |
|
815
|
|
|
$displayname = null; |
|
816
|
|
|
list($principalType, $account_lid) = explode('/', Principals::resource2name($resource, $is_location, $displayname)); |
|
817
|
|
|
} |
|
818
|
|
|
elseif ($user) |
|
|
|
|
|
|
819
|
|
|
{ |
|
820
|
|
|
$account_lid = $this->accounts->id2name($user); |
|
821
|
|
|
if ($user >= 0 && $GLOBALS['egw']->preferences->account_id != $user) |
|
822
|
|
|
{ |
|
823
|
|
|
$GLOBALS['egw']->preferences->__construct($user); |
|
824
|
|
|
$user_preferences = $GLOBALS['egw']->preferences->read_repository(); |
|
825
|
|
|
$GLOBALS['egw']->preferences->__construct($GLOBALS['egw_info']['user']['account_lid']); |
|
826
|
|
|
} |
|
827
|
|
|
$principalType = $user < 0 ? 'groups' : 'users'; |
|
828
|
|
|
} |
|
829
|
|
|
else |
|
830
|
|
|
{ |
|
831
|
|
|
$account_lid = $GLOBALS['egw_info']['user']['account_lid']; |
|
832
|
|
|
$principalType = 'users'; |
|
833
|
|
|
} |
|
834
|
|
|
if (!isset($displayname)) $displayname = $this->account_name($user); |
|
835
|
|
|
|
|
836
|
|
|
$props = array( |
|
837
|
|
|
'owner' => array(self::mkprop('href',$this->base_uri.'/principals/'.$principalType.'/'.$account_lid.'/')), |
|
838
|
|
|
); |
|
839
|
|
|
|
|
840
|
|
|
switch ($app) |
|
841
|
|
|
{ |
|
842
|
|
|
case 'inbox': |
|
843
|
|
|
$props['displayname'] = lang('Scheduling inbox').' '.$displayname; |
|
844
|
|
|
break; |
|
845
|
|
|
case 'outbox': |
|
846
|
|
|
$props['displayname'] = lang('Scheduling outbox').' '.$displayname; |
|
847
|
|
|
break; |
|
848
|
|
|
case 'addressbook': |
|
849
|
|
|
if ($path == '/addressbook/') |
|
850
|
|
|
{ |
|
851
|
|
|
$props['displayname'] = lang('All addressbooks'); |
|
852
|
|
|
break; |
|
853
|
|
|
} |
|
854
|
|
|
elseif(!$user && $GLOBALS['egw_info']['user']['preferences']['addressbook']['hide_accounts'] !== '1') |
|
|
|
|
|
|
855
|
|
|
{ |
|
856
|
|
|
unset($props['owner']); |
|
857
|
|
|
$props['displayname'] = lang($app).' '.lang('Accounts'); |
|
858
|
|
|
break; |
|
859
|
|
|
} |
|
860
|
|
|
// fall through |
|
861
|
|
|
default: |
|
862
|
|
|
$props['displayname'] = Translation::convert(lang($app).' '.$displayname, $this->egw_charset, 'utf-8'); |
|
863
|
|
|
} |
|
864
|
|
|
|
|
865
|
|
|
// rfc 5995 (Use POST to add members to WebDAV collections): we use collection path with add-member query param |
|
866
|
|
|
// leaving it switched off, until further testing, because OS X iCal seem to ignore it and OS X Addressbook uses POST to full URL without ?add-member |
|
867
|
|
|
if ($app && !in_array($app,array('inbox','outbox','principals'))) // not on inbox, outbox or principals |
|
868
|
|
|
{ |
|
869
|
|
|
$props['add-member'][] = self::mkprop('href',$this->base_uri.$path.'?add-member'); |
|
870
|
|
|
} |
|
871
|
|
|
|
|
872
|
|
|
// add props modifyable via proppatch from client, eg. calendar-color, see self::$proppatch_props |
|
873
|
|
|
$ns = null; |
|
874
|
|
|
foreach((array)$GLOBALS['egw_info']['user']['preferences'][$app] as $name => $value) |
|
875
|
|
|
{ |
|
876
|
|
|
unset($ns); |
|
877
|
|
|
list($prop,$prop4user,$ns) = explode(':', $name, 3); |
|
878
|
|
|
if ($prop4user == (string)$user && isset(self::$proppatch_props[$prop]) && !isset($ns)) |
|
879
|
|
|
{ |
|
880
|
|
|
$props[$prop] = self::mkprop(self::$proppatch_props[$prop], $prop, $value); |
|
881
|
|
|
//error_log(__METHOD__."() explicit ".self::$proppatch_props[$prop].":$prop=".array2string($value)); |
|
882
|
|
|
} |
|
883
|
|
|
// props in arbitrary namespaces not mentioned in self::$ns_needs_explicit_named_props |
|
884
|
|
|
elseif(isset($ns) && !in_array($ns,self::$ns_needs_explicit_named_props)) |
|
885
|
|
|
{ |
|
886
|
|
|
$props[] = self::mkprop($ns, $prop, $value); |
|
887
|
|
|
//error_log(__METHOD__."() arbitrary $ns:$prop=".array2string($value)); |
|
888
|
|
|
} |
|
889
|
|
|
} |
|
890
|
|
|
|
|
891
|
|
|
foreach((array)$this->root[$app] as $prop => $values) |
|
892
|
|
|
{ |
|
893
|
|
|
switch($prop) |
|
894
|
|
|
{ |
|
895
|
|
|
case 'resourcetype'; |
|
896
|
|
|
if (!$no_extra_types) |
|
897
|
|
|
{ |
|
898
|
|
|
foreach($this->root[$app]['resourcetype'] as $ns => $type) |
|
899
|
|
|
{ |
|
900
|
|
|
$props['resourcetype'][] = self::mkprop($ns,$type,''); |
|
901
|
|
|
} |
|
902
|
|
|
// add /addressbook/ as directory gateway |
|
903
|
|
|
if ($path == '/addressbook/') |
|
904
|
|
|
{ |
|
905
|
|
|
$props['resourcetype'][] = self::mkprop(self::CARDDAV, 'directory', ''); |
|
906
|
|
|
} |
|
907
|
|
|
} |
|
908
|
|
|
break; |
|
909
|
|
|
case 'app': |
|
910
|
|
|
case 'user-only': |
|
911
|
|
|
break; // no props, already handled |
|
912
|
|
|
default: |
|
913
|
|
|
if (is_array($values)) |
|
914
|
|
|
{ |
|
915
|
|
|
foreach($values as $ns => $value) |
|
916
|
|
|
{ |
|
917
|
|
|
$props[$prop] = self::mkprop($ns,$prop,$value); |
|
918
|
|
|
} |
|
919
|
|
|
} |
|
920
|
|
|
else |
|
921
|
|
|
{ |
|
922
|
|
|
$props[$prop] = $values; |
|
923
|
|
|
} |
|
924
|
|
|
break; |
|
925
|
|
|
} |
|
926
|
|
|
} |
|
927
|
|
|
// add other handler specific properties |
|
928
|
|
|
if (($handler = self::app_handler($app))) |
|
|
|
|
|
|
929
|
|
|
{ |
|
930
|
|
|
if (method_exists($handler,'extra_properties')) |
|
931
|
|
|
{ |
|
932
|
|
|
$props = $handler->extra_properties($props, $displayname, $this->base_uri, $user, $path); |
|
|
|
|
|
|
933
|
|
|
} |
|
934
|
|
|
// add ctag if handler implements it |
|
935
|
|
|
if (method_exists($handler,'getctag') && $this->prop_requested('getctag') === true) |
|
936
|
|
|
{ |
|
937
|
|
|
$props['getctag'] = self::mkprop( |
|
938
|
|
|
self::CALENDARSERVER,'getctag',$handler->getctag($path,$user)); |
|
939
|
|
|
} |
|
940
|
|
|
// add sync-token url if handler supports sync-collection report |
|
941
|
|
|
if (isset($props['supported-report-set']['sync-collection']) && $this->prop_requested('sync-token') === true) |
|
942
|
|
|
{ |
|
943
|
|
|
$props['sync-token'] = $handler->get_sync_token($path,$user); |
|
944
|
|
|
} |
|
945
|
|
|
} |
|
946
|
|
|
if ($handler && !is_null($user)) |
|
947
|
|
|
{ |
|
948
|
|
|
return $this->add_collection($path, $props, $handler->current_user_privileges($path, $user)); |
|
949
|
|
|
} |
|
950
|
|
|
return $this->add_collection($path, $props); |
|
951
|
|
|
} |
|
952
|
|
|
|
|
953
|
|
|
/** |
|
954
|
|
|
* CalDAV/CardDAV REPORT method handler |
|
955
|
|
|
* |
|
956
|
|
|
* just calls PROPFIND() |
|
957
|
|
|
* |
|
958
|
|
|
* @param array general parameter passing array |
|
959
|
|
|
* @param array return array for file properties |
|
960
|
|
|
* @return bool true on success |
|
961
|
|
|
*/ |
|
962
|
|
|
function REPORT(&$options, &$files) |
|
963
|
|
|
{ |
|
964
|
|
|
if ($this->debug > 1) error_log(__METHOD__.'('.array2string($options).')'); |
|
965
|
|
|
|
|
966
|
|
|
return $this->PROPFIND($options,$files,'REPORT'); |
|
967
|
|
|
} |
|
968
|
|
|
|
|
969
|
|
|
/** |
|
970
|
|
|
* CalDAV/CardDAV REPORT method handler to get HTTP_WebDAV_Server to process REPORT requests |
|
971
|
|
|
* |
|
972
|
|
|
* Just calls http_PROPFIND() |
|
973
|
|
|
*/ |
|
974
|
|
|
function http_REPORT() |
|
975
|
|
|
{ |
|
976
|
|
|
parent::http_PROPFIND('REPORT'); |
|
977
|
|
|
} |
|
978
|
|
|
|
|
979
|
|
|
/** |
|
980
|
|
|
* GET method handler |
|
981
|
|
|
* |
|
982
|
|
|
* @param array $options parameter passing array |
|
983
|
|
|
* @return bool true on success |
|
984
|
|
|
*/ |
|
985
|
|
|
function GET(&$options) |
|
986
|
|
|
{ |
|
987
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).')'); |
|
988
|
|
|
|
|
989
|
|
|
$id = $app = $user = null; |
|
990
|
|
|
if (!$this->_parse_path($options['path'],$id,$app,$user) || $app == 'principals') |
|
991
|
|
|
{ |
|
992
|
|
|
return $this->autoindex($options); |
|
993
|
|
|
} |
|
994
|
|
|
if (($handler = self::app_handler($app))) |
|
|
|
|
|
|
995
|
|
|
{ |
|
996
|
|
|
return $handler->get($options,$id,$user); |
|
997
|
|
|
} |
|
998
|
|
|
error_log(__METHOD__."(".array2string($options).") 501 Not Implemented"); |
|
999
|
|
|
return '501 Not Implemented'; |
|
1000
|
|
|
} |
|
1001
|
|
|
|
|
1002
|
|
|
/** |
|
1003
|
|
|
* Display an automatic index (listing and properties) for a collection |
|
1004
|
|
|
* |
|
1005
|
|
|
* @param array $options parameter passing array, index "path" contains requested path |
|
1006
|
|
|
*/ |
|
1007
|
|
|
protected function autoindex($options) |
|
1008
|
|
|
{ |
|
1009
|
|
|
$propfind_options = array( |
|
1010
|
|
|
'path' => $options['path'], |
|
1011
|
|
|
'depth' => 1, |
|
1012
|
|
|
); |
|
1013
|
|
|
$files = array(); |
|
1014
|
|
|
if (($ret = $this->PROPFIND($propfind_options,$files)) !== true) |
|
1015
|
|
|
{ |
|
1016
|
|
|
return $ret; // no collection |
|
1017
|
|
|
} |
|
1018
|
|
|
header('Content-type: text/html; charset='.Translation::charset()); |
|
1019
|
|
|
echo "<html>\n<head>\n\t<title>".'EGroupware (Cal|Card|Group)DAV server '.htmlspecialchars($options['path'])."</title>\n"; |
|
1020
|
|
|
echo "\t<meta http-equiv='content-type' content='text/html; charset=utf-8' />\n"; |
|
1021
|
|
|
echo "\t<style type='text/css'>\n.th { background-color: #e0e0e0; }\n.row_on { background-color: #F1F1F1; vertical-align: top; }\n". |
|
1022
|
|
|
".row_off { background-color: #ffffff; vertical-align: top; }\ntd { padding-left: 5px; }\nth { padding-left: 5px; text-align: left; }\n\t</style>\n"; |
|
1023
|
|
|
echo "</head>\n<body>\n"; |
|
1024
|
|
|
|
|
1025
|
|
|
echo '<h1>(Cal|Card|Group)DAV '; |
|
1026
|
|
|
$path = '/groupdav.php'; |
|
1027
|
|
|
foreach(explode('/',$this->_unslashify($options['path'])) as $n => $name) |
|
1028
|
|
|
{ |
|
1029
|
|
|
$path .= ($n != 1 ? '/' : '').$name; |
|
1030
|
|
|
echo Html::a_href(htmlspecialchars($name.'/'),$path); |
|
1031
|
|
|
} |
|
1032
|
|
|
echo "</h1>\n"; |
|
1033
|
|
|
|
|
1034
|
|
|
static $props2show = array( |
|
1035
|
|
|
'DAV:displayname' => 'Displayname', |
|
1036
|
|
|
'DAV:getlastmodified' => 'Last modified', |
|
1037
|
|
|
'DAV:getetag' => 'ETag', |
|
1038
|
|
|
//'CalDAV:schedule-tag' => 'Schedule-Tag', |
|
1039
|
|
|
'DAV:getcontenttype' => 'Content type', |
|
1040
|
|
|
'DAV:resourcetype' => 'Resource type', |
|
1041
|
|
|
//'http://calendarserver.org/ns/:created-by' => 'Created by', |
|
1042
|
|
|
//'http://calendarserver.org/ns/:updated-by' => 'Updated by', |
|
1043
|
|
|
//'DAV:owner' => 'Owner', |
|
1044
|
|
|
//'DAV:current-user-privilege-set' => 'current-user-privilege-set', |
|
1045
|
|
|
//'DAV:getcontentlength' => 'Size', |
|
1046
|
|
|
//'DAV:sync-token' => 'sync-token', |
|
1047
|
|
|
); |
|
1048
|
|
|
$n = 0; |
|
1049
|
|
|
$collection_props = null; |
|
1050
|
|
|
foreach($files['files'] as $file) |
|
1051
|
|
|
{ |
|
1052
|
|
|
if (!isset($collection_props)) |
|
1053
|
|
|
{ |
|
1054
|
|
|
$collection_props = $this->props2array($file['props']); |
|
1055
|
|
|
echo '<h3>'.lang('Collection listing').': '.htmlspecialchars($collection_props['DAV:displayname'])."</h3>\n"; |
|
1056
|
|
|
continue; // own entry --> displaying properies later |
|
1057
|
|
|
} |
|
1058
|
|
|
if(!$n++) |
|
1059
|
|
|
{ |
|
1060
|
|
|
echo "<table>\n\t<tr class='th'>\n\t\t<th>#</th>\n\t\t<th>".lang('Name')."</th>"; |
|
1061
|
|
|
foreach($props2show as $label) |
|
1062
|
|
|
{ |
|
1063
|
|
|
echo "\t\t<th>".lang($label)."</th>\n"; |
|
1064
|
|
|
} |
|
1065
|
|
|
echo "\t</tr>\n"; |
|
1066
|
|
|
} |
|
1067
|
|
|
$props = $this->props2array($file['props']); |
|
1068
|
|
|
//echo $file['path']; _debug_array($props); |
|
1069
|
|
|
$class = $class == 'row_on' ? 'row_off' : 'row_on'; |
|
1070
|
|
|
|
|
1071
|
|
|
if (substr($file['path'],-1) == '/') |
|
1072
|
|
|
{ |
|
1073
|
|
|
$name = basename(substr($file['path'],0,-1)).'/'; |
|
1074
|
|
|
} |
|
1075
|
|
|
else |
|
1076
|
|
|
{ |
|
1077
|
|
|
$name = basename($file['path']); |
|
1078
|
|
|
} |
|
1079
|
|
|
|
|
1080
|
|
|
echo "\t<tr class='$class'>\n\t\t<td>$n</td>\n\t\t<td>". |
|
1081
|
|
|
Html::a_href(htmlspecialchars($name),'/groupdav.php'.strtr($file['path'], array( |
|
1082
|
|
|
'%' => '%25', |
|
1083
|
|
|
'#' => '%23', |
|
1084
|
|
|
'?' => '%3F', |
|
1085
|
|
|
)))."</td>\n"; |
|
1086
|
|
|
foreach($props2show as $prop => $label) |
|
1087
|
|
|
{ |
|
1088
|
|
|
echo "\t\t<td>".($prop=='DAV:getlastmodified'&&!empty($props[$prop])?date('Y-m-d H:i:s',$props[$prop]):$props[$prop])."</td>\n"; |
|
1089
|
|
|
} |
|
1090
|
|
|
echo "\t</tr>\n"; |
|
1091
|
|
|
} |
|
1092
|
|
|
if (!$n) |
|
1093
|
|
|
{ |
|
1094
|
|
|
echo '<p>'.lang('Collection empty.')."</p>\n"; |
|
1095
|
|
|
} |
|
1096
|
|
|
else |
|
1097
|
|
|
{ |
|
1098
|
|
|
echo "</table>\n"; |
|
1099
|
|
|
} |
|
1100
|
|
|
echo '<h3>'.lang('Properties')."</h3>\n"; |
|
1101
|
|
|
echo "<table>\n\t<tr class='th'><th>".lang('Namespace')."</th><th>".lang('Name')."</th><th>".lang('Value')."</th></tr>\n"; |
|
1102
|
|
|
foreach($collection_props as $name => $value) |
|
1103
|
|
|
{ |
|
1104
|
|
|
$class = $class == 'row_on' ? 'row_off' : 'row_on'; |
|
1105
|
|
|
$parts = explode(':', $name); |
|
1106
|
|
|
$name = array_pop($parts); |
|
1107
|
|
|
$ns = implode(':', $parts); |
|
1108
|
|
|
echo "\t<tr class='$class'>\n\t\t<td>".htmlspecialchars($ns)."</td><td style='white-space: nowrap'>".htmlspecialchars($name)."</td>\n"; |
|
1109
|
|
|
echo "\t\t<td>".$value."</td>\n\t</tr>\n"; |
|
1110
|
|
|
} |
|
1111
|
|
|
echo "</table>\n"; |
|
1112
|
|
|
$dav = array(1); |
|
1113
|
|
|
$allow = false; |
|
1114
|
|
|
$this->OPTIONS($options['path'], $dav, $allow); |
|
1115
|
|
|
echo "<p>DAV: ".implode(', ', $dav)."</p>\n"; |
|
1116
|
|
|
|
|
1117
|
|
|
echo "</body>\n</html>\n"; |
|
1118
|
|
|
|
|
1119
|
|
|
exit; |
|
|
|
|
|
|
1120
|
|
|
} |
|
1121
|
|
|
|
|
1122
|
|
|
/** |
|
1123
|
|
|
* Format a property value for output |
|
1124
|
|
|
* |
|
1125
|
|
|
* @param mixed $value |
|
1126
|
|
|
* @return string |
|
1127
|
|
|
*/ |
|
1128
|
|
|
protected function prop_value($value) |
|
1129
|
|
|
{ |
|
1130
|
|
|
if (is_array($value)) |
|
1131
|
|
|
{ |
|
1132
|
|
|
if (isset($value[0]['ns'])) |
|
1133
|
|
|
{ |
|
1134
|
|
|
$ns_defs = ''; |
|
1135
|
|
|
$ns_hash = array(); |
|
1136
|
|
|
$value = $this->_hierarchical_prop_encode($value, '', $ns_defs, $ns_hash); |
|
1137
|
|
|
} |
|
1138
|
|
|
$value = array2string($value); |
|
1139
|
|
|
} |
|
1140
|
|
|
if ($value[0] == '<' && function_exists('tidy_repair_string')) |
|
1141
|
|
|
{ |
|
1142
|
|
|
$value = tidy_repair_string($value, array( |
|
1143
|
|
|
'indent' => true, |
|
1144
|
|
|
'show-body-only' => true, |
|
1145
|
|
|
'output-encoding' => 'utf-8', |
|
1146
|
|
|
'input-encoding' => 'utf-8', |
|
1147
|
|
|
'input-xml' => true, |
|
1148
|
|
|
'output-xml' => true, |
|
1149
|
|
|
'wrap' => 0, |
|
1150
|
|
|
)); |
|
1151
|
|
|
} |
|
1152
|
|
|
if (($href=preg_match('/\<(D:)?href\>[^<]+\<\/(D:)?href\>/i',$value))) |
|
1153
|
|
|
{ |
|
1154
|
|
|
$value = preg_replace('/\<(D:)?href\>('.preg_quote($this->base_uri.'/','/').')?([^<]+)\<\/(D:)?href\>/i','<\\1href><a href="\\2\\3">\\3</a></\\4href>',$value); |
|
1155
|
|
|
} |
|
1156
|
|
|
$ret = $value[0] == '<' || strpos($value, "\n") !== false ? '<pre>'.htmlspecialchars($value).'</pre>' : htmlspecialchars($value); |
|
1157
|
|
|
|
|
1158
|
|
|
if ($href) |
|
1159
|
|
|
{ |
|
1160
|
|
|
$ret = str_replace('</a>', '</a>', preg_replace('/<a href="(.+)">/', '<a href="\\1">', $ret)); |
|
1161
|
|
|
} |
|
1162
|
|
|
return $ret; |
|
1163
|
|
|
} |
|
1164
|
|
|
|
|
1165
|
|
|
/** |
|
1166
|
|
|
* Return numeric indexed array with values for keys 'ns', 'name' and 'val' as array 'ns:name' => 'val' |
|
1167
|
|
|
* |
|
1168
|
|
|
* @param array $props |
|
1169
|
|
|
* @return array |
|
1170
|
|
|
*/ |
|
1171
|
|
|
protected function props2array(array $props) |
|
1172
|
|
|
{ |
|
1173
|
|
|
$arr = array(); |
|
1174
|
|
|
foreach($props as $prop) |
|
1175
|
|
|
{ |
|
1176
|
|
|
$ns_hash = array('DAV:' => 'D'); |
|
1177
|
|
|
switch($prop['ns']) |
|
1178
|
|
|
{ |
|
1179
|
|
|
case 'DAV:'; |
|
1180
|
|
|
$ns = 'DAV'; |
|
1181
|
|
|
break; |
|
1182
|
|
|
case self::CALDAV: |
|
1183
|
|
|
$ns = $ns_hash[$prop['ns']] = 'CalDAV'; |
|
1184
|
|
|
break; |
|
1185
|
|
|
case self::CARDDAV: |
|
1186
|
|
|
$ns = $ns_hash[$prop['ns']] = 'CardDAV'; |
|
1187
|
|
|
break; |
|
1188
|
|
|
case self::GROUPDAV: |
|
1189
|
|
|
$ns = $ns_hash[$prop['ns']] = 'GroupDAV'; |
|
1190
|
|
|
break; |
|
1191
|
|
|
default: |
|
1192
|
|
|
$ns = $prop['ns']; |
|
1193
|
|
|
} |
|
1194
|
|
|
if (is_array($prop['val'])) |
|
1195
|
|
|
{ |
|
1196
|
|
|
$prop['val'] = $this->_hierarchical_prop_encode($prop['val'], $prop['ns'], $ns_defs='', $ns_hash); |
|
1197
|
|
|
// hack to show real namespaces instead of not (visibly) defined shortcuts |
|
1198
|
|
|
unset($ns_hash['DAV:']); |
|
1199
|
|
|
$value = strtr($v=$this->prop_value($prop['val']),array_flip($ns_hash)); |
|
1200
|
|
|
} |
|
1201
|
|
|
else |
|
1202
|
|
|
{ |
|
1203
|
|
|
$value = $this->prop_value($prop['val']); |
|
1204
|
|
|
} |
|
1205
|
|
|
$arr[$ns.':'.$prop['name']] = $value; |
|
1206
|
|
|
} |
|
1207
|
|
|
return $arr; |
|
1208
|
|
|
} |
|
1209
|
|
|
|
|
1210
|
|
|
/** |
|
1211
|
|
|
* POST method handler |
|
1212
|
|
|
* |
|
1213
|
|
|
* @param array parameter passing array |
|
|
|
|
|
|
1214
|
|
|
* @return bool true on success |
|
1215
|
|
|
*/ |
|
1216
|
|
|
function POST(&$options) |
|
1217
|
|
|
{ |
|
1218
|
|
|
// for some reason OS X Addressbook (CFNetwork user-agent) uses now (DAV:add-member given with collection URL+"?add-member") |
|
1219
|
|
|
// POST to the collection URL plus a UID like name component (like for regular PUT) to create new entrys |
|
1220
|
|
|
if (isset($_GET['add-member']) || Handler::get_agent() == 'cfnetwork') |
|
1221
|
|
|
{ |
|
1222
|
|
|
$_GET['add-member'] = ''; // otherwise we give no Location header |
|
1223
|
|
|
return $this->PUT($options); |
|
1224
|
|
|
} |
|
1225
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).')'); |
|
1226
|
|
|
|
|
1227
|
|
|
$id = $app = $user = null; |
|
1228
|
|
|
$this->_parse_path($options['path'],$id,$app,$user); |
|
1229
|
|
|
|
|
1230
|
|
|
if (($handler = self::app_handler($app))) |
|
|
|
|
|
|
1231
|
|
|
{ |
|
1232
|
|
|
// managed attachments |
|
1233
|
|
|
if (isset($_GET['action']) && substr($_GET['action'], 0, 11) === 'attachment-') |
|
1234
|
|
|
{ |
|
1235
|
|
|
return $this->managed_attachements($options, $id, $handler, $_GET['action']); |
|
1236
|
|
|
} |
|
1237
|
|
|
|
|
1238
|
|
|
if (method_exists($handler, 'post')) |
|
1239
|
|
|
{ |
|
1240
|
|
|
// read the content in a string, if a stream is given |
|
1241
|
|
|
if (isset($options['stream'])) |
|
1242
|
|
|
{ |
|
1243
|
|
|
$options['content'] = ''; |
|
1244
|
|
|
while(!feof($options['stream'])) |
|
1245
|
|
|
{ |
|
1246
|
|
|
$options['content'] .= fread($options['stream'],8192); |
|
1247
|
|
|
} |
|
1248
|
|
|
} |
|
1249
|
|
|
return $handler->post($options,$id,$user); |
|
1250
|
|
|
} |
|
1251
|
|
|
} |
|
1252
|
|
|
return '501 Not Implemented'; |
|
1253
|
|
|
} |
|
1254
|
|
|
|
|
1255
|
|
|
/** |
|
1256
|
|
|
* HTTP header containing managed id |
|
1257
|
|
|
*/ |
|
1258
|
|
|
const MANAGED_ID_HEADER = 'Cal-Managed-ID'; |
|
1259
|
|
|
|
|
1260
|
|
|
/** |
|
1261
|
|
|
* Add, update or remove attachments |
|
1262
|
|
|
* |
|
1263
|
|
|
* @param array &$options |
|
1264
|
|
|
* @param string|int $id |
|
1265
|
|
|
* @param Handler $handler |
|
1266
|
|
|
* @param string $action 'attachment-add', 'attachment-update', 'attachment-remove' |
|
1267
|
|
|
* @return string http status |
|
1268
|
|
|
* |
|
1269
|
|
|
* @todo support for rid parameter |
|
1270
|
|
|
* @todo managed-id does NOT change on update |
|
1271
|
|
|
* @todo updates of attachments through vfs need to call $handler->update_tags($id) too |
|
1272
|
|
|
*/ |
|
1273
|
|
|
protected function managed_attachements(&$options, $id, Handler $handler, $action) |
|
1274
|
|
|
{ |
|
1275
|
|
|
error_log(__METHOD__."(path=$options[path], id=$id, ..., action=$action) _GET=".array2string($_GET)); |
|
1276
|
|
|
$entry = $handler->_common_get_put_delete('GET', $options, $id); |
|
1277
|
|
|
|
|
1278
|
|
|
if (!is_array($entry)) |
|
|
|
|
|
|
1279
|
|
|
{ |
|
1280
|
|
|
return $entry ? $entry : "404 Not found"; |
|
1281
|
|
|
} |
|
1282
|
|
|
|
|
1283
|
|
|
if (!Link::file_access($handler->app, $entry['id'], Acl::EDIT)) |
|
1284
|
|
|
{ |
|
1285
|
|
|
return '403 Forbidden'; |
|
1286
|
|
|
} |
|
1287
|
|
|
|
|
1288
|
|
|
switch($action) |
|
1289
|
|
|
{ |
|
1290
|
|
|
case 'attachment-add': |
|
1291
|
|
|
$matches = null; |
|
1292
|
|
|
if (isset($this->_SERVER['HTTP_CONTENT_DISPOSITION']) && |
|
1293
|
|
|
substr($this->_SERVER['HTTP_CONTENT_DISPOSITION'], 0, 10) === 'attachment' && |
|
1294
|
|
|
preg_match('/filename="?([^";]+)/', $this->_SERVER['HTTP_CONTENT_DISPOSITION'], $matches)) |
|
1295
|
|
|
{ |
|
1296
|
|
|
$filename = Vfs::basename($matches[1]); |
|
1297
|
|
|
} |
|
1298
|
|
|
$path = null; |
|
1299
|
|
|
if (!($to = self::fopen_attachment($handler->app, $handler->get_id($entry), $filename, $this->_SERVER['CONTENT_TYPE'], $path)) || |
|
1300
|
|
|
isset($options['stream']) && ($copied=stream_copy_to_stream($options['stream'], $to)) === false || |
|
1301
|
|
|
isset($options['content']) && ($copied=fwrite($to, $options['content'])) === false) |
|
1302
|
|
|
{ |
|
1303
|
|
|
return '403 Forbidden'; |
|
1304
|
|
|
} |
|
1305
|
|
|
fclose($to); |
|
1306
|
|
|
error_log(__METHOD__."() content-type=$options[content_type], filename=$filename: $path created $copied bytes copied"); |
|
1307
|
|
|
$ret = '201 Created'; |
|
1308
|
|
|
header(self::MANAGED_ID_HEADER.': '.self::path2managed_id($path)); |
|
1309
|
|
|
header('Location: '.self::path2location($path)); |
|
1310
|
|
|
break; |
|
1311
|
|
|
|
|
1312
|
|
|
case 'attachment-remove': |
|
1313
|
|
|
case 'attachment-update': |
|
1314
|
|
|
if (empty($_GET['managed-id']) || !($path = self::managed_id2path($_GET['managed-id'], $handler->app, $entry['id']))) |
|
1315
|
|
|
{ |
|
1316
|
|
|
self::xml_error(self::mkprop(self::CALDAV, 'valid-managed-id-parameter', '')); |
|
1317
|
|
|
return '403 Forbidden'; |
|
1318
|
|
|
} |
|
1319
|
|
|
if ($action == 'attachment-remove') |
|
1320
|
|
|
{ |
|
1321
|
|
|
if (!Vfs::unlink($path)) |
|
1322
|
|
|
{ |
|
1323
|
|
|
self::xml_error(self::mkprop(self::CALDAV, 'valid-managed-id-parameter', '')); |
|
1324
|
|
|
return '403 Forbidden'; |
|
1325
|
|
|
} |
|
1326
|
|
|
$ret = '204 No content'; |
|
1327
|
|
|
} |
|
1328
|
|
|
else |
|
1329
|
|
|
{ |
|
1330
|
|
|
// check for rename of attachment via Content-Disposition:filename= |
|
1331
|
|
|
if (isset($this->_SERVER['HTTP_CONTENT_DISPOSITION']) && |
|
1332
|
|
|
substr($this->_SERVER['HTTP_CONTENT_DISPOSITION'], 0, 10) === 'attachment' && |
|
1333
|
|
|
preg_match('/filename="?([^";]+)/', $this->_SERVER['HTTP_CONTENT_DISPOSITION'], $matches) && |
|
1334
|
|
|
($filename = Vfs::basename($matches[1])) != Vfs::basename($path)) |
|
1335
|
|
|
{ |
|
1336
|
|
|
$old_path = $path; |
|
1337
|
|
|
if (!($dir = Vfs::dirname($path)) || !Vfs::rename($old_path, $path = Vfs::concat($dir, $filename))) |
|
1338
|
|
|
{ |
|
1339
|
|
|
self::xml_error(self::mkprop(self::CALDAV, 'valid-managed-id-parameter', '')); |
|
1340
|
|
|
return '403 Forbidden'; |
|
1341
|
|
|
} |
|
1342
|
|
|
} |
|
1343
|
|
|
if (!($to = Vfs::fopen($path, 'w')) || |
|
1344
|
|
|
isset($options['stream']) && ($copied=stream_copy_to_stream($options['stream'], $to)) === false || |
|
1345
|
|
|
isset($options['content']) && ($copied=fwrite($to, $options['content'])) === false) |
|
1346
|
|
|
{ |
|
1347
|
|
|
self::xml_error(self::mkprop(self::CALDAV, 'valid-managed-id-parameter', '')); |
|
1348
|
|
|
return '403 Forbidden'; |
|
1349
|
|
|
} |
|
1350
|
|
|
fclose($to); |
|
1351
|
|
|
error_log(__METHOD__."() content-type=$options[content_type], filename=$filename: $path updated $copied bytes copied"); |
|
1352
|
|
|
$ret = '200 Ok'; |
|
1353
|
|
|
header(self::MANAGED_ID_HEADER.': '.self::path2managed_id($path)); |
|
1354
|
|
|
header('Location: '.self::path2location($path)); |
|
1355
|
|
|
} |
|
1356
|
|
|
break; |
|
1357
|
|
|
|
|
1358
|
|
|
default: |
|
1359
|
|
|
return '501 Unknown action parameter '.$action; |
|
1360
|
|
|
} |
|
1361
|
|
|
// update etag/ctag/sync-token by updating modification time |
|
1362
|
|
|
$handler->update_tags($entry); |
|
1363
|
|
|
|
|
1364
|
|
|
// check/handle Prefer: return-representation |
|
1365
|
|
|
// we can NOT use 204 No content (forbidds a body) with return=representation, therefore we need to use 200 Ok instead! |
|
1366
|
|
|
if ($handler->check_return_representation($options, $id) && (int)$ret == 204) |
|
1367
|
|
|
{ |
|
1368
|
|
|
$ret = '200 Ok'; |
|
1369
|
|
|
} |
|
1370
|
|
|
|
|
1371
|
|
|
return $ret; |
|
1372
|
|
|
} |
|
1373
|
|
|
|
|
1374
|
|
|
/** |
|
1375
|
|
|
* Handle ATTACH attribute on importing iCals |
|
1376
|
|
|
* |
|
1377
|
|
|
* - turn inline attachments into managed attachments |
|
1378
|
|
|
* - delete NOT included attachments, $delete_via_put is true |
|
1379
|
|
|
* @todo: store URLs not from our managed attachments |
|
1380
|
|
|
* |
|
1381
|
|
|
* @param string $app eg. 'calendar' |
|
1382
|
|
|
* @param int|string $id |
|
1383
|
|
|
* @param array $attach array of array with values for keys 'name', 'params', 'value' |
|
1384
|
|
|
* @param boolean $delete_via_put |
|
1385
|
|
|
* @return boolean false on error, eg. invalid managed id, for false an xml-error body has been send |
|
1386
|
|
|
*/ |
|
1387
|
|
|
public static function handle_attach($app, $id, $attach, $delete_via_put=false) |
|
1388
|
|
|
{ |
|
1389
|
|
|
//error_log(__METHOD__."('$app', $id, attach=".array2string($attach).", delete_via_put=".array2string($delete_via_put).')'); |
|
1390
|
|
|
|
|
1391
|
|
|
if (!Link::file_access($app, $id, Acl::EDIT)) |
|
1392
|
|
|
{ |
|
1393
|
|
|
error_log(__METHOD__."('$app', $id, ...) no rights to update attachments"); |
|
1394
|
|
|
return; // no rights --> nothing to do |
|
1395
|
|
|
} |
|
1396
|
|
|
if (!is_array($attach)) $attach = array(); // could be PEAR_Error if not set |
|
|
|
|
|
|
1397
|
|
|
|
|
1398
|
|
|
if ($delete_via_put) |
|
1399
|
|
|
{ |
|
1400
|
|
|
foreach(Vfs::find(Link::vfs_path($app, $id, '', true), array('type' => 'F')) as $path) |
|
1401
|
|
|
{ |
|
1402
|
|
|
$found = false; |
|
1403
|
|
|
foreach($attach as $key => $attr) |
|
1404
|
|
|
{ |
|
1405
|
|
|
if ($attr['params']['MANAGED-ID'] === self::path2managed_id($path)) |
|
1406
|
|
|
{ |
|
1407
|
|
|
$found = true; |
|
1408
|
|
|
unset($attach[$key]); |
|
1409
|
|
|
break; |
|
1410
|
|
|
} |
|
1411
|
|
|
} |
|
1412
|
|
|
if (!$found) |
|
1413
|
|
|
{ |
|
1414
|
|
|
$ok = Vfs::unlink($path); |
|
1415
|
|
|
error_log(__METHOD__."('$app', $id, ...) Vfs::unlink('$path') returned ".array2string($ok)); |
|
1416
|
|
|
} |
|
1417
|
|
|
} |
|
1418
|
|
|
} |
|
1419
|
|
|
// turn inline attachments into managed ones |
|
1420
|
|
|
foreach($attach as $key => $attr) |
|
1421
|
|
|
{ |
|
1422
|
|
|
if (!empty($attr['params']['FMTTYPE'])) |
|
1423
|
|
|
{ |
|
1424
|
|
|
if (isset($attr['params']['MANAGED-ID'])) |
|
1425
|
|
|
{ |
|
1426
|
|
|
// invalid managed-id |
|
1427
|
|
|
if (!($path = self::managed_id2path($attr['params']['MANAGED-ID'])) || !Vfs::is_readable($path)) |
|
1428
|
|
|
{ |
|
1429
|
|
|
error_log(__METHOD__."('$app', $id, ...) invalid MANAGED-ID ".array2string($attr)); |
|
1430
|
|
|
self::xml_error(self::mkprop(self::CALDAV, 'valid-managed-id', '')); |
|
1431
|
|
|
return false; |
|
1432
|
|
|
} |
|
1433
|
|
|
if($path == ($link = Link::vfs_path($app, $id, Vfs::basename($path)))) |
|
1434
|
|
|
{ |
|
1435
|
|
|
error_log(__METHOD__."('$app', $id, ...) trying to modify existing MANAGED-ID --> ignored! ".array2string($attr)); |
|
1436
|
|
|
continue; |
|
1437
|
|
|
} |
|
1438
|
|
|
// reuse valid managed-id --> symlink attachment |
|
1439
|
|
|
if (Vfs::file_exists($link)) |
|
1440
|
|
|
{ |
|
1441
|
|
|
if (Vfs::readlink($link) === $path) continue; // no need to recreate identical link |
|
1442
|
|
|
Vfs::unlink($link); // symlink will fail, if $link exists |
|
1443
|
|
|
} |
|
1444
|
|
|
if (!Vfs::symlink($path, $link)) |
|
1445
|
|
|
{ |
|
1446
|
|
|
error_log(__METHOD__."('$app', $id, ...) failed to symlink($path, $link) --> ignored!"); |
|
1447
|
|
|
} |
|
1448
|
|
|
continue; |
|
1449
|
|
|
} |
|
1450
|
|
|
if (!($to = self::fopen_attachment($app, $id, $filename=$attr['params']['FILENAME'], $attr['params']['FMTTYPE'], $path)) || |
|
1451
|
|
|
// Horde Icalendar does NOT decode automatic |
|
1452
|
|
|
(/*$copied=*/fwrite($to, $attr['params']['ENCODING'] == 'BASE64' ? base64_decode($attr['value']) : $attr['value'])) === false) |
|
1453
|
|
|
{ |
|
1454
|
|
|
error_log(__METHOD__."('$app', $id, ...) failed to add attachment ".array2string($attr).") "); |
|
1455
|
|
|
continue; |
|
1456
|
|
|
} |
|
1457
|
|
|
fclose($to); |
|
1458
|
|
|
//error_log(__METHOD__."('$app', $id, ...)) content-type={$attr['params']['FMTTYPE']}, filename=$filename: $path created $copied bytes copied"); |
|
1459
|
|
|
} |
|
1460
|
|
|
else |
|
1461
|
|
|
{ |
|
1462
|
|
|
//error_log(__METHOD__."('$app', $id, ...) unsupported URI attachment ".array2string($attr)); |
|
1463
|
|
|
} |
|
1464
|
|
|
} |
|
1465
|
|
|
} |
|
1466
|
|
|
|
|
1467
|
|
|
/** |
|
1468
|
|
|
* Open attachment for writing |
|
1469
|
|
|
* |
|
1470
|
|
|
* @param string $app |
|
1471
|
|
|
* @param int|string $id |
|
1472
|
|
|
* @param string $_filename defaults to 'attachment' |
|
1473
|
|
|
* @param string $mime =null mime-type to generate extension |
|
1474
|
|
|
* @param string &$path =null on return path opened |
|
1475
|
|
|
* @return resource |
|
1476
|
|
|
*/ |
|
1477
|
|
|
protected static function fopen_attachment($app, $id, $_filename, $mime=null, &$path=null) |
|
1478
|
|
|
{ |
|
1479
|
|
|
$filename = empty($_filename) ? 'attachment' : Vfs::basename($_filename); |
|
1480
|
|
|
|
|
1481
|
|
|
if (strpos($mime, ';')) list($mime) = explode(';', $mime); // in case it contains eg. charset info |
|
1482
|
|
|
|
|
1483
|
|
|
$ext = !empty($mime) ? MimeMagic::mime2ext($mime) : ''; |
|
1484
|
|
|
|
|
1485
|
|
|
$matches = null; |
|
1486
|
|
|
if (!$ext || substr($filename, -strlen($ext)-1) == '.'.$ext || |
|
1487
|
|
|
preg_match('/\.([^.]+)$/', $filename, $matches) && MimeMagic::ext2mime($matches[1]) == $mime) |
|
1488
|
|
|
{ |
|
1489
|
|
|
$parts = explode('.', $filename); |
|
1490
|
|
|
$ext = '.'.array_pop($parts); |
|
1491
|
|
|
$filename = implode('.', $parts); |
|
1492
|
|
|
} |
|
1493
|
|
|
else |
|
1494
|
|
|
{ |
|
1495
|
|
|
$ext = '.'.$ext; |
|
1496
|
|
|
} |
|
1497
|
|
|
for($i = 1; $i < 100; ++$i) |
|
1498
|
|
|
{ |
|
1499
|
|
|
$path = Link::vfs_path($app, $id, $filename.($i > 1 ? '-'.$i : '').$ext, true); |
|
1500
|
|
|
if (!Vfs::stat($path)) break; |
|
1501
|
|
|
} |
|
1502
|
|
|
if ($i >= 100) return null; |
|
1503
|
|
|
|
|
1504
|
|
|
if (!($dir = Vfs::dirname($path)) || !Vfs::file_exists($dir) && !Vfs::mkdir($dir, 0777, STREAM_MKDIR_RECURSIVE)) |
|
1505
|
|
|
{ |
|
1506
|
|
|
error_log(__METHOD__."('$app', $id, ...) failed to create entry dir $dir!"); |
|
1507
|
|
|
return false; |
|
1508
|
|
|
} |
|
1509
|
|
|
|
|
1510
|
|
|
return Vfs::fopen($path, 'w'); |
|
1511
|
|
|
} |
|
1512
|
|
|
|
|
1513
|
|
|
/** |
|
1514
|
|
|
* Get attachment location from path |
|
1515
|
|
|
* |
|
1516
|
|
|
* @param string $path |
|
1517
|
|
|
* @return string |
|
1518
|
|
|
*/ |
|
1519
|
|
|
protected static function path2location($path) |
|
1520
|
|
|
{ |
|
1521
|
|
|
return Framework::getUrl(Framework::link(Vfs::download_url($path))); |
|
1522
|
|
|
} |
|
1523
|
|
|
|
|
1524
|
|
|
/** |
|
1525
|
|
|
* Add ATTACH attribute(s) for iCal |
|
1526
|
|
|
* |
|
1527
|
|
|
* @param string $app eg. 'calendar' |
|
1528
|
|
|
* @param int|string $id |
|
1529
|
|
|
* @param array &$attributes |
|
1530
|
|
|
* @param array &$parameters |
|
1531
|
|
|
*/ |
|
1532
|
|
|
public static function add_attach($app, $id, array &$attributes, array &$parameters) |
|
1533
|
|
|
{ |
|
1534
|
|
|
foreach(Vfs::find(Link::vfs_path($app, $id, '', true), array( |
|
1535
|
|
|
'type' => 'F', |
|
1536
|
|
|
'need_mime' => true, |
|
1537
|
|
|
'maxdepth' => 10, // set a limit to not run into an infinit recursion |
|
1538
|
|
|
), true) as $path => $stat) |
|
1539
|
|
|
{ |
|
1540
|
|
|
// handle symlinks --> return target size and mime-type |
|
1541
|
|
|
if (($target = Vfs::readlink($path))) |
|
1542
|
|
|
{ |
|
1543
|
|
|
if (!($stat = Vfs::stat($target))) continue; // broken or inaccessible symlink |
|
1544
|
|
|
|
|
1545
|
|
|
// check if target is in /apps, probably reused MANAGED-ID --> return it |
|
1546
|
|
|
if (substr($target, 0, 6) == '/apps/') |
|
1547
|
|
|
{ |
|
1548
|
|
|
$path = $target; |
|
1549
|
|
|
} |
|
1550
|
|
|
} |
|
1551
|
|
|
$attributes['ATTACH'][] = self::path2location($path); |
|
1552
|
|
|
$parameters['ATTACH'][] = array( |
|
1553
|
|
|
'MANAGED-ID' => self::path2managed_id($path), |
|
1554
|
|
|
'FMTTYPE' => $stat['mime'], |
|
1555
|
|
|
'SIZE' => (string)$stat['size'], // Horde_Icalendar renders int as empty string |
|
1556
|
|
|
'FILENAME' => Vfs::basename($path), |
|
1557
|
|
|
); |
|
1558
|
|
|
// if we have attachments, set X-attribute to enable deleting them by put |
|
1559
|
|
|
// (works around events synced before without ATTACH attributes) |
|
1560
|
|
|
$attributes['X-EGROUPWARE-ATTACH-INCLUDED'] = 'TRUE'; |
|
1561
|
|
|
} |
|
1562
|
|
|
} |
|
1563
|
|
|
|
|
1564
|
|
|
/** |
|
1565
|
|
|
* Return managed-id of a vfs-path |
|
1566
|
|
|
* |
|
1567
|
|
|
* @param string $path "/apps/$app/$id/something" |
|
1568
|
|
|
* @return string |
|
1569
|
|
|
*/ |
|
1570
|
|
|
static public function path2managed_id($path) |
|
1571
|
|
|
{ |
|
1572
|
|
|
return base64_encode($path); |
|
1573
|
|
|
} |
|
1574
|
|
|
|
|
1575
|
|
|
/** |
|
1576
|
|
|
* Return vfs-path of a managed-id |
|
1577
|
|
|
* |
|
1578
|
|
|
* @param string $managed_id |
|
1579
|
|
|
* @param string $app =null app-name to check against path |
|
1580
|
|
|
* @param string|int $id =null id to check agains path |
|
1581
|
|
|
* @return string|boolean "/apps/$app/$id/something" or false if not found or not belonging to given $app/$id |
|
1582
|
|
|
*/ |
|
1583
|
|
|
static public function managed_id2path($managed_id, $app=null, $id=null) |
|
1584
|
|
|
{ |
|
1585
|
|
|
$path = base64_decode($managed_id); |
|
1586
|
|
|
|
|
1587
|
|
|
if (!$path || substr($path, 0, 6) != '/apps/' || !Vfs::stat($path)) |
|
1588
|
|
|
{ |
|
1589
|
|
|
$path = false; |
|
1590
|
|
|
} |
|
1591
|
|
|
elseif (!empty($app) && !empty($id)) |
|
1592
|
|
|
{ |
|
1593
|
|
|
list(,,$a,$i) = explode('/', $path); |
|
1594
|
|
|
if ($a !== $app || $i !== (string)$id) |
|
1595
|
|
|
{ |
|
1596
|
|
|
$path = false; |
|
1597
|
|
|
} |
|
1598
|
|
|
} |
|
1599
|
|
|
error_log(__METHOD__."('$managed_id', $app, $id) base64_decode('$managed_id')=".array2string(base64_decode($managed_id)).' returning '.array2string($path)); |
|
1600
|
|
|
return $path; |
|
1601
|
|
|
} |
|
1602
|
|
|
|
|
1603
|
|
|
/** |
|
1604
|
|
|
* Namespaces which need to be eplicitly named in self::$proppatch_props, |
|
1605
|
|
|
* because we consider them protected, if not explicitly named |
|
1606
|
|
|
* |
|
1607
|
|
|
* @var array |
|
1608
|
|
|
*/ |
|
1609
|
|
|
static $ns_needs_explicit_named_props = array(self::DAV, self::CALDAV, self::CARDDAV, self::CALENDARSERVER); |
|
1610
|
|
|
/** |
|
1611
|
|
|
* props modifyable via proppatch from client for name-spaces mentioned in self::$ns_needs_explicit_named_props |
|
1612
|
|
|
* |
|
1613
|
|
|
* Props named here are stored in prefs without namespace! |
|
1614
|
|
|
* |
|
1615
|
|
|
* @var array name => namespace pairs |
|
1616
|
|
|
*/ |
|
1617
|
|
|
static $proppatch_props = array( |
|
1618
|
|
|
'displayname' => self::DAV, |
|
1619
|
|
|
'calendar-description' => self::CALDAV, |
|
1620
|
|
|
'addressbook-description' => self::CARDDAV, |
|
1621
|
|
|
'calendar-color' => self::ICAL, // only mentioned that old prefs still work |
|
1622
|
|
|
'calendar-order' => self::ICAL, |
|
1623
|
|
|
'default-alarm-vevent-date' => self::CALDAV, |
|
1624
|
|
|
'default-alarm-vevent-datetime' => self::CALDAV, |
|
1625
|
|
|
); |
|
1626
|
|
|
|
|
1627
|
|
|
/** |
|
1628
|
|
|
* PROPPATCH method handler |
|
1629
|
|
|
* |
|
1630
|
|
|
* @param array &$options general parameter passing array |
|
1631
|
|
|
* @return string with responsedescription or null, individual status in $options['props'][]['status'] |
|
1632
|
|
|
*/ |
|
1633
|
|
|
function PROPPATCH(&$options) |
|
1634
|
|
|
{ |
|
1635
|
|
|
if ($this->debug) error_log(__METHOD__."(".array2string($options).')'); |
|
1636
|
|
|
|
|
1637
|
|
|
// parse path in form [/account_lid]/app[/more] |
|
1638
|
|
|
$id = $app = $user = $user_prefix = null; |
|
1639
|
|
|
self::_parse_path($options['path'],$id,$app,$user,$user_prefix); // allways returns false if eg. !$id |
|
|
|
|
|
|
1640
|
|
|
if ($app == 'principals' || $id || $options['path'] == '/') |
|
1641
|
|
|
{ |
|
1642
|
|
|
if ($this->debug > 1) error_log(__METHOD__.": user='$user', app='$app', id='$id': 404 not found!"); |
|
1643
|
|
|
foreach($options['props'] as &$prop) |
|
1644
|
|
|
{ |
|
1645
|
|
|
$prop['status'] = '403 Forbidden'; |
|
1646
|
|
|
} |
|
1647
|
|
|
return 'NOT allowed to PROPPATCH that resource!'; |
|
1648
|
|
|
} |
|
1649
|
|
|
// store selected props in preferences, eg. calendar-color, see self::$proppatch_props |
|
1650
|
|
|
$need_save = array(); |
|
1651
|
|
|
foreach($options['props'] as &$prop) |
|
1652
|
|
|
{ |
|
1653
|
|
|
if ((isset(self::$proppatch_props[$prop['name']]) && self::$proppatch_props[$prop['name']] === $prop['xmlns'] || |
|
|
|
|
|
|
1654
|
|
|
!in_array($prop['xmlns'],self::$ns_needs_explicit_named_props))) |
|
1655
|
|
|
{ |
|
1656
|
|
|
if (!$app) |
|
1657
|
|
|
{ |
|
1658
|
|
|
$app = 'groupdav'; |
|
1659
|
|
|
$name = $prop['name'].':'.$options['path'].':'.$prop['ns']; |
|
1660
|
|
|
} |
|
1661
|
|
|
else |
|
1662
|
|
|
{ |
|
1663
|
|
|
$name = $prop['name'].':'.$user.(isset(self::$proppatch_props[$prop['name']]) && |
|
1664
|
|
|
self::$proppatch_props[$prop['name']] == $prop['ns'] ? '' : ':'.$prop['ns']); |
|
1665
|
|
|
} |
|
1666
|
|
|
//error_log("preferences['user']['$app']['$name']=".array2string($GLOBALS['egw_info']['user']['preferences'][$app][$name]).($GLOBALS['egw_info']['user']['preferences'][$app][$name] !== $prop['val'] ? ' !== ':' === ')."prop['val']=".array2string($prop['val'])); |
|
1667
|
|
|
if ($GLOBALS['egw_info']['user']['preferences'][$app][$name] !== $prop['val']) // nothing to change otherwise |
|
1668
|
|
|
{ |
|
1669
|
|
|
if (isset($prop['val'])) |
|
1670
|
|
|
{ |
|
1671
|
|
|
$GLOBALS['egw']->preferences->add($app, $name, $prop['val']); |
|
1672
|
|
|
} |
|
1673
|
|
|
else |
|
1674
|
|
|
{ |
|
1675
|
|
|
$GLOBALS['egw']->preferences->delete($app, $name); |
|
1676
|
|
|
} |
|
1677
|
|
|
$need_save[] = $name; |
|
1678
|
|
|
} |
|
1679
|
|
|
$prop['status'] = '200 OK'; |
|
1680
|
|
|
} |
|
1681
|
|
|
else |
|
1682
|
|
|
{ |
|
1683
|
|
|
$prop['status'] = '409 Conflict'; // could also be "403 Forbidden" |
|
1684
|
|
|
} |
|
1685
|
|
|
} |
|
1686
|
|
|
if ($need_save) |
|
1687
|
|
|
{ |
|
1688
|
|
|
$GLOBALS['egw_info']['user']['preferences'] = $GLOBALS['egw']->preferences->save_repository(); |
|
1689
|
|
|
// call calendar-hook, if default-alarms are changed, to sync them to calendar prefs |
|
1690
|
|
|
if (class_exists('calendar_hooks')) |
|
1691
|
|
|
{ |
|
1692
|
|
|
foreach($need_save as $name) |
|
1693
|
|
|
{ |
|
1694
|
|
|
list($name) = explode(':', $name); |
|
1695
|
|
|
if (in_array($name, array('default-alarm-vevent-date', 'default-alarm-vevent-datetime'))) |
|
1696
|
|
|
{ |
|
1697
|
|
|
calendar_hooks::sync_default_alarms(); |
|
1698
|
|
|
break; |
|
1699
|
|
|
} |
|
1700
|
|
|
} |
|
1701
|
|
|
} |
|
1702
|
|
|
} |
|
1703
|
|
|
} |
|
1704
|
|
|
|
|
1705
|
|
|
/** |
|
1706
|
|
|
* PUT method handler |
|
1707
|
|
|
* |
|
1708
|
|
|
* @param array parameter passing array |
|
1709
|
|
|
* @return bool true on success |
|
1710
|
|
|
*/ |
|
1711
|
|
|
function PUT(&$options) |
|
1712
|
|
|
{ |
|
1713
|
|
|
// read the content in a string, if a stream is given |
|
1714
|
|
|
if (isset($options['stream'])) |
|
1715
|
|
|
{ |
|
1716
|
|
|
$options['content'] = ''; |
|
1717
|
|
|
while(!feof($options['stream'])) |
|
1718
|
|
|
{ |
|
1719
|
|
|
$options['content'] .= fread($options['stream'],8192); |
|
1720
|
|
|
} |
|
1721
|
|
|
} |
|
1722
|
|
|
|
|
1723
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).')'); |
|
1724
|
|
|
|
|
1725
|
|
|
$id = $app = $user = $prefix = null; |
|
1726
|
|
|
if (!$this->_parse_path($options['path'],$id,$app,$user,$prefix)) |
|
1727
|
|
|
{ |
|
1728
|
|
|
return '404 Not Found'; |
|
1729
|
|
|
} |
|
1730
|
|
|
if (($handler = self::app_handler($app))) |
|
|
|
|
|
|
1731
|
|
|
{ |
|
1732
|
|
|
$status = $handler->put($options,$id,$user,$prefix); |
|
|
|
|
|
|
1733
|
|
|
|
|
1734
|
|
|
// set default stati: true --> 204 No Content, false --> should be already handled |
|
1735
|
|
|
if (is_bool($status)) $status = $status ? '204 No Content' : '400 Something went wrong'; |
|
1736
|
|
|
|
|
1737
|
|
|
// check/handle Prefer: return-representation |
|
1738
|
|
|
if ($status[0] === '2' || $status === true) |
|
1739
|
|
|
{ |
|
1740
|
|
|
// we can NOT use 204 No content (forbidds a body) with return=representation, therefore we need to use 200 Ok instead! |
|
1741
|
|
|
if ($handler->check_return_representation($options, $id, $user) && (int)$status == 204) |
|
1742
|
|
|
{ |
|
1743
|
|
|
$status = '200 Ok'; |
|
1744
|
|
|
} |
|
1745
|
|
|
} |
|
1746
|
|
|
return $status; |
|
1747
|
|
|
} |
|
1748
|
|
|
return '501 Not Implemented'; |
|
1749
|
|
|
} |
|
1750
|
|
|
|
|
1751
|
|
|
/** |
|
1752
|
|
|
* DELETE method handler |
|
1753
|
|
|
* |
|
1754
|
|
|
* @param array general parameter passing array |
|
|
|
|
|
|
1755
|
|
|
* @return bool true on success |
|
1756
|
|
|
*/ |
|
1757
|
|
|
function DELETE($options) |
|
1758
|
|
|
{ |
|
1759
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).')'); |
|
1760
|
|
|
|
|
1761
|
|
|
$id = $app = $user = null; |
|
1762
|
|
|
if (!$this->_parse_path($options['path'],$id,$app,$user)) |
|
1763
|
|
|
{ |
|
1764
|
|
|
return '404 Not Found'; |
|
1765
|
|
|
} |
|
1766
|
|
|
if (($handler = self::app_handler($app))) |
|
|
|
|
|
|
1767
|
|
|
{ |
|
1768
|
|
|
$status = $handler->delete($options,$id,$user); |
|
1769
|
|
|
// set default stati: true --> 204 No Content, false --> should be already handled |
|
1770
|
|
|
if (is_bool($status)) $status = $status ? '204 No Content' : '400 Something went wrong'; |
|
1771
|
|
|
return $status; |
|
1772
|
|
|
} |
|
1773
|
|
|
return '501 Not Implemented'; |
|
1774
|
|
|
} |
|
1775
|
|
|
|
|
1776
|
|
|
/** |
|
1777
|
|
|
* MKCOL method handler |
|
1778
|
|
|
* |
|
1779
|
|
|
* @param array general parameter passing array |
|
1780
|
|
|
* @return bool true on success |
|
1781
|
|
|
*/ |
|
1782
|
|
|
function MKCOL($options) |
|
1783
|
|
|
{ |
|
1784
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).')'); |
|
1785
|
|
|
|
|
1786
|
|
|
return '501 Not Implemented'; |
|
1787
|
|
|
} |
|
1788
|
|
|
|
|
1789
|
|
|
/** |
|
1790
|
|
|
* MOVE method handler |
|
1791
|
|
|
* |
|
1792
|
|
|
* @param array general parameter passing array |
|
1793
|
|
|
* @return bool true on success |
|
1794
|
|
|
*/ |
|
1795
|
|
|
function MOVE($options) |
|
1796
|
|
|
{ |
|
1797
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).')'); |
|
1798
|
|
|
|
|
1799
|
|
|
return '501 Not Implemented'; |
|
1800
|
|
|
} |
|
1801
|
|
|
|
|
1802
|
|
|
/** |
|
1803
|
|
|
* COPY method handler |
|
1804
|
|
|
* |
|
1805
|
|
|
* @param array general parameter passing array |
|
1806
|
|
|
* @return bool true on success |
|
1807
|
|
|
*/ |
|
1808
|
|
|
function COPY($options, $del=false) |
|
1809
|
|
|
{ |
|
1810
|
|
|
if ($this->debug) error_log('self::'.($del ? 'MOVE' : 'COPY').'('.array2string($options).')'); |
|
1811
|
|
|
|
|
1812
|
|
|
return '501 Not Implemented'; |
|
1813
|
|
|
} |
|
1814
|
|
|
|
|
1815
|
|
|
/** |
|
1816
|
|
|
* LOCK method handler |
|
1817
|
|
|
* |
|
1818
|
|
|
* @param array general parameter passing array |
|
1819
|
|
|
* @return bool true on success |
|
1820
|
|
|
*/ |
|
1821
|
|
|
function LOCK(&$options) |
|
1822
|
|
|
{ |
|
1823
|
|
|
$id = $app = $user = null; |
|
1824
|
|
|
self::_parse_path($options['path'],$id,$app,$user); |
|
|
|
|
|
|
1825
|
|
|
$path = Vfs::app_entry_lock_path($app,$id); |
|
1826
|
|
|
|
|
1827
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).") path=$path"); |
|
1828
|
|
|
|
|
1829
|
|
|
// get the app handler, to check if the user has edit access to the entry (required to make locks) |
|
1830
|
|
|
$handler = self::app_handler($app); |
|
|
|
|
|
|
1831
|
|
|
|
|
1832
|
|
|
// TODO recursive locks on directories not supported yet |
|
1833
|
|
|
if (!$id || !empty($options['depth']) || !$handler->check_access(Acl::EDIT,$id)) |
|
1834
|
|
|
{ |
|
1835
|
|
|
return '409 Conflict'; |
|
1836
|
|
|
} |
|
1837
|
|
|
$options['timeout'] = time()+300; // 5min. hardcoded |
|
1838
|
|
|
|
|
1839
|
|
|
// dont know why, but HTTP_WebDAV_Server passes the owner in D:href tags, which get's passed unchanged to checkLock/PROPFIND |
|
1840
|
|
|
// that's wrong according to the standard and cadaver does not show it on discover --> strip_tags removes eventual tags |
|
1841
|
|
|
if (($ret = Vfs::lock($path,$options['locktoken'],$options['timeout'],strip_tags($options['owner']), |
|
|
|
|
|
|
1842
|
|
|
$options['scope'],$options['type'],isset($options['update']),false)) && !isset($options['update'])) // false = no ACL check |
|
1843
|
|
|
{ |
|
1844
|
|
|
return $ret ? '200 OK' : '409 Conflict'; |
|
|
|
|
|
|
1845
|
|
|
} |
|
1846
|
|
|
return $ret; |
|
1847
|
|
|
} |
|
1848
|
|
|
|
|
1849
|
|
|
/** |
|
1850
|
|
|
* UNLOCK method handler |
|
1851
|
|
|
* |
|
1852
|
|
|
* @param array general parameter passing array |
|
1853
|
|
|
* @return bool true on success |
|
1854
|
|
|
*/ |
|
1855
|
|
|
function UNLOCK(&$options) |
|
1856
|
|
|
{ |
|
1857
|
|
|
$id = $app = $user = null; |
|
1858
|
|
|
self::_parse_path($options['path'],$id,$app,$user); |
|
|
|
|
|
|
1859
|
|
|
$path = Vfs::app_entry_lock_path($app,$id); |
|
1860
|
|
|
|
|
1861
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).") path=$path"); |
|
1862
|
|
|
return Vfs::unlock($path,$options['token']) ? '204 No Content' : '409 Conflict'; |
|
1863
|
|
|
} |
|
1864
|
|
|
|
|
1865
|
|
|
/** |
|
1866
|
|
|
* checkLock() helper |
|
1867
|
|
|
* |
|
1868
|
|
|
* @param string resource path to check for locks |
|
1869
|
|
|
* @return bool true on success |
|
1870
|
|
|
*/ |
|
1871
|
|
|
function checkLock($path) |
|
1872
|
|
|
{ |
|
1873
|
|
|
$id = $app = $user = null; |
|
1874
|
|
|
self::_parse_path($path,$id,$app,$user); |
|
|
|
|
|
|
1875
|
|
|
|
|
1876
|
|
|
return Vfs::checkLock(Vfs::app_entry_lock_path($app, $id)); |
|
1877
|
|
|
} |
|
1878
|
|
|
|
|
1879
|
|
|
/** |
|
1880
|
|
|
* ACL method handler |
|
1881
|
|
|
* |
|
1882
|
|
|
* @param array general parameter passing array |
|
1883
|
|
|
* @return string HTTP status |
|
1884
|
|
|
*/ |
|
1885
|
|
|
function ACL(&$options) |
|
1886
|
|
|
{ |
|
1887
|
|
|
$id = $app = $user = null; |
|
1888
|
|
|
self::_parse_path($options['path'],$id,$app,$user); |
|
|
|
|
|
|
1889
|
|
|
|
|
1890
|
|
|
if ($this->debug) error_log(__METHOD__.'('.array2string($options).") path=$options[path]"); |
|
1891
|
|
|
|
|
1892
|
|
|
$options['errors'] = array(); |
|
1893
|
|
|
switch ($app) |
|
1894
|
|
|
{ |
|
1895
|
|
|
case 'calendar': |
|
1896
|
|
|
case 'addressbook': |
|
1897
|
|
|
case 'infolog': |
|
1898
|
|
|
$status = '200 OK'; // grant all |
|
1899
|
|
|
break; |
|
1900
|
|
|
default: |
|
1901
|
|
|
$options['errors'][] = 'no-inherited-ace-conflict'; |
|
1902
|
|
|
$status = '403 Forbidden'; |
|
1903
|
|
|
} |
|
1904
|
|
|
|
|
1905
|
|
|
return $status; |
|
1906
|
|
|
} |
|
1907
|
|
|
|
|
1908
|
|
|
/** |
|
1909
|
|
|
* Parse a path into it's id, app and user parts |
|
1910
|
|
|
* |
|
1911
|
|
|
* @param string $path |
|
1912
|
|
|
* @param int &$id |
|
1913
|
|
|
* @param string &$app addressbook, calendar, infolog (=infolog) |
|
1914
|
|
|
* @param int &$user |
|
1915
|
|
|
* @param string &$user_prefix =null |
|
1916
|
|
|
* @return boolean true on success, false on error |
|
1917
|
|
|
*/ |
|
1918
|
|
|
function _parse_path($path,&$id,&$app,&$user,&$user_prefix=null) |
|
1919
|
|
|
{ |
|
1920
|
|
|
if ($this->debug) |
|
1921
|
|
|
{ |
|
1922
|
|
|
error_log(__METHOD__." called with ('$path') id=$id, app='$app', user=$user"); |
|
1923
|
|
|
} |
|
1924
|
|
|
if ($path[0] == '/') |
|
1925
|
|
|
{ |
|
1926
|
|
|
$path = substr($path, 1); |
|
1927
|
|
|
} |
|
1928
|
|
|
$parts = explode('/', $this->_unslashify($path)); |
|
1929
|
|
|
|
|
1930
|
|
|
// /(resources|locations)/<resource-id>-<resource-name>/calendar |
|
1931
|
|
|
if ($parts[0] == 'resources' || $parts[0] == 'locations') |
|
1932
|
|
|
{ |
|
1933
|
|
|
if (!empty($parts[1])) |
|
1934
|
|
|
{ |
|
1935
|
|
|
$user = $parts[0].'/'.$parts[1]; |
|
1936
|
|
|
array_shift($parts); |
|
1937
|
|
|
$res_id = (int)array_shift($parts); |
|
1938
|
|
|
if (!Principals::read_resource($res_id)) |
|
1939
|
|
|
{ |
|
1940
|
|
|
return false; |
|
1941
|
|
|
} |
|
1942
|
|
|
$account_id = 'r'.$res_id; |
|
1943
|
|
|
$app = 'calendar'; |
|
1944
|
|
|
} |
|
1945
|
|
|
} |
|
1946
|
|
|
elseif (($account_id = $this->accounts->name2id($parts[0], 'account_lid')) || |
|
1947
|
|
|
($account_id = $this->accounts->name2id($parts[0]=urldecode($parts[0])))) |
|
1948
|
|
|
{ |
|
1949
|
|
|
// /$user/$app/... |
|
1950
|
|
|
$user = array_shift($parts); |
|
1951
|
|
|
} |
|
1952
|
|
|
|
|
1953
|
|
|
if (!isset($app)) $app = array_shift($parts); |
|
1954
|
|
|
|
|
1955
|
|
|
// /addressbook-accounts/ |
|
1956
|
|
|
if (!$account_id && $app == 'addressbook-accounts') |
|
1957
|
|
|
{ |
|
1958
|
|
|
$app = 'addressbook'; |
|
1959
|
|
|
$user = 0; |
|
1960
|
|
|
$user_prefix = '/'; |
|
1961
|
|
|
} |
|
1962
|
|
|
// shared calendars/addressbooks at /<currentuser>/(calendar|addressbook|infolog|resource|location)-<username> |
|
1963
|
|
|
elseif ($account_id == $GLOBALS['egw_info']['user']['account_id'] && strpos($app, '-') !== false) |
|
1964
|
|
|
{ |
|
1965
|
|
|
$user_prefix = '/'.$GLOBALS['egw_info']['user']['account_lid'].'/'.$app; |
|
1966
|
|
|
list($app, $username) = explode('-', $app, 2); |
|
1967
|
|
|
if ($username == 'accounts' && $GLOBALS['egw_info']['user']['preferences']['addressbook']['hide_accounts'] !== '1') |
|
1968
|
|
|
{ |
|
1969
|
|
|
$account_id = 0; |
|
1970
|
|
|
} |
|
1971
|
|
|
elseif($app == 'resource' || $app == 'location') |
|
1972
|
|
|
{ |
|
1973
|
|
|
if (!Principals::read_resource($res_id = (int)$username)) |
|
1974
|
|
|
{ |
|
1975
|
|
|
return false; |
|
1976
|
|
|
} |
|
1977
|
|
|
$account_id = 'r'.$res_id; |
|
1978
|
|
|
$app = 'calendar'; |
|
1979
|
|
|
} |
|
1980
|
|
|
elseif (!($account_id = $this->accounts->name2id($username, 'account_lid')) && |
|
1981
|
|
|
!($account_id = $this->accounts->name2id($username=urldecode($username)))) |
|
1982
|
|
|
{ |
|
1983
|
|
|
return false; |
|
1984
|
|
|
} |
|
1985
|
|
|
$user = $account_id; |
|
1986
|
|
|
} |
|
1987
|
|
|
elseif ($user) |
|
1988
|
|
|
{ |
|
1989
|
|
|
$user_prefix = '/'.$user; |
|
1990
|
|
|
$user = $account_id; |
|
1991
|
|
|
// /<currentuser>/inbox/ |
|
1992
|
|
|
if ($user == $GLOBALS['egw_info']['user']['account_id'] && $app == 'inbox') |
|
1993
|
|
|
{ |
|
1994
|
|
|
$app = 'calendar'; |
|
1995
|
|
|
} |
|
1996
|
|
|
} |
|
1997
|
|
|
else |
|
1998
|
|
|
{ |
|
1999
|
|
|
$user_prefix = ''; |
|
2000
|
|
|
$user = $GLOBALS['egw_info']['user']['account_id']; |
|
2001
|
|
|
} |
|
2002
|
|
|
|
|
2003
|
|
|
// Api\WebDAV\Server encodes %, # and ? again, which leads to storing eg. '%' as '%25' |
|
2004
|
|
|
$id = strtr(array_pop($parts), array( |
|
2005
|
|
|
'%25' => '%', |
|
2006
|
|
|
'%23' => '#', |
|
2007
|
|
|
'%3F' => '?', |
|
2008
|
|
|
)); |
|
2009
|
|
|
|
|
2010
|
|
|
$ok = ($id || isset($_GET['add-member']) && $_SERVER['REQUEST_METHOD'] == 'POST') && |
|
2011
|
|
|
($user || $user === 0) && in_array($app,array('addressbook','calendar','infolog','principals')); |
|
2012
|
|
|
|
|
2013
|
|
|
if ($this->debug) |
|
2014
|
|
|
{ |
|
2015
|
|
|
error_log(__METHOD__."('$path') returning " . ($ok ? 'true' : 'false') . ": id='$id', app='$app', user='$user', user_prefix='$user_prefix'"); |
|
2016
|
|
|
} |
|
2017
|
|
|
return $ok; |
|
2018
|
|
|
} |
|
2019
|
|
|
|
|
2020
|
|
|
protected static $request_starttime; |
|
2021
|
|
|
/** |
|
2022
|
|
|
* Log level from user prefs: $GLOBALS['egw_info']['user']['preferences']['groupdav']['debug_level']) |
|
2023
|
|
|
* - 'f' files directory |
|
2024
|
|
|
* - 'r' to error-log, but only shortend requests |
|
2025
|
|
|
* |
|
2026
|
|
|
* @var string |
|
2027
|
|
|
*/ |
|
2028
|
|
|
protected static $log_level; |
|
2029
|
|
|
|
|
2030
|
|
|
/** |
|
2031
|
|
|
* Serve WebDAV HTTP request |
|
2032
|
|
|
* |
|
2033
|
|
|
* Reimplemented to add logging |
|
2034
|
|
|
* |
|
2035
|
|
|
* @param $prefix =null prefix filesystem path with given path, eg. "/webdav" for owncloud 4.5 remote.php |
|
|
|
|
|
|
2036
|
|
|
*/ |
|
2037
|
|
|
function ServeRequest($prefix=null) |
|
2038
|
|
|
{ |
|
2039
|
|
|
if ((self::$log_level=$GLOBALS['egw_info']['user']['preferences']['groupdav']['debug_level']) === 'r' || |
|
2040
|
|
|
self::$log_level === 'f' || $this->debug) |
|
2041
|
|
|
{ |
|
2042
|
|
|
self::$request_starttime = microtime(true); |
|
2043
|
|
|
// do NOT log non-text attachments |
|
2044
|
|
|
$this->store_request = $_SERVER['REQUEST_METHOD'] != 'POST' || !isset($_GET['action']) || |
|
2045
|
|
|
!in_array($_GET['action'], array('attachment-add', 'attachment-update')) || |
|
2046
|
|
|
substr($_SERVER['CONTENT_TYPE'], 0, 5) == 'text/'; |
|
2047
|
|
|
ob_start(); |
|
2048
|
|
|
} |
|
2049
|
|
|
parent::ServeRequest($prefix); |
|
2050
|
|
|
|
|
2051
|
|
|
if (self::$request_starttime) self::log_request(); |
|
|
|
|
|
|
2052
|
|
|
} |
|
2053
|
|
|
|
|
2054
|
|
|
/** |
|
2055
|
|
|
* Sanitizing filename to gard agains path traversal and / eg. in UserAgent string |
|
2056
|
|
|
* |
|
2057
|
|
|
* @param string $filename |
|
2058
|
|
|
* @return string |
|
2059
|
|
|
*/ |
|
2060
|
|
|
public static function sanitize_filename($filename) |
|
2061
|
|
|
{ |
|
2062
|
|
|
return str_replace(array('../', '/'), array('', '!'), $filename); |
|
2063
|
|
|
} |
|
2064
|
|
|
|
|
2065
|
|
|
/** |
|
2066
|
|
|
* Log the request |
|
2067
|
|
|
* |
|
2068
|
|
|
* @param string $extra ='' extra text to add below request-log, eg. exception thrown |
|
2069
|
|
|
*/ |
|
2070
|
|
|
protected function log_request($extra='') |
|
2071
|
|
|
{ |
|
2072
|
|
|
if (self::$request_starttime) |
|
2073
|
|
|
{ |
|
2074
|
|
|
if (self::$log_level === 'f') |
|
2075
|
|
|
{ |
|
2076
|
|
|
$msg_file = $GLOBALS['egw_info']['server']['files_dir']; |
|
2077
|
|
|
$msg_file .= '/groupdav'; |
|
2078
|
|
|
$msg_file .= '/'.self::sanitize_filename($GLOBALS['egw_info']['user']['account_lid']).'/'; |
|
2079
|
|
|
if (!file_exists($msg_file) && !mkdir($msg_file, 0700, true)) |
|
2080
|
|
|
{ |
|
2081
|
|
|
error_log(__METHOD__."() Could NOT create directory '$msg_file'!"); |
|
2082
|
|
|
return; |
|
2083
|
|
|
} |
|
2084
|
|
|
// stop CalDAVTester from creating one log per test-step |
|
2085
|
|
|
if (substr($_SERVER['HTTP_USER_AGENT'], 0, 14) == 'scripts/tests/') |
|
2086
|
|
|
{ |
|
2087
|
|
|
$msg_file .= 'CalDAVTester.log'; |
|
2088
|
|
|
} |
|
2089
|
|
|
else |
|
2090
|
|
|
{ |
|
2091
|
|
|
$msg_file .= self::sanitize_filename($_SERVER['HTTP_USER_AGENT']).'.log'; |
|
2092
|
|
|
} |
|
2093
|
|
|
$content = '*** '.$_SERVER['REMOTE_ADDR'].' '.date('c')."\n"; |
|
2094
|
|
|
} |
|
2095
|
|
|
$content .= $_SERVER['REQUEST_METHOD'].' '.$_SERVER['REQUEST_URI'].' HTTP/1.1'."\n"; |
|
2096
|
|
|
// reconstruct headers |
|
2097
|
|
|
foreach($_SERVER as $name => $value) |
|
2098
|
|
|
{ |
|
2099
|
|
|
list($type,$name) = explode('_',$name,2); |
|
2100
|
|
|
if ($type == 'HTTP' || $type == 'CONTENT') |
|
2101
|
|
|
{ |
|
2102
|
|
|
$content .= str_replace(' ','-',ucwords(strtolower(($type=='HTTP'?'':$type.' ').str_replace('_',' ',$name)))). |
|
2103
|
|
|
': '.($name=='AUTHORIZATION'?'Basic ***************':$value)."\n"; |
|
2104
|
|
|
} |
|
2105
|
|
|
} |
|
2106
|
|
|
$content .= "\n"; |
|
2107
|
|
|
if ($this->request) |
|
2108
|
|
|
{ |
|
2109
|
|
|
$content .= $this->request."\n"; |
|
2110
|
|
|
} |
|
2111
|
|
|
$content .= 'HTTP/1.1 '.$this->_http_status."\n"; |
|
2112
|
|
|
$content .= 'Date: '.str_replace('+0000', 'GMT', gmdate('r'))."\n"; |
|
2113
|
|
|
$content .= 'Server: '.$_SERVER['SERVER_SOFTWARE']."\n"; |
|
2114
|
|
|
foreach(headers_list() as $line) |
|
2115
|
|
|
{ |
|
2116
|
|
|
$content .= $line."\n"; |
|
2117
|
|
|
} |
|
2118
|
|
|
if (($c = ob_get_flush())) $content .= "\n"; |
|
2119
|
|
|
if (self::$log_level !== 'f' && strlen($c) > 1536) $c = substr($c,0,1536)."\n*** LOG TRUNKATED\n"; |
|
2120
|
|
|
$content .= $c; |
|
2121
|
|
|
if ($extra) $content .= $extra; |
|
2122
|
|
|
if ($this->to_log) $content .= "\n### ".implode("\n### ", $this->to_log)."\n"; |
|
|
|
|
|
|
2123
|
|
|
$content .= $this->_http_status[0] == '4' && substr($this->_http_status,0,3) != '412' || |
|
2124
|
|
|
$this->_http_status[0] == '5' ? '###' : '***'; // mark failed requests with ###, instead of *** |
|
2125
|
|
|
$content .= sprintf(' %s --> "%s" took %5.3f s',$_SERVER['REQUEST_METHOD'].($_SERVER['REQUEST_METHOD']=='REPORT'?' '.$this->propfind_options['root']['name']:'').' '.$_SERVER['PATH_INFO'],$this->_http_status,microtime(true)-self::$request_starttime)."\n\n"; |
|
2126
|
|
|
|
|
2127
|
|
|
if ($msg_file && ($f = fopen($msg_file,'a'))) |
|
2128
|
|
|
{ |
|
2129
|
|
|
flock($f,LOCK_EX); |
|
2130
|
|
|
fwrite($f,$content); |
|
2131
|
|
|
flock($f,LOCK_UN); |
|
2132
|
|
|
fclose($f); |
|
2133
|
|
|
} |
|
2134
|
|
|
else |
|
2135
|
|
|
{ |
|
2136
|
|
|
foreach(explode("\n",$content) as $line) |
|
2137
|
|
|
{ |
|
2138
|
|
|
error_log($line); |
|
2139
|
|
|
} |
|
2140
|
|
|
} |
|
2141
|
|
|
} |
|
2142
|
|
|
} |
|
2143
|
|
|
|
|
2144
|
|
|
/** |
|
2145
|
|
|
* Output xml error element |
|
2146
|
|
|
* |
|
2147
|
|
|
* @param string|array $xml_error string with name for empty element in DAV NS or array with props |
|
2148
|
|
|
* @param string $human_readable =null human readable error message |
|
2149
|
|
|
*/ |
|
2150
|
|
|
public static function xml_error($xml_error, $human_readable=null) |
|
2151
|
|
|
{ |
|
2152
|
|
|
header('Content-type: application/xml; charset=utf-8'); |
|
2153
|
|
|
|
|
2154
|
|
|
$xml = new \XMLWriter; |
|
2155
|
|
|
$xml->openMemory(); |
|
2156
|
|
|
$xml->setIndent(true); |
|
2157
|
|
|
$xml->startDocument('1.0', 'utf-8'); |
|
2158
|
|
|
$xml->startElementNs(null, 'error', 'DAV:'); |
|
2159
|
|
|
|
|
2160
|
|
|
self::add_prop($xml, $xml_error); |
|
2161
|
|
|
|
|
2162
|
|
|
if (!empty($human_readable)) |
|
2163
|
|
|
{ |
|
2164
|
|
|
$xml->writeElement('responsedescription', $human_readable); |
|
2165
|
|
|
} |
|
2166
|
|
|
|
|
2167
|
|
|
$xml->endElement(); // DAV:error |
|
2168
|
|
|
$xml->endDocument(); |
|
2169
|
|
|
echo $xml->outputMemory(); |
|
2170
|
|
|
} |
|
2171
|
|
|
|
|
2172
|
|
|
/** |
|
2173
|
|
|
* Recursivly add properties to XMLWriter object |
|
2174
|
|
|
* |
|
2175
|
|
|
* @param \XMLWriter $xml |
|
2176
|
|
|
* @param string|array $props string with name for empty element in DAV NS or array with props |
|
2177
|
|
|
*/ |
|
2178
|
|
|
protected static function add_prop(\XMLWriter $xml, $props) |
|
2179
|
|
|
{ |
|
2180
|
|
|
if (is_string($props)) $props = self::mkprop($props, ''); |
|
2181
|
|
|
if (isset($props['name'])) $props = array($props); |
|
2182
|
|
|
|
|
2183
|
|
|
foreach($props as $prop) |
|
2184
|
|
|
{ |
|
2185
|
|
|
if (isset($prop['ns']) && $prop['ns'] !== 'DAV:') |
|
2186
|
|
|
{ |
|
2187
|
|
|
$xml->startElementNs(null, $prop['name'], $prop['ns']); |
|
2188
|
|
|
} |
|
2189
|
|
|
else |
|
2190
|
|
|
{ |
|
2191
|
|
|
$xml->startElement($prop['name']); |
|
2192
|
|
|
} |
|
2193
|
|
|
if (is_array($prop['val'])) |
|
2194
|
|
|
{ |
|
2195
|
|
|
self::add_prop($xml, $prop['val']); |
|
2196
|
|
|
} |
|
2197
|
|
|
else |
|
2198
|
|
|
{ |
|
2199
|
|
|
$xml->text((string)$prop['val']); |
|
2200
|
|
|
} |
|
2201
|
|
|
$xml->endElement(); |
|
2202
|
|
|
} |
|
2203
|
|
|
} |
|
2204
|
|
|
|
|
2205
|
|
|
/** |
|
2206
|
|
|
* Content of log() calls, to be appended to request_log |
|
2207
|
|
|
* |
|
2208
|
|
|
* @var array |
|
2209
|
|
|
*/ |
|
2210
|
|
|
private $to_log = array(); |
|
2211
|
|
|
|
|
2212
|
|
|
/** |
|
2213
|
|
|
* Log unconditional to own request- and PHP error-log |
|
2214
|
|
|
* |
|
2215
|
|
|
* @param string $str |
|
2216
|
|
|
*/ |
|
2217
|
|
|
public function log($str) |
|
2218
|
|
|
{ |
|
2219
|
|
|
$this->to_log[] = $str; |
|
2220
|
|
|
|
|
2221
|
|
|
error_log($str); |
|
2222
|
|
|
} |
|
2223
|
|
|
|
|
2224
|
|
|
/** |
|
2225
|
|
|
* Exception handler, which additionally logs the request (incl. a trace) |
|
2226
|
|
|
* |
|
2227
|
|
|
* Does NOT return and get installed in constructor. |
|
2228
|
|
|
* |
|
2229
|
|
|
* @param \Exception|\Error $e |
|
2230
|
|
|
*/ |
|
2231
|
|
|
public static function exception_handler($e) |
|
2232
|
|
|
{ |
|
2233
|
|
|
// logging exception as regular egw_execption_hander does |
|
2234
|
|
|
$headline = null; |
|
2235
|
|
|
_egw_log_exception($e,$headline); |
|
2236
|
|
|
|
|
2237
|
|
|
// exception handler sending message back to the client as basic auth message |
|
2238
|
|
|
$error = str_replace(array("\r", "\n"), array('', ' | '), $e->getMessage()); |
|
2239
|
|
|
header('WWW-Authenticate: Basic realm="'.$headline.': '.$error.'"'); |
|
2240
|
|
|
header('HTTP/1.1 401 Unauthorized'); |
|
2241
|
|
|
header('X-WebDAV-Status: 401 Unauthorized', true); |
|
2242
|
|
|
|
|
2243
|
|
|
// if our own logging is active, log the request plus a trace, if enabled in server-config |
|
2244
|
|
|
if (self::$request_starttime && isset(self::$instance)) |
|
2245
|
|
|
{ |
|
2246
|
|
|
self::$instance->_http_status = '401 Unauthorized'; // to correctly log it |
|
2247
|
|
|
if ($GLOBALS['egw_info']['server']['exception_show_trace']) |
|
2248
|
|
|
{ |
|
2249
|
|
|
self::$instance->log_request("\n".$e->getTraceAsString()."\n"); |
|
2250
|
|
|
} |
|
2251
|
|
|
else |
|
2252
|
|
|
{ |
|
2253
|
|
|
self::$instance->log_request(); |
|
2254
|
|
|
} |
|
2255
|
|
|
} |
|
2256
|
|
|
exit; |
|
|
|
|
|
|
2257
|
|
|
} |
|
2258
|
|
|
|
|
2259
|
|
|
/** |
|
2260
|
|
|
* Generate a unique id, which can be used for syncronisation |
|
2261
|
|
|
* |
|
2262
|
|
|
* @param string $_appName the appname |
|
2263
|
|
|
* @param string $_eventID the id of the content |
|
2264
|
|
|
* @return string the unique id |
|
2265
|
|
|
*/ |
|
2266
|
|
|
static function generate_uid($_appName, $_eventID) |
|
2267
|
|
|
{ |
|
2268
|
|
|
if(empty($_appName) || empty($_eventID)) return false; |
|
2269
|
|
|
|
|
2270
|
|
|
return $_appName.'-'.$_eventID.'-'.$GLOBALS['egw_info']['server']['install_id']; |
|
2271
|
|
|
} |
|
2272
|
|
|
} |
|
2273
|
|
|
|
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:For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths