Mercurial > hg > dav / file comparison

comparison: dav/methods.c

dav/methods.c

changeset 5
88625853ae74
child 13
8a0cc4d90de7
equal deleted inserted replaced
4:ae5a98f0545c 5:88625853ae74
1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3 *
4 * Copyright 2013 Olaf Wintermann. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "utils.h"
34 #include "methods.h"
35
36 #define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)
37
38 /* ----------------------------- PROPFIND ----------------------------- */
39
40 CURLcode do_propfind_request(
41 CURL *handle,
42 UcxBuffer *request,
43 UcxBuffer *response)
44 {
45 curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, "PROPFIND");
46
47 struct curl_slist *headers = NULL;
48 headers = curl_slist_append(headers, "Content-Type: text/xml");
49 headers = curl_slist_append(headers, "Depth: 1");
50 curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers);
51
52 curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0);
53
54 curl_easy_setopt(handle, CURLOPT_UPLOAD, 1);
55 curl_easy_setopt(handle, CURLOPT_READFUNCTION, ucx_buffer_read);
56 curl_easy_setopt(handle, CURLOPT_READDATA, request);
57 curl_easy_setopt(handle, CURLOPT_INFILESIZE, request->size);
58
59 curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, ucx_buffer_write);
60 curl_easy_setopt(handle, CURLOPT_WRITEDATA, response);
61
62 ucx_buffer_seek(request, 0, SEEK_SET);
63 return curl_easy_perform(handle);
64 }
65
66 UcxBuffer* create_allprop_propfind_request() {
67 UcxBuffer *buf = ucx_buffer_new(NULL, 512, 0);
68 sstr_t s;
69
70 s = S("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
71 ucx_buffer_write(s.ptr, 1, s.length, buf);
72
73 s = S("<D:propfind xmlns:D=\"DAV:\">\n");
74 ucx_buffer_write(s.ptr, 1, s.length, buf);
75
76 s = S("<D:allprop/></D:propfind>\n");
77 ucx_buffer_write(s.ptr, 1, s.length, buf);
78
79 return buf;
80 }
81
82 UcxBuffer* create_propfind_request(UcxList *properties) {
83 UcxBuffer *buf = ucx_buffer_new(NULL, 512, 0);
84 sstr_t s;
85
86 UcxMap *namespaces = ucx_map_new(8);
87 UCX_FOREACH(elm, properties) {
88 DavProperty *p = elm->data;
89 if(strcmp(p->ns->name, "DAV:")) {
90 ucx_map_cstr_put(namespaces, p->ns->prefix, p->ns);
91 }
92 }
93
94 s = S("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
95 ucx_buffer_write(s.ptr, 1, s.length, buf);
96
97 // write root element and namespaces
98 s = S("<D:propfind xmlns:D=\"DAV:\"");
99 ucx_buffer_write(s.ptr, 1, s.length, buf);
100 UcxMapIterator mapi = ucx_map_iterator(namespaces);
101 UcxKey key;
102 DavNamespace *ns;
103 UCX_MAP_FOREACH(key, ns, mapi) {
104 s = S(" xmlns:");
105 ucx_buffer_write(s.ptr, 1, s.length, buf);
106 s = sstr(ns->prefix);
107 ucx_buffer_write(s.ptr, 1, s.length, buf);
108 s = S("=\"");
109 ucx_buffer_write(s.ptr, 1, s.length, buf);
110 s = sstr(ns->name);
111 ucx_buffer_write(s.ptr, 1, s.length, buf);
112 s = S("\"");
113 ucx_buffer_write(s.ptr, 1, s.length, buf);
114 }
115 s = S(">\n");
116 ucx_buffer_write(s.ptr, 1, s.length, buf);
117
118 // default properties
119 s = S("<D:prop>\n");
120 ucx_buffer_write(s.ptr, 1, s.length, buf);
121
122 s = S("<D:creationdate />\n<D:getlastmodified />\n");
123 ucx_buffer_write(s.ptr, 1, s.length, buf);
124
125 s = S("<D:getcontentlength />\n<D:getcontenttype />\n");
126 ucx_buffer_write(s.ptr, 1, s.length, buf);
127
128 s = S("<D:resourcetype />\n");
129 ucx_buffer_write(s.ptr, 1, s.length, buf);
130
131 // extra properties
132 UCX_FOREACH(elm, properties) {
133 DavProperty *prop = elm->data;
134 s = S("<");
135 ucx_buffer_write(s.ptr, 1, s.length, buf);
136 s = sstr(prop->ns->prefix);
137 ucx_buffer_write(s.ptr, 1, s.length, buf);
138 s = S(":");
139 ucx_buffer_write(s.ptr, 1, s.length, buf);
140 s = sstr(prop->name);
141 ucx_buffer_write(s.ptr, 1, s.length, buf);
142 s = S(" />\n");
143 ucx_buffer_write(s.ptr, 1, s.length, buf);
144 }
145
146 // end
147 s = S("</D:prop>\n</D:propfind>\n");
148 ucx_buffer_write(s.ptr, 1, s.length, buf);
149
150 return buf;
151 }
152
153 DavResource* parse_propfind_response(DavSession *sn, UcxBuffer *response) {
154 char *url = NULL;
155 curl_easy_getinfo(sn->handle, CURLINFO_EFFECTIVE_URL, &url);
156 DavResource *root = resource_new_href(sn, util_url_path(url));
157
158 xmlDoc *doc = xmlReadMemory(response->space, response->size, url, NULL, 0);
159 if(!doc) {
160 // TODO: free stuff
161 return NULL;
162 }
163
164 xmlNode *xml_root = xmlDocGetRootElement(doc);
165 xmlNode *node = xml_root->children;
166 while(node) {
167 if(node->type == XML_ELEMENT_NODE) {
168 if(xstreq(node->name, "response")) {
169 parse_response_tag(root, node);
170 }
171 }
172
173 node = node->next;
174 }
175
176 return root;
177 }
178
179 int parse_response_tag(DavResource *resource, xmlNode *node) {
180 DavResource *res = resource;
181 node = node->children;
182 while(node) {
183 if(node->type == XML_ELEMENT_NODE) {
184 if(xstreq(node->name, "href")) {
185 xmlNode *href_content = node->children;
186 if(href_content->type != XML_TEXT_NODE) {
187 // error
188 return 1;
189 }
190 if(xstreq(resource->href, href_content->content)) {
191 res = resource;
192 } else {
193 res = resource_new_href(resource->session, (char*)href_content->content);
194 resource_add_child(resource, res);
195 }
196 } else if(xstreq(node->name, "propstat")) {
197 xmlNode *n = node->children;
198 xmlNode *prop_node = NULL;
199 int ok = 0;
200 // get the status code
201 while(n) {
202 if(n->type == XML_ELEMENT_NODE) {
203 if(xstreq(n->name, "prop")) {
204 prop_node = n;
205 } else if(xstreq(n->name, "status")) {
206 xmlNode *status_node = n->children;
207 if(status_node->type != XML_TEXT_NODE) {
208 return 1;
209 }
210 sstr_t status_str = sstr((char*)status_node->content);
211 if(status_str.length < 13) {
212 return 1;
213 }
214 status_str = sstrsubsl(status_str, 9, 3);
215 if(!sstrcmp(status_str, S("200"))) {
216 ok = 1;
217 }
218 }
219 }
220 n = n->next;
221 }
222 // if status is ok, get all properties
223 if(ok) {
224 n = prop_node->children;
225 while(n) {
226 if(n->type == XML_ELEMENT_NODE) {
227 if(xstreq(n->name, "resourcetype")) {
228 xmlNode *rsnode = n->children;
229 if(rsnode && rsnode->type == XML_ELEMENT_NODE) {
230 // TODO: this is a ugly lazy hack
231 resource_add_property(res, "DAV:", (char*)n->name, "collection");
232 res->iscollection = 1;
233 }
234 } else {
235 xmlNode *content = n->children;
236 if(content) {
237 resource_add_property(
238 res,
239 (char*)n->ns->href,
240 (char*)n->name,
241 (char*)content->content);
242 }
243 }
244 }
245 n = n->next;
246 }
247 }
248 }
249 }
250
251 node = node->next;
252 }
253
254 set_davprops(res);
255
256 return 0;
257 }
258
259 void set_davprops(DavResource *res) {
260 char *cl = dav_get_property_ns(res, "DAV:", "getcontentlength");
261 char *ct = dav_get_property_ns(res, "DAV:", "getcontenttype");
262 char *cd = dav_get_property_ns(res, "DAV:", "creationdate");
263 char *lm = dav_get_property_ns(res, "DAV:", "getlastmodified");
264
265 res->contenttype = ct;
266 if(cl) {
267 char *end = NULL;
268 res->contentlength = strtoull(cl, &end, 0);
269 }
270 res->creationdate = util_parse_creationdate(cd);
271 res->lastmodified = util_parse_lastmodified(lm);
272 }
273
274
275 /* ----------------------------- PROPPATCH ----------------------------- */
276
277 CURLcode do_proppatch_request(
278 CURL *handle,
279 UcxBuffer *request,
280 UcxBuffer *response)
281 {
282 curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, "PROPPATCH");
283
284 struct curl_slist *headers = NULL;
285 headers = curl_slist_append(headers, "Content-Type: text/xml");
286 curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers);
287
288 curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0);
289
290 curl_easy_setopt(handle, CURLOPT_UPLOAD, 1);
291 curl_easy_setopt(handle, CURLOPT_READFUNCTION, ucx_buffer_read);
292 curl_easy_setopt(handle, CURLOPT_READDATA, request);
293 curl_easy_setopt(handle, CURLOPT_INFILESIZE, request->size);
294
295 curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, ucx_buffer_write);
296 curl_easy_setopt(handle, CURLOPT_WRITEDATA, response);
297
298 ucx_buffer_seek(request, 0, SEEK_SET);
299 return curl_easy_perform(handle);
300 }
301
302 UcxBuffer* create_proppatch_request(DavNodeData *data) {
303 UcxBuffer *buf = ucx_buffer_new(NULL, 512, 0);
304 sstr_t s;
305
306 UcxMap *namespaces = ucx_map_new(8);
307 char prefix[8];
308 int pfxnum = 0;
309 UCX_FOREACH(elm, data->set) {
310 DavProperty *p = elm->data;
311 if(strcmp(p->ns->name, "DAV:")) {
312 snprintf(prefix, 8, "x%d\0", pfxnum++);
313 ucx_map_cstr_put(namespaces, p->ns->name, prefix);
314 }
315 }
316 UCX_FOREACH(elm, data->remove) {
317 DavProperty *p = elm->data;
318 if(strcmp(p->ns->name, "DAV:")) {
319 snprintf(prefix, 8, "x%d\0", pfxnum++);
320 ucx_map_cstr_put(namespaces, p->ns->name, prefix);
321 }
322 }
323
324 s = S("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
325 ucx_buffer_write(s.ptr, 1, s.length, buf);
326
327 // write root element and namespaces
328 s = S("<D:propertyupdate xmlns:D=\"DAV:\"");
329 ucx_buffer_write(s.ptr, 1, s.length, buf);
330 UcxMapIterator mapi = ucx_map_iterator(namespaces);
331 UcxKey key;
332 char *pfxval;
333 UCX_MAP_FOREACH(key, pfxval, mapi) {
334 s = S(" xmlns:");
335 ucx_buffer_write(s.ptr, 1, s.length, buf);
336 s = sstr(pfxval);
337 ucx_buffer_write(s.ptr, 1, s.length, buf);
338 s = S("=\"");
339 ucx_buffer_write(s.ptr, 1, s.length, buf);
340 s = sstrn(key.data, key.len);
341 ucx_buffer_write(s.ptr, 1, s.length, buf);
342 s = S("\"");
343 ucx_buffer_write(s.ptr, 1, s.length, buf);
344 }
345 s = S(">\n");
346 ucx_buffer_write(s.ptr, 1, s.length, buf);
347
348 if(data->set) {
349 s = S("<D:set>\n<D:prop>\n");
350 ucx_buffer_write(s.ptr, 1, s.length, buf);
351 UCX_FOREACH(elm, data->set) {
352 DavProperty *property = elm->data;
353 char *prefix = ucx_map_cstr_get(namespaces, property->ns->name);
354
355 s = S("<");
356 ucx_buffer_write(s.ptr, 1, s.length, buf);
357 s = sstr(prefix);
358 ucx_buffer_write(s.ptr, 1, s.length, buf);
359 s = S(":");
360 ucx_buffer_write(s.ptr, 1, s.length, buf);
361 s = sstr(property->name);
362 ucx_buffer_write(s.ptr, 1, s.length, buf);
363 s = S(">");
364 ucx_buffer_write(s.ptr, 1, s.length, buf);
365 s = sstr(property->value);
366 ucx_buffer_write(s.ptr, 1, s.length, buf);
367 s = S("</");
368 ucx_buffer_write(s.ptr, 1, s.length, buf);
369 s = sstr(prefix);
370 ucx_buffer_write(s.ptr, 1, s.length, buf);
371 s = S(":");
372 ucx_buffer_write(s.ptr, 1, s.length, buf);
373 s = sstr(property->name);
374 ucx_buffer_write(s.ptr, 1, s.length, buf);
375 s = S(">\n");
376 ucx_buffer_write(s.ptr, 1, s.length, buf);
377 }
378 s = S("</D:prop>\n</D:set>\n");
379 ucx_buffer_write(s.ptr, 1, s.length, buf);
380 }
381 if(data->remove) {
382 s = S("<D:set>\n<D:prop>\n");
383 ucx_buffer_write(s.ptr, 1, s.length, buf);
384 UCX_FOREACH(elm, data->set) {
385 DavProperty *property = elm->data;
386 char *prefix = ucx_map_cstr_get(namespaces, property->ns->name);
387
388 s = S("<");
389 ucx_buffer_write(s.ptr, 1, s.length, buf);
390 s = sstr(prefix);
391 ucx_buffer_write(s.ptr, 1, s.length, buf);
392 s = S(":");
393 ucx_buffer_write(s.ptr, 1, s.length, buf);
394 s = sstr(property->name);
395 ucx_buffer_write(s.ptr, 1, s.length, buf);
396 s = S(">");
397 ucx_buffer_write(s.ptr, 1, s.length, buf);
398 s = sstr(property->value);
399 ucx_buffer_write(s.ptr, 1, s.length, buf);
400 s = S("</");
401 ucx_buffer_write(s.ptr, 1, s.length, buf);
402 s = sstr(prefix);
403 ucx_buffer_write(s.ptr, 1, s.length, buf);
404 s = S(":");
405 ucx_buffer_write(s.ptr, 1, s.length, buf);
406 s = sstr(property->name);
407 ucx_buffer_write(s.ptr, 1, s.length, buf);
408 s = S(">\n");
409 ucx_buffer_write(s.ptr, 1, s.length, buf);
410 }
411 s = S("</D:prop>\n</D:set>\n");
412 ucx_buffer_write(s.ptr, 1, s.length, buf);
413 }
414
415 s = S("</D:propertyupdate>\n");
416 ucx_buffer_write(s.ptr, 1, s.length, buf);
417
418 return buf;
419 }
420
421 /* ----------------------------- PUT ----------------------------- */
422
423 static size_t dummy_write(void *buf, size_t s, size_t n, void *data) {
424 return s*n;
425 }
426
427 CURLcode do_put_request(CURL *handle, void *data, dav_read_func read_func, size_t length) {
428 curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, NULL);
429 curl_easy_setopt(handle, CURLOPT_PUT, 1L);
430 curl_easy_setopt(handle, CURLOPT_UPLOAD, 1L);
431 curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0);
432
433 UcxBuffer *buf = NULL;
434 if(!read_func) {
435 buf = ucx_buffer_new(data, length, 0);
436 buf->size = length;
437 data = buf;
438 read_func = (dav_read_func)ucx_buffer_read;
439 curl_easy_setopt(handle, CURLOPT_INFILESIZE_LARGE, (curl_off_t)length);
440 } else if(length == 0) {
441 struct curl_slist *headers = NULL;
442 headers = curl_slist_append(headers, "Transfer-Encoding: chunked");
443 curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers);
444 }
445
446 curl_easy_setopt(handle, CURLOPT_READFUNCTION, read_func);
447 curl_easy_setopt(handle, CURLOPT_READDATA, data);
448
449 curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, dummy_write);
450 curl_easy_setopt(handle, CURLOPT_WRITEDATA, NULL);
451
452 CURLcode res = curl_easy_perform(handle);
453 if(buf) {
454 ucx_buffer_free(buf);
455 }
456 return res;
457 }
458

Mercurial Repository: dav

mercurial