| 82 | 82 |
#include <libxml/uri.h>
|
| 83 | 83 |
|
| 84 | 84 |
|
|
85 |
/* Bitmask of property flags */
|
|
86 |
enum {
|
|
87 |
PROP_ALLPROP = (1<<0), /* Returned in <allprop> request */
|
|
88 |
PROP_ROOT = (1<<1), /* Returnd for root (/) */
|
|
89 |
PROP_PRINCIPAL = (1<<2), /* Returned for principal */
|
|
90 |
PROP_COLLECTION = (1<<3), /* Returned for collection */
|
|
91 |
PROP_RESOURCE = (1<<4), /* Returned for resource */
|
|
92 |
PROP_CALENDAR = (1<<5), /* Returned for calendar only */
|
|
93 |
PROP_ADDRESSBOOK = (1<<6) /* Returned for addressbook only */
|
|
94 |
};
|
|
95 |
|
|
96 |
static const struct dav_namespace_t {
|
|
97 |
const char *href;
|
|
98 |
const char *prefix;
|
|
99 |
} known_namespaces[] = {
|
|
100 |
{ XML_NS_DAV, "D" },
|
|
101 |
{ XML_NS_CALDAV, "C" },
|
|
102 |
{ XML_NS_CARDDAV, "C" },
|
|
103 |
{ XML_NS_ISCHED, NULL },
|
|
104 |
{ XML_NS_CS, "CS" },
|
|
105 |
{ XML_NS_CYRUS, "CY" },
|
|
106 |
};
|
|
107 |
|
|
108 |
/* PROPFIND modes */
|
|
109 |
enum {
|
|
110 |
PROPFIND_NONE = 0, /* only used with REPORT */
|
|
111 |
PROPFIND_ALL,
|
|
112 |
PROPFIND_NAME,
|
|
113 |
PROPFIND_PROP
|
|
114 |
};
|
|
115 |
|
| 85 | 116 |
static void my_dav_init(struct buf *serverinfo);
|
| 86 | 117 |
|
| 87 | 118 |
static int prin_parse_path(const char *path,
|
| 88 | 119 |
struct request_target_t *tgt, const char **errstr);
|
|
120 |
|
|
121 |
static int allprop_cb(const char *mailbox __attribute__((unused)),
|
|
122 |
const char *entry,
|
|
123 |
const char *userid, struct annotation_data *attrib,
|
|
124 |
void *rock);
|
| 89 | 125 |
|
| 90 | 126 |
static struct meth_params princ_params = {
|
| 91 | 127 |
.parse_path = &prin_parse_path
|
|
| 161 | 197 |
|
| 162 | 198 |
/* Linked-list of properties for fetching */
|
| 163 | 199 |
struct propfind_entry_list {
|
| 164 | |
xmlNodePtr prop; /* Property */
|
| 165 | |
int (*get)(xmlNodePtr node, /* Callback to fetch property */
|
| 166 | |
struct propfind_ctx *fctx, xmlNodePtr resp,
|
|
200 |
const xmlChar *name; /* Property name */
|
|
201 |
xmlNsPtr ns; /* Property namespace */
|
|
202 |
unsigned char flags; /* Flags for how/where prop apply */
|
|
203 |
int (*get)(const xmlChar *name, /* Callback to fetch property */
|
|
204 |
xmlNsPtr ns, struct propfind_ctx *fctx, xmlNodePtr resp,
|
| 167 | 205 |
struct propstat propstat[], void *rock);
|
| 168 | 206 |
void *rock; /* Add'l data to pass to callback */
|
| 169 | 207 |
struct propfind_entry_list *next;
|
|
| 178 | 216 |
xmlNodePtr root; /* root node to add to XML tree */
|
| 179 | 217 |
xmlNsPtr *ns; /* Array of our supported namespaces */
|
| 180 | 218 |
struct txn *tid; /* Transaction ID for annot writes */
|
| 181 | |
const char **errstr; /* Error string to pass up to caller */
|
|
219 |
struct error_t *err; /* Error info to pass up to caller */
|
| 182 | 220 |
int *ret; /* Return code to pass up to caller */
|
| 183 | 221 |
struct buf buf; /* Working buffer */
|
| 184 | 222 |
};
|
|
| 192 | 230 |
{ "VTODO", CAL_COMP_VTODO },
|
| 193 | 231 |
{ "VJOURNAL", CAL_COMP_VJOURNAL },
|
| 194 | 232 |
{ "VFREEBUSY", CAL_COMP_VFREEBUSY },
|
| 195 | |
{ "VTIMEZONE", CAL_COMP_VTIMEZONE },
|
| 196 | |
{ "VALARM", CAL_COMP_VALARM },
|
|
233 |
// { "VTIMEZONE", CAL_COMP_VTIMEZONE },
|
|
234 |
// { "VALARM", CAL_COMP_VALARM },
|
| 197 | 235 |
{ NULL, 0 }
|
| 198 | 236 |
};
|
| 199 | 237 |
|
|
| 417 | 455 |
ensure_ns(respNs, NS_CYRUS, root,
|
| 418 | 456 |
(const char *) nsDef->href,
|
| 419 | 457 |
(const char *) nsDef->prefix);
|
| 420 | |
else if (!xmlStrcmp(nsDef->href, BAD_CAST XML_NS_ICAL))
|
| 421 | |
ensure_ns(respNs, NS_ICAL, root,
|
| 422 | |
(const char *) nsDef->href,
|
| 423 | |
(const char *) nsDef->prefix);
|
| 424 | 458 |
else
|
| 425 | 459 |
xmlNewNs(root, nsDef->href, nsDef->prefix);
|
| 426 | 460 |
}
|
|
| 454 | 488 |
xml_add_ns(req, respNs, root);
|
| 455 | 489 |
|
| 456 | 490 |
/* Set namespace of root node */
|
| 457 | |
switch (ns) {
|
| 458 | |
case NS_ISCHED:
|
| 459 | |
ensure_ns(respNs, NS_ISCHED, root, XML_NS_ISCHED, NULL);
|
| 460 | |
break;
|
| 461 | |
|
| 462 | |
case NS_CALDAV:
|
| 463 | |
ensure_ns(respNs, NS_CALDAV, root, XML_NS_CALDAV, "C");
|
| 464 | |
|
| 465 | |
default:
|
| 466 | |
ensure_ns(respNs, NS_DAV, root, XML_NS_DAV, "D");
|
| 467 | |
}
|
|
491 |
ensure_ns(respNs, ns, root,
|
|
492 |
known_namespaces[ns].href, known_namespaces[ns].prefix);
|
| 468 | 493 |
xmlSetNs(root, respNs[ns]);
|
| 469 | 494 |
|
| 470 | 495 |
return root;
|
|
| 500 | 525 |
}
|
| 501 | 526 |
else error = xmlNewChild(root, NULL, BAD_CAST "error", NULL);
|
| 502 | 527 |
|
| 503 | |
switch (precond->ns) {
|
| 504 | |
case NS_CALDAV:
|
| 505 | |
ensure_ns(avail_ns, NS_CALDAV, root, XML_NS_CALDAV, "C");
|
| 506 | |
break;
|
| 507 | |
|
| 508 | |
case NS_CARDDAV:
|
| 509 | |
ensure_ns(avail_ns, NS_CARDDAV, root, XML_NS_CARDDAV, "C");
|
| 510 | |
break;
|
| 511 | |
}
|
|
528 |
ensure_ns(avail_ns, precond->ns, root, known_namespaces[precond->ns].href,
|
|
529 |
known_namespaces[precond->ns].prefix);
|
| 512 | 530 |
node = xmlNewChild(error, avail_ns[precond->ns],
|
| 513 | 531 |
BAD_CAST precond->name, NULL);
|
| 514 | 532 |
|
|
| 591 | 609 |
*/
|
| 592 | 610 |
static xmlNodePtr xml_add_prop(long status, xmlNsPtr davns,
|
| 593 | 611 |
struct propstat *propstat,
|
| 594 | |
xmlNodePtr prop, xmlChar *content,
|
|
612 |
const xmlChar *name, xmlNsPtr ns,
|
|
613 |
xmlChar *content,
|
| 595 | 614 |
unsigned precond)
|
| 596 | 615 |
{
|
| 597 | 616 |
xmlNodePtr newprop = NULL;
|
|
| 601 | 620 |
xmlNewChild(propstat->root, NULL, BAD_CAST "prop", NULL);
|
| 602 | 621 |
}
|
| 603 | 622 |
|
| 604 | |
if (prop) newprop = xmlNewTextChild(propstat->root->children,
|
| 605 | |
prop->ns, prop->name, content);
|
|
623 |
if (name) newprop = xmlNewTextChild(propstat->root->children,
|
|
624 |
ns, name, content);
|
| 606 | 625 |
propstat->status = status;
|
| 607 | 626 |
propstat->precond = precond;
|
| 608 | 627 |
|
| 609 | 628 |
return newprop;
|
| 610 | 629 |
}
|
| 611 | 630 |
|
|
631 |
|
|
632 |
struct allprop_rock {
|
|
633 |
struct propfind_ctx *fctx;
|
|
634 |
struct propstat *propstat;
|
|
635 |
};
|
| 612 | 636 |
|
| 613 | 637 |
/* Add a response tree to 'root' for the specified href and
|
| 614 | 638 |
either error code or property list */
|
|
| 618 | 642 |
|
| 619 | 643 |
resp = xmlNewChild(fctx->root, NULL, BAD_CAST "response", NULL);
|
| 620 | 644 |
if (!resp) {
|
| 621 | |
*fctx->errstr = "Unable to add response XML element";
|
|
645 |
fctx->err->desc = "Unable to add response XML element";
|
| 622 | 646 |
*fctx->ret = HTTP_SERVER_ERROR;
|
| 623 | 647 |
return HTTP_SERVER_ERROR;
|
| 624 | 648 |
}
|
|
| 637 | 661 |
|
| 638 | 662 |
/* Process each property in the linked list */
|
| 639 | 663 |
for (e = fctx->elist; e; e = e->next) {
|
|
664 |
int r = HTTP_NOT_FOUND;
|
|
665 |
|
| 640 | 666 |
if (e->get) {
|
| 641 | |
e->get(e->prop, fctx, resp, propstat, e->rock);
|
|
667 |
r = 0;
|
|
668 |
|
|
669 |
/* Pre-screen request based on prop flags */
|
|
670 |
switch (fctx->req_tgt->namespace) {
|
|
671 |
case URL_NS_CALENDAR:
|
|
672 |
case URL_NS_ADDRESSBOOK:
|
|
673 |
if (fctx->req_tgt->resource) {
|
|
674 |
if (!(e->flags & PROP_RESOURCE)) r = HTTP_NOT_FOUND;
|
|
675 |
}
|
|
676 |
else if (!(e->flags & PROP_COLLECTION)) r = HTTP_NOT_FOUND;
|
|
677 |
break;
|
|
678 |
}
|
|
679 |
|
|
680 |
if (!r) {
|
|
681 |
if (fctx->mode == PROPFIND_NAME) {
|
|
682 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
|
683 |
&propstat[PROPSTAT_OK],
|
|
684 |
e->name, e->ns, NULL, 0);
|
|
685 |
}
|
|
686 |
else {
|
|
687 |
r = e->get(e->name, e->ns,
|
|
688 |
fctx, resp, propstat, e->rock);
|
|
689 |
}
|
|
690 |
}
|
| 642 | 691 |
}
|
| 643 | |
else if (!(fctx->prefer & PREFER_MIN)) {
|
| 644 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 645 | |
&propstat[PROPSTAT_NOTFOUND], e->prop, NULL, 0);
|
|
692 |
|
|
693 |
switch (r) {
|
|
694 |
case 0:
|
|
695 |
case HTTP_OK:
|
|
696 |
/* Nothing to do - property handled in callback */
|
|
697 |
break;
|
|
698 |
|
|
699 |
case HTTP_UNAUTHORIZED:
|
|
700 |
xml_add_prop(HTTP_UNAUTHORIZED, fctx->ns[NS_DAV],
|
|
701 |
&propstat[PROPSTAT_UNAUTH],
|
|
702 |
e->name, e->ns, NULL, 0);
|
|
703 |
break;
|
|
704 |
|
|
705 |
case HTTP_FORBIDDEN:
|
|
706 |
xml_add_prop(HTTP_FORBIDDEN, fctx->ns[NS_DAV],
|
|
707 |
&propstat[PROPSTAT_FORBID],
|
|
708 |
e->name, e->ns, NULL, 0);
|
|
709 |
break;
|
|
710 |
|
|
711 |
case HTTP_NOT_FOUND:
|
|
712 |
if (!(fctx->prefer & PREFER_MIN)) {
|
|
713 |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
|
714 |
&propstat[PROPSTAT_NOTFOUND],
|
|
715 |
e->name, e->ns, NULL, 0);
|
|
716 |
}
|
|
717 |
break;
|
|
718 |
|
|
719 |
default:
|
|
720 |
xml_add_prop(r, fctx->ns[NS_DAV], &propstat[PROPSTAT_ERROR],
|
|
721 |
e->name, e->ns, NULL, 0);
|
|
722 |
break;
|
|
723 |
|
| 646 | 724 |
}
|
| 647 | 725 |
}
|
| 648 | 726 |
|
| 649 | |
/* Remove propstat 404 element if using return-minimal */
|
| 650 | |
stat = &propstat[PROPSTAT_NOTFOUND];
|
| 651 | |
if (stat->root && (fctx->prefer & PREFER_MIN)) {
|
| 652 | |
xmlFreeNode(stat->root);
|
| 653 | |
stat->root = NULL;
|
|
727 |
/* Process dead properties for allprop/propname */
|
|
728 |
if (fctx->mailbox && !fctx->req_tgt->resource &&
|
|
729 |
(fctx->mode == PROPFIND_ALL || fctx->mode == PROPFIND_NAME)) {
|
|
730 |
struct allprop_rock arock = { fctx, propstat };
|
|
731 |
|
|
732 |
annotatemore_findall(fctx->mailbox->name, ANNOT_NS "*",
|
|
733 |
allprop_cb, &arock, NULL);
|
| 654 | 734 |
}
|
| 655 | 735 |
|
| 656 | 736 |
/* Check if we have any propstat elements */
|
|
| 658 | 738 |
if (i == NUM_PROPSTAT) {
|
| 659 | 739 |
/* Add an empty propstat 200 */
|
| 660 | 740 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
| 661 | |
&propstat[PROPSTAT_OK], NULL, NULL, 0);
|
|
741 |
&propstat[PROPSTAT_OK], NULL, NULL, NULL, 0);
|
| 662 | 742 |
}
|
| 663 | 743 |
|
| 664 | 744 |
/* Add status and optional error to the propstat elements
|
|
| 686 | 766 |
|
| 687 | 767 |
|
| 688 | 768 |
/* Callback to fetch DAV:creationdate */
|
| 689 | |
static int propfind_creationdate(xmlNodePtr prop,
|
|
769 |
static int propfind_creationdate(const xmlChar *name, xmlNsPtr ns,
|
| 690 | 770 |
struct propfind_ctx *fctx,
|
| 691 | 771 |
xmlNodePtr resp __attribute__((unused)),
|
| 692 | 772 |
struct propstat propstat[],
|
| 693 | 773 |
void *rock __attribute__((unused)))
|
| 694 | 774 |
{
|
| 695 | 775 |
time_t t = 0;
|
|
776 |
struct tm *tm;
|
| 696 | 777 |
|
| 697 | 778 |
if (fctx->data) {
|
| 698 | 779 |
struct dav_data *ddata = (struct dav_data *) fctx->data;
|
|
| 707 | 788 |
t = sbuf.st_ctime;
|
| 708 | 789 |
}
|
| 709 | 790 |
|
| 710 | |
if (t) {
|
| 711 | |
struct tm *tm = gmtime(&t);
|
| 712 | |
|
| 713 | |
buf_reset(&fctx->buf);
|
| 714 | |
buf_printf(&fctx->buf, "%4d-%02d-%02dT%02d:%02d:%02dZ",
|
| 715 | |
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
|
| 716 | |
tm->tm_hour, tm->tm_min, tm->tm_sec);
|
| 717 | |
|
| 718 | |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 719 | |
prop, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 720 | |
|
| 721 | |
}
|
| 722 | |
else {
|
| 723 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 724 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 725 | |
}
|
|
791 |
if (!t) return HTTP_NOT_FOUND;
|
|
792 |
|
|
793 |
tm = gmtime(&t);
|
|
794 |
|
|
795 |
buf_reset(&fctx->buf);
|
|
796 |
buf_printf(&fctx->buf, "%4d-%02d-%02dT%02d:%02d:%02dZ",
|
|
797 |
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
|
|
798 |
tm->tm_hour, tm->tm_min, tm->tm_sec);
|
|
799 |
|
|
800 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
801 |
name, ns, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 726 | 802 |
|
| 727 | 803 |
return 0;
|
| 728 | 804 |
}
|
| 729 | 805 |
|
| 730 | 806 |
|
|
807 |
/* Callback to fetch DAV:getcontenttype */
|
|
808 |
static int propfind_getcontenttype(const xmlChar *name, xmlNsPtr ns,
|
|
809 |
struct propfind_ctx *fctx,
|
|
810 |
xmlNodePtr resp __attribute__((unused)),
|
|
811 |
struct propstat propstat[],
|
|
812 |
void *rock __attribute__((unused)))
|
|
813 |
{
|
|
814 |
buf_reset(&fctx->buf);
|
|
815 |
|
|
816 |
switch (fctx->req_tgt->namespace) {
|
|
817 |
case URL_NS_CALENDAR:
|
|
818 |
buf_setcstr(&fctx->buf, "text/calendar; charset=utf-8");
|
|
819 |
break;
|
|
820 |
|
|
821 |
case URL_NS_ADDRESSBOOK:
|
|
822 |
buf_setcstr(&fctx->buf, "text/vcard; charset=utf-8");
|
|
823 |
break;
|
|
824 |
|
|
825 |
default:
|
|
826 |
return HTTP_NOT_FOUND;
|
|
827 |
}
|
|
828 |
|
|
829 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
830 |
name, ns, BAD_CAST buf_cstring(&fctx->buf), 0);
|
|
831 |
|
|
832 |
return 0;
|
|
833 |
}
|
|
834 |
|
|
835 |
|
| 731 | 836 |
/* Callback to fetch DAV:getcontentlength */
|
| 732 | |
static int propfind_getlength(xmlNodePtr prop,
|
|
837 |
static int propfind_getlength(const xmlChar *name, xmlNsPtr ns,
|
| 733 | 838 |
struct propfind_ctx *fctx,
|
| 734 | 839 |
xmlNodePtr resp __attribute__((unused)),
|
| 735 | 840 |
struct propstat propstat[],
|
|
| 737 | 842 |
{
|
| 738 | 843 |
uint32_t len = 0;
|
| 739 | 844 |
|
| 740 | |
if (fctx->record) len = fctx->record->size - fctx->record->header_size;
|
|
845 |
if (!fctx->record) return HTTP_NOT_FOUND;
|
|
846 |
|
|
847 |
len = fctx->record->size - fctx->record->header_size;
|
| 741 | 848 |
|
| 742 | 849 |
buf_reset(&fctx->buf);
|
| 743 | 850 |
buf_printf(&fctx->buf, "%u", len);
|
| 744 | 851 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 745 | |
prop, BAD_CAST buf_cstring(&fctx->buf), 0);
|
|
852 |
name, ns, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 746 | 853 |
|
| 747 | 854 |
return 0;
|
| 748 | 855 |
}
|
| 749 | 856 |
|
| 750 | 857 |
|
| 751 | 858 |
/* Callback to fetch DAV:getetag */
|
| 752 | |
static int propfind_getetag(xmlNodePtr prop,
|
|
859 |
static int propfind_getetag(const xmlChar *name, xmlNsPtr ns,
|
| 753 | 860 |
struct propfind_ctx *fctx,
|
| 754 | 861 |
xmlNodePtr resp __attribute__((unused)),
|
| 755 | 862 |
struct propstat propstat[],
|
| 756 | 863 |
void *rock __attribute__((unused)))
|
| 757 | 864 |
{
|
|
865 |
if (fctx->req_tgt->resource && !fctx->record) return HTTP_NOT_FOUND;
|
|
866 |
if (!fctx->mailbox) return HTTP_NOT_FOUND;
|
|
867 |
|
|
868 |
buf_reset(&fctx->buf);
|
|
869 |
|
| 758 | 870 |
if (fctx->record) {
|
| 759 | 871 |
/* add DQUOTEs */
|
| 760 | |
buf_reset(&fctx->buf);
|
| 761 | 872 |
buf_printf(&fctx->buf, "\"%s\"",
|
| 762 | 873 |
message_guid_encode(&fctx->record->guid));
|
| 763 | |
|
| 764 | |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 765 | |
prop, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 766 | 874 |
}
|
| 767 | 875 |
else {
|
| 768 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 769 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 770 | |
}
|
|
876 |
buf_printf(&fctx->buf, "\"%u-%u-%u\"", fctx->mailbox->i.uidvalidity,
|
|
877 |
fctx->mailbox->i.last_uid, fctx->mailbox->i.exists);
|
|
878 |
}
|
|
879 |
|
|
880 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
881 |
name, ns, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 771 | 882 |
|
| 772 | 883 |
return 0;
|
| 773 | 884 |
}
|
| 774 | 885 |
|
| 775 | 886 |
|
| 776 | 887 |
/* Callback to fetch DAV:getlastmodified */
|
| 777 | |
static int propfind_getlastmod(xmlNodePtr prop,
|
|
888 |
static int propfind_getlastmod(const xmlChar *name, xmlNsPtr ns,
|
| 778 | 889 |
struct propfind_ctx *fctx,
|
| 779 | 890 |
xmlNodePtr resp __attribute__((unused)),
|
| 780 | 891 |
struct propstat propstat[],
|
| 781 | 892 |
void *rock __attribute__((unused)))
|
| 782 | 893 |
{
|
| 783 | |
if (fctx->record) {
|
| 784 | |
buf_ensure(&fctx->buf, 30);
|
| 785 | |
httpdate_gen(fctx->buf.s, fctx->buf.alloc,
|
| 786 | |
fctx->record->internaldate);
|
| 787 | |
|
| 788 | |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 789 | |
prop, BAD_CAST fctx->buf.s, 0);
|
| 790 | |
}
|
| 791 | |
else {
|
| 792 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 793 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 794 | |
}
|
|
894 |
if (!fctx->record) return HTTP_NOT_FOUND;
|
|
895 |
|
|
896 |
buf_ensure(&fctx->buf, 30);
|
|
897 |
httpdate_gen(fctx->buf.s, fctx->buf.alloc,
|
|
898 |
fctx->record->internaldate);
|
|
899 |
|
|
900 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
901 |
name, ns, BAD_CAST fctx->buf.s, 0);
|
| 795 | 902 |
|
| 796 | 903 |
return 0;
|
| 797 | 904 |
}
|
| 798 | 905 |
|
| 799 | 906 |
|
| 800 | 907 |
/* Callback to fetch DAV:lockdiscovery */
|
| 801 | |
static int propfind_lockdisc(xmlNodePtr prop,
|
|
908 |
static int propfind_lockdisc(const xmlChar *name, xmlNsPtr ns,
|
| 802 | 909 |
struct propfind_ctx *fctx,
|
| 803 | 910 |
xmlNodePtr resp __attribute__((unused)),
|
| 804 | 911 |
struct propstat propstat[],
|
| 805 | 912 |
void *rock __attribute__((unused)))
|
| 806 | 913 |
{
|
| 807 | 914 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
| 808 | |
&propstat[PROPSTAT_OK], prop, NULL, 0);
|
|
915 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
| 809 | 916 |
|
| 810 | 917 |
if (fctx->mailbox && fctx->record) {
|
| 811 | 918 |
struct dav_data *ddata = (struct dav_data *) fctx->data;
|
|
| 818 | 925 |
|
| 819 | 926 |
|
| 820 | 927 |
/* Callback to fetch DAV:resourcetype */
|
| 821 | |
static int propfind_restype(xmlNodePtr prop,
|
|
928 |
static int propfind_restype(const xmlChar *name, xmlNsPtr ns,
|
| 822 | 929 |
struct propfind_ctx *fctx,
|
| 823 | 930 |
xmlNodePtr resp,
|
| 824 | 931 |
struct propstat propstat[],
|
| 825 | 932 |
void *rock __attribute__((unused)))
|
| 826 | 933 |
{
|
| 827 | 934 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
| 828 | |
&propstat[PROPSTAT_OK], prop, NULL, 0);
|
|
935 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
| 829 | 936 |
|
| 830 | 937 |
if ((fctx->req_tgt->namespace != URL_NS_DEFAULT) && !fctx->record) {
|
| 831 | 938 |
xmlNewChild(node, NULL, BAD_CAST "collection", NULL);
|
|
| 892 | 999 |
if (!cur) {
|
| 893 | 1000 |
/* All resourcetypes are valid */
|
| 894 | 1001 |
xml_add_prop(HTTP_OK, pctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 895 | |
prop, NULL, 0);
|
|
1002 |
prop->name, prop->ns, NULL, 0);
|
| 896 | 1003 |
|
| 897 | 1004 |
return 0;
|
| 898 | 1005 |
}
|
|
| 906 | 1013 |
}
|
| 907 | 1014 |
|
| 908 | 1015 |
xml_add_prop(HTTP_FORBIDDEN, pctx->ns[NS_DAV], &propstat[PROPSTAT_FORBID],
|
| 909 | |
prop, NULL, precond);
|
|
1016 |
prop->name, prop->ns, NULL, precond);
|
| 910 | 1017 |
|
| 911 | 1018 |
*pctx->ret = HTTP_FORBIDDEN;
|
| 912 | 1019 |
|
|
| 915 | 1022 |
|
| 916 | 1023 |
|
| 917 | 1024 |
/* Callback to fetch DAV:supportedlock */
|
| 918 | |
static int propfind_suplock(xmlNodePtr prop,
|
|
1025 |
static int propfind_suplock(const xmlChar *name, xmlNsPtr ns,
|
| 919 | 1026 |
struct propfind_ctx *fctx,
|
| 920 | 1027 |
xmlNodePtr resp __attribute__((unused)),
|
| 921 | 1028 |
struct propstat propstat[],
|
| 922 | 1029 |
void *rock __attribute__((unused)))
|
| 923 | 1030 |
{
|
| 924 | 1031 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
| 925 | |
&propstat[PROPSTAT_OK], prop, NULL, 0);
|
|
1032 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
| 926 | 1033 |
|
| 927 | 1034 |
if (fctx->mailbox && fctx->record) {
|
| 928 | 1035 |
xmlNodePtr entry = xmlNewChild(node, NULL, BAD_CAST "lockentry", NULL);
|
|
| 938 | 1045 |
|
| 939 | 1046 |
|
| 940 | 1047 |
/* Callback to fetch DAV:supported-report-set */
|
| 941 | |
static int propfind_reportset(xmlNodePtr prop,
|
|
1048 |
static int propfind_reportset(const xmlChar *name, xmlNsPtr ns,
|
| 942 | 1049 |
struct propfind_ctx *fctx,
|
| 943 | 1050 |
xmlNodePtr resp,
|
| 944 | 1051 |
struct propstat propstat[],
|
|
| 947 | 1054 |
xmlNodePtr s, r, top;
|
| 948 | 1055 |
|
| 949 | 1056 |
top = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 950 | |
prop, NULL, 0);
|
|
1057 |
name, ns, NULL, 0);
|
| 951 | 1058 |
|
| 952 | 1059 |
if ((fctx->req_tgt->namespace == URL_NS_CALENDAR ||
|
| 953 | 1060 |
fctx->req_tgt->namespace == URL_NS_ADDRESSBOOK) &&
|
| 954 | 1061 |
fctx->req_tgt->collection && !fctx->req_tgt->resource) {
|
| 955 | 1062 |
s = xmlNewChild(top, NULL, BAD_CAST "supported-report", NULL);
|
| 956 | 1063 |
r = xmlNewChild(s, NULL, BAD_CAST "report", NULL);
|
| 957 | |
ensure_ns(fctx->ns, NS_DAV, resp->parent, XML_NS_DAV, "D");
|
| 958 | 1064 |
xmlNewChild(r, fctx->ns[NS_DAV], BAD_CAST "sync-collection", NULL);
|
| 959 | 1065 |
}
|
| 960 | 1066 |
|
| 961 | 1067 |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR) {
|
|
1068 |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
|
1069 |
|
| 962 | 1070 |
s = xmlNewChild(top, NULL, BAD_CAST "supported-report", NULL);
|
| 963 | 1071 |
r = xmlNewChild(s, NULL, BAD_CAST "report", NULL);
|
| 964 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 965 | 1072 |
xmlNewChild(r, fctx->ns[NS_CALDAV], BAD_CAST "calendar-query", NULL);
|
| 966 | 1073 |
|
| 967 | 1074 |
s = xmlNewChild(top, NULL, BAD_CAST "supported-report", NULL);
|
| 968 | 1075 |
r = xmlNewChild(s, NULL, BAD_CAST "report", NULL);
|
| 969 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 970 | 1076 |
xmlNewChild(r, fctx->ns[NS_CALDAV], BAD_CAST "calendar-multiget", NULL);
|
| 971 | 1077 |
|
| 972 | 1078 |
s = xmlNewChild(top, NULL, BAD_CAST "supported-report", NULL);
|
| 973 | 1079 |
r = xmlNewChild(s, NULL, BAD_CAST "report", NULL);
|
| 974 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 975 | 1080 |
xmlNewChild(r, fctx->ns[NS_CALDAV], BAD_CAST "free-busy-query", NULL);
|
| 976 | 1081 |
}
|
| 977 | 1082 |
|
| 978 | 1083 |
else if (fctx->req_tgt->namespace == URL_NS_ADDRESSBOOK) {
|
|
1084 |
ensure_ns(fctx->ns, NS_CARDDAV, resp->parent, XML_NS_CARDDAV, "C");
|
|
1085 |
|
| 979 | 1086 |
s = xmlNewChild(top, NULL, BAD_CAST "supported-report", NULL);
|
| 980 | 1087 |
r = xmlNewChild(s, NULL, BAD_CAST "report", NULL);
|
| 981 | |
ensure_ns(fctx->ns, NS_CARDDAV, resp->parent, XML_NS_CARDDAV, "C");
|
| 982 | 1088 |
xmlNewChild(r, fctx->ns[NS_CARDDAV], BAD_CAST "addressbook-query", NULL);
|
| 983 | 1089 |
|
| 984 | 1090 |
s = xmlNewChild(top, NULL, BAD_CAST "supported-report", NULL);
|
| 985 | 1091 |
r = xmlNewChild(s, NULL, BAD_CAST "report", NULL);
|
| 986 | |
ensure_ns(fctx->ns, NS_CARDDAV, resp->parent, XML_NS_CARDDAV, "C");
|
| 987 | 1092 |
xmlNewChild(r, fctx->ns[NS_CARDDAV], BAD_CAST "addressbook-multiget", NULL);
|
| 988 | 1093 |
}
|
| 989 | 1094 |
|
|
| 992 | 1097 |
|
| 993 | 1098 |
|
| 994 | 1099 |
/* Callback to fetch DAV:principalurl */
|
| 995 | |
static int propfind_principalurl(xmlNodePtr prop,
|
|
1100 |
static int propfind_principalurl(const xmlChar *name, xmlNsPtr ns,
|
| 996 | 1101 |
struct propfind_ctx *fctx,
|
| 997 | 1102 |
xmlNodePtr resp __attribute__((unused)),
|
| 998 | 1103 |
struct propstat propstat[],
|
| 999 | 1104 |
void *rock __attribute__((unused)))
|
| 1000 | 1105 |
{
|
| 1001 | |
xmlNodePtr node;
|
| 1002 | |
|
| 1003 | |
if (fctx->req_tgt->namespace != URL_NS_PRINCIPAL) {
|
| 1004 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1005 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1006 | |
}
|
| 1007 | |
else {
|
| 1008 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1009 | |
prop, NULL, 0);
|
| 1010 | |
|
| 1011 | |
buf_reset(&fctx->buf);
|
| 1012 | |
if (fctx->req_tgt->user) {
|
| 1013 | |
buf_printf(&fctx->buf, "%s/user/%.*s/",
|
| 1014 | |
namespace_principal.prefix,
|
| 1015 | |
(int) fctx->req_tgt->userlen, fctx->req_tgt->user);
|
| 1016 | |
}
|
| 1017 | |
|
| 1018 | |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
| 1019 | |
}
|
|
1106 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
|
1107 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
|
1108 |
|
|
1109 |
buf_reset(&fctx->buf);
|
|
1110 |
if (fctx->req_tgt->user) {
|
|
1111 |
buf_printf(&fctx->buf, "%s/user/%.*s/",
|
|
1112 |
namespace_principal.prefix,
|
|
1113 |
(int) fctx->req_tgt->userlen, fctx->req_tgt->user);
|
|
1114 |
}
|
|
1115 |
|
|
1116 |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
| 1020 | 1117 |
|
| 1021 | 1118 |
return 0;
|
| 1022 | 1119 |
}
|
| 1023 | 1120 |
|
| 1024 | 1121 |
|
| 1025 | 1122 |
/* Callback to fetch DAV:owner */
|
| 1026 | |
static int propfind_owner(xmlNodePtr prop,
|
|
1123 |
static int propfind_owner(const xmlChar *name, xmlNsPtr ns,
|
| 1027 | 1124 |
struct propfind_ctx *fctx,
|
| 1028 | 1125 |
xmlNodePtr resp __attribute__((unused)),
|
| 1029 | 1126 |
struct propstat propstat[],
|
| 1030 | 1127 |
void *rock __attribute__((unused)))
|
| 1031 | 1128 |
{
|
| 1032 | |
xmlNodePtr node;
|
| 1033 | |
|
| 1034 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1035 | |
prop, NULL, 0);
|
| 1036 | |
|
| 1037 | |
if ((fctx->req_tgt->namespace == URL_NS_CALENDAR ||
|
| 1038 | |
fctx->req_tgt->namespace == URL_NS_ADDRESSBOOK) &&
|
| 1039 | |
fctx->req_tgt->user) {
|
|
1129 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
|
1130 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
|
1131 |
|
|
1132 |
if (fctx->req_tgt->user) {
|
| 1040 | 1133 |
buf_reset(&fctx->buf);
|
| 1041 | 1134 |
buf_printf(&fctx->buf, "%s/user/%.*s/",
|
| 1042 | 1135 |
namespace_principal.prefix,
|
|
| 1070 | 1163 |
|
| 1071 | 1164 |
|
| 1072 | 1165 |
/* Callback to fetch DAV:supported-privilege-set */
|
| 1073 | |
static int propfind_supprivset(xmlNodePtr prop,
|
|
1166 |
static int propfind_supprivset(const xmlChar *name, xmlNsPtr ns,
|
| 1074 | 1167 |
struct propfind_ctx *fctx,
|
| 1075 | 1168 |
xmlNodePtr resp,
|
| 1076 | 1169 |
struct propstat propstat[],
|
| 1077 | 1170 |
void *rock __attribute__((unused)))
|
| 1078 | 1171 |
{
|
| 1079 | 1172 |
xmlNodePtr set, all, agg, write;
|
|
1173 |
unsigned tgt_flags = 0;
|
| 1080 | 1174 |
|
| 1081 | 1175 |
set = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1082 | |
prop, NULL, 0);
|
|
1176 |
name, ns, NULL, 0);
|
| 1083 | 1177 |
|
| 1084 | 1178 |
all = add_suppriv(set, "all", NULL, 0, "Any operation");
|
| 1085 | 1179 |
|
|
| 1087 | 1181 |
add_suppriv(agg, "read-current-user-privilege-set", NULL, 1,
|
| 1088 | 1182 |
"Read current user privilege set");
|
| 1089 | 1183 |
|
| 1090 | |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR &&
|
| 1091 | |
!(fctx->req_tgt->collection &&
|
| 1092 | |
(!strcmp(fctx->req_tgt->collection, SCHED_INBOX) ||
|
| 1093 | |
!strcmp(fctx->req_tgt->collection, SCHED_OUTBOX)))) {
|
| 1094 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 1095 | |
add_suppriv(agg, "read-free-busy", fctx->ns[NS_CALDAV], 0,
|
| 1096 | |
"Read free/busy time");
|
|
1184 |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR) {
|
|
1185 |
if (fctx->req_tgt->collection) {
|
|
1186 |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
|
1187 |
|
|
1188 |
if (!strcmp(fctx->req_tgt->collection, SCHED_INBOX))
|
|
1189 |
tgt_flags = TGT_SCHED_INBOX;
|
|
1190 |
else if (!strcmp(fctx->req_tgt->collection, SCHED_OUTBOX))
|
|
1191 |
tgt_flags = TGT_SCHED_OUTBOX;
|
|
1192 |
else {
|
|
1193 |
add_suppriv(agg, "read-free-busy", fctx->ns[NS_CALDAV], 0,
|
|
1194 |
"Read free/busy time");
|
|
1195 |
}
|
|
1196 |
}
|
| 1097 | 1197 |
}
|
| 1098 | 1198 |
|
| 1099 | 1199 |
write = add_suppriv(all, "write", NULL, 0, "Write any object");
|
|
| 1120 | 1220 |
add_suppriv(agg, "write-acl", NULL, 1, "Write ACL");
|
| 1121 | 1221 |
add_suppriv(agg, "unlock", NULL, 1, "Unlock resource");
|
| 1122 | 1222 |
|
| 1123 | |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR &&
|
| 1124 | |
fctx->req_tgt->collection) {
|
| 1125 | |
if (!strcmp(fctx->req_tgt->collection, SCHED_INBOX)) {
|
| 1126 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 1127 | |
agg = add_suppriv(all, "schedule-deliver", fctx->ns[NS_CALDAV], 0,
|
| 1128 | |
"Deliver scheduling messages");
|
| 1129 | |
add_suppriv(agg, "schedule-deliver-invite", fctx->ns[NS_CALDAV], 0,
|
| 1130 | |
"Deliver scheduling messages from Organizers");
|
| 1131 | |
add_suppriv(agg, "schedule-deliver-reply", fctx->ns[NS_CALDAV], 0,
|
| 1132 | |
"Deliver scheduling messages from Attendees");
|
| 1133 | |
add_suppriv(agg, "schedule-query-freebusy", fctx->ns[NS_CALDAV], 0,
|
| 1134 | |
"Accept free/busy requests");
|
| 1135 | |
}
|
| 1136 | |
else if (!strcmp(fctx->req_tgt->collection, SCHED_OUTBOX)) {
|
| 1137 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 1138 | |
agg = add_suppriv(all, "schedule-send", fctx->ns[NS_CALDAV], 0,
|
| 1139 | |
"Send scheduling messages");
|
| 1140 | |
add_suppriv(agg, "schedule-send-invite", fctx->ns[NS_CALDAV], 0,
|
| 1141 | |
"Send scheduling messages by Organizers");
|
| 1142 | |
add_suppriv(agg, "schedule-send-reply", fctx->ns[NS_CALDAV], 0,
|
| 1143 | |
"Send scheduling messages by Attendees");
|
| 1144 | |
add_suppriv(agg, "schedule-send-freebusy", fctx->ns[NS_CALDAV], 0,
|
| 1145 | |
"Submit free/busy requests");
|
| 1146 | |
}
|
|
1223 |
if (tgt_flags == TGT_SCHED_INBOX) {
|
|
1224 |
agg = add_suppriv(all, "schedule-deliver", fctx->ns[NS_CALDAV], 0,
|
|
1225 |
"Deliver scheduling messages");
|
|
1226 |
add_suppriv(agg, "schedule-deliver-invite", fctx->ns[NS_CALDAV], 0,
|
|
1227 |
"Deliver scheduling messages from Organizers");
|
|
1228 |
add_suppriv(agg, "schedule-deliver-reply", fctx->ns[NS_CALDAV], 0,
|
|
1229 |
"Deliver scheduling messages from Attendees");
|
|
1230 |
add_suppriv(agg, "schedule-query-freebusy", fctx->ns[NS_CALDAV], 0,
|
|
1231 |
"Accept free/busy requests");
|
|
1232 |
}
|
|
1233 |
else if (tgt_flags == TGT_SCHED_OUTBOX) {
|
|
1234 |
agg = add_suppriv(all, "schedule-send", fctx->ns[NS_CALDAV], 0,
|
|
1235 |
"Send scheduling messages");
|
|
1236 |
add_suppriv(agg, "schedule-send-invite", fctx->ns[NS_CALDAV], 0,
|
|
1237 |
"Send scheduling messages by Organizers");
|
|
1238 |
add_suppriv(agg, "schedule-send-reply", fctx->ns[NS_CALDAV], 0,
|
|
1239 |
"Send scheduling messages by Attendees");
|
|
1240 |
add_suppriv(agg, "schedule-send-freebusy", fctx->ns[NS_CALDAV], 0,
|
|
1241 |
"Submit free/busy requests");
|
| 1147 | 1242 |
}
|
| 1148 | 1243 |
|
| 1149 | 1244 |
return 0;
|
|
| 1263 | 1358 |
|
| 1264 | 1359 |
|
| 1265 | 1360 |
/* Callback to fetch DAV:current-user-privilege-set */
|
| 1266 | |
static int propfind_curprivset(xmlNodePtr prop,
|
|
1361 |
static int propfind_curprivset(const xmlChar *name, xmlNsPtr ns,
|
| 1267 | 1362 |
struct propfind_ctx *fctx,
|
| 1268 | 1363 |
xmlNodePtr resp,
|
| 1269 | 1364 |
struct propstat propstat[],
|
|
| 1271 | 1366 |
{
|
| 1272 | 1367 |
int rights;
|
| 1273 | 1368 |
unsigned flags = 0;
|
| 1274 | |
|
| 1275 | |
if (!fctx->mailbox) {
|
| 1276 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1277 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1278 | |
}
|
| 1279 | |
else if (((rights =
|
| 1280 | |
cyrus_acl_myrights(fctx->authstate, fctx->mailbox->acl))
|
| 1281 | |
& DACL_READ) != DACL_READ) {
|
| 1282 | |
xml_add_prop(HTTP_UNAUTHORIZED, fctx->ns[NS_DAV],
|
| 1283 | |
&propstat[PROPSTAT_UNAUTH], prop, NULL, 0);
|
| 1284 | |
}
|
| 1285 | |
else {
|
| 1286 | |
xmlNodePtr set;
|
| 1287 | |
|
| 1288 | |
/* Add in implicit rights */
|
| 1289 | |
if (fctx->userisadmin) {
|
| 1290 | |
rights |= DACL_ADMIN;
|
| 1291 | |
}
|
| 1292 | |
else if (mboxname_userownsmailbox(fctx->userid, fctx->mailbox->name)) {
|
| 1293 | |
rights |= config_implicitrights;
|
| 1294 | |
}
|
| 1295 | |
|
| 1296 | |
/* Build the rest of the XML response */
|
| 1297 | |
set = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1298 | |
prop, NULL, 0);
|
| 1299 | |
|
| 1300 | |
if (fctx->req_tgt->collection) {
|
| 1301 | |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR) {
|
| 1302 | |
flags = PRIV_IMPLICIT;
|
| 1303 | |
|
| 1304 | |
if (!strcmp(fctx->req_tgt->collection, SCHED_INBOX))
|
| 1305 | |
flags = PRIV_INBOX;
|
| 1306 | |
else if (!strcmp(fctx->req_tgt->collection, SCHED_OUTBOX))
|
| 1307 | |
flags = PRIV_OUTBOX;
|
| 1308 | |
}
|
| 1309 | |
|
| 1310 | |
add_privs(rights, flags, set, resp->parent, fctx->ns);
|
| 1311 | |
}
|
|
1369 |
xmlNodePtr set;
|
|
1370 |
|
|
1371 |
if (!fctx->mailbox) return HTTP_NOT_FOUND;
|
|
1372 |
if (((rights = cyrus_acl_myrights(fctx->authstate, fctx->mailbox->acl))
|
|
1373 |
& DACL_READ) != DACL_READ) {
|
|
1374 |
return HTTP_UNAUTHORIZED;
|
|
1375 |
}
|
|
1376 |
|
|
1377 |
/* Add in implicit rights */
|
|
1378 |
if (fctx->userisadmin) {
|
|
1379 |
rights |= DACL_ADMIN;
|
|
1380 |
}
|
|
1381 |
else if (mboxname_userownsmailbox(fctx->int_userid, fctx->mailbox->name)) {
|
|
1382 |
rights |= config_implicitrights;
|
|
1383 |
}
|
|
1384 |
|
|
1385 |
/* Build the rest of the XML response */
|
|
1386 |
set = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1387 |
name, ns, NULL, 0);
|
|
1388 |
|
|
1389 |
if (fctx->req_tgt->collection) {
|
|
1390 |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR) {
|
|
1391 |
flags = PRIV_IMPLICIT;
|
|
1392 |
|
|
1393 |
if (!strcmp(fctx->req_tgt->collection, SCHED_INBOX))
|
|
1394 |
flags = PRIV_INBOX;
|
|
1395 |
else if (!strcmp(fctx->req_tgt->collection, SCHED_OUTBOX))
|
|
1396 |
flags = PRIV_OUTBOX;
|
|
1397 |
}
|
|
1398 |
|
|
1399 |
add_privs(rights, flags, set, resp->parent, fctx->ns);
|
| 1312 | 1400 |
}
|
| 1313 | 1401 |
|
| 1314 | 1402 |
return 0;
|
|
| 1316 | 1404 |
|
| 1317 | 1405 |
|
| 1318 | 1406 |
/* Callback to fetch DAV:acl */
|
| 1319 | |
static int propfind_acl(xmlNodePtr prop,
|
|
1407 |
static int propfind_acl(const xmlChar *name, xmlNsPtr ns,
|
| 1320 | 1408 |
struct propfind_ctx *fctx,
|
| 1321 | 1409 |
xmlNodePtr resp,
|
| 1322 | 1410 |
struct propstat propstat[],
|
| 1323 | 1411 |
void *rock __attribute__((unused)))
|
| 1324 | 1412 |
{
|
| 1325 | 1413 |
int rights;
|
| 1326 | |
|
| 1327 | |
if (!fctx->mailbox) {
|
| 1328 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1329 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1330 | |
}
|
| 1331 | |
else if (!((rights =
|
| 1332 | |
cyrus_acl_myrights(fctx->authstate, fctx->mailbox->acl))
|
| 1333 | |
& DACL_ADMIN)) {
|
| 1334 | |
xml_add_prop(HTTP_UNAUTHORIZED, fctx->ns[NS_DAV],
|
| 1335 | |
&propstat[PROPSTAT_UNAUTH], prop, NULL, 0);
|
| 1336 | |
}
|
| 1337 | |
else {
|
| 1338 | |
xmlNodePtr acl;
|
| 1339 | |
char *aclstr, *userid;
|
| 1340 | |
unsigned flags = 0;
|
| 1341 | |
|
| 1342 | |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR) {
|
| 1343 | |
flags = PRIV_IMPLICIT;
|
| 1344 | |
|
| 1345 | |
if (fctx->req_tgt->collection) {
|
| 1346 | |
if (!strcmp(fctx->req_tgt->collection, SCHED_INBOX))
|
| 1347 | |
flags = PRIV_INBOX;
|
| 1348 | |
else if (!strcmp(fctx->req_tgt->collection, SCHED_OUTBOX))
|
| 1349 | |
flags = PRIV_OUTBOX;
|
| 1350 | |
}
|
| 1351 | |
}
|
| 1352 | |
|
| 1353 | |
/* Start the acl XML response */
|
| 1354 | |
acl = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1355 | |
prop, NULL, 0);
|
| 1356 | |
|
| 1357 | |
/* Parse the ACL string (userid/rights pairs) */
|
| 1358 | |
userid = aclstr = xstrdup(fctx->mailbox->acl);
|
| 1359 | |
|
| 1360 | |
while (userid) {
|
| 1361 | |
char *rightstr, *nextid;
|
| 1362 | |
xmlNodePtr ace, node;
|
| 1363 | |
int deny = 0;
|
| 1364 | |
|
| 1365 | |
rightstr = strchr(userid, '\t');
|
| 1366 | |
if (!rightstr) break;
|
| 1367 | |
*rightstr++ = '\0';
|
|
1414 |
xmlNodePtr acl;
|
|
1415 |
char *aclstr, *userid;
|
|
1416 |
unsigned flags = 0;
|
|
1417 |
|
|
1418 |
if (!fctx->mailbox) return HTTP_NOT_FOUND;
|
|
1419 |
if (!((rights = cyrus_acl_myrights(fctx->authstate, fctx->mailbox->acl))
|
|
1420 |
& DACL_ADMIN)) {
|
|
1421 |
return HTTP_UNAUTHORIZED;
|
|
1422 |
}
|
|
1423 |
|
|
1424 |
if (fctx->req_tgt->namespace == URL_NS_CALENDAR) {
|
|
1425 |
flags = PRIV_IMPLICIT;
|
|
1426 |
|
|
1427 |
if (fctx->req_tgt->collection) {
|
|
1428 |
if (!strcmp(fctx->req_tgt->collection, SCHED_INBOX))
|
|
1429 |
flags = PRIV_INBOX;
|
|
1430 |
else if (!strcmp(fctx->req_tgt->collection, SCHED_OUTBOX))
|
|
1431 |
flags = PRIV_OUTBOX;
|
|
1432 |
}
|
|
1433 |
}
|
|
1434 |
|
|
1435 |
/* Start the acl XML response */
|
|
1436 |
acl = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1437 |
name, ns, NULL, 0);
|
|
1438 |
|
|
1439 |
/* Parse the ACL string (userid/rights pairs) */
|
|
1440 |
userid = aclstr = xstrdup(fctx->mailbox->acl);
|
|
1441 |
|
|
1442 |
while (userid) {
|
|
1443 |
char *rightstr, *nextid;
|
|
1444 |
xmlNodePtr ace, node;
|
|
1445 |
int deny = 0;
|
|
1446 |
|
|
1447 |
rightstr = strchr(userid, '\t');
|
|
1448 |
if (!rightstr) break;
|
|
1449 |
*rightstr++ = '\0';
|
| 1368 | 1450 |
|
| 1369 | |
nextid = strchr(rightstr, '\t');
|
| 1370 | |
if (!nextid) break;
|
| 1371 | |
*nextid++ = '\0';
|
| 1372 | |
|
| 1373 | |
/* Check for negative rights */
|
| 1374 | |
/* XXX Does this correspond to DAV:deny? */
|
| 1375 | |
if (*userid == '-') {
|
| 1376 | |
deny = 1;
|
| 1377 | |
userid++;
|
| 1378 | |
}
|
| 1379 | |
|
| 1380 | |
rights = cyrus_acl_strtomask(rightstr);
|
| 1381 | |
|
| 1382 | |
/* Add ace XML element for this userid/right pair */
|
| 1383 | |
ace = xmlNewChild(acl, NULL, BAD_CAST "ace", NULL);
|
| 1384 | |
|
| 1385 | |
/* XXX Need to check for groups.
|
| 1386 | |
* Is there any IMAP equivalent to "unauthenticated"?
|
| 1387 | |
* Is there any DAV equivalent to "anonymous"?
|
| 1388 | |
*/
|
| 1389 | |
|
| 1390 | |
node = xmlNewChild(ace, NULL, BAD_CAST "principal", NULL);
|
| 1391 | |
if (!strcmp(userid, fctx->userid))
|
| 1392 | |
xmlNewChild(node, NULL, BAD_CAST "self", NULL);
|
| 1393 | |
else if ((strlen(userid) == fctx->req_tgt->userlen) &&
|
| 1394 | |
!strncmp(userid, fctx->req_tgt->user, fctx->req_tgt->userlen))
|
| 1395 | |
xmlNewChild(node, NULL, BAD_CAST "owner", NULL);
|
| 1396 | |
else if (!strcmp(userid, "anyone"))
|
| 1397 | |
xmlNewChild(node, NULL, BAD_CAST "authenticated", NULL);
|
| 1398 | |
else {
|
| 1399 | |
buf_reset(&fctx->buf);
|
| 1400 | |
buf_printf(&fctx->buf, "%s/user/%s/",
|
| 1401 | |
namespace_principal.prefix, userid);
|
| 1402 | |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
| 1403 | |
}
|
| 1404 | |
|
| 1405 | |
node = xmlNewChild(ace, NULL,
|
| 1406 | |
BAD_CAST (deny ? "deny" : "grant"), NULL);
|
| 1407 | |
add_privs(rights, flags, node, resp->parent, fctx->ns);
|
| 1408 | |
|
| 1409 | |
if (fctx->req_tgt->resource) {
|
| 1410 | |
node = xmlNewChild(ace, NULL, BAD_CAST "inherited", NULL);
|
| 1411 | |
buf_reset(&fctx->buf);
|
| 1412 | |
buf_printf(&fctx->buf, "%.*s",
|
| 1413 | |
(int)(fctx->req_tgt->resource - fctx->req_tgt->path),
|
| 1414 | |
fctx->req_tgt->path);
|
| 1415 | |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
| 1416 | |
}
|
| 1417 | |
|
| 1418 | |
userid = nextid;
|
| 1419 | |
}
|
| 1420 | |
|
| 1421 | |
if (aclstr) free(aclstr);
|
| 1422 | |
}
|
|
1451 |
nextid = strchr(rightstr, '\t');
|
|
1452 |
if (!nextid) break;
|
|
1453 |
*nextid++ = '\0';
|
|
1454 |
|
|
1455 |
/* Check for negative rights */
|
|
1456 |
/* XXX Does this correspond to DAV:deny? */
|
|
1457 |
if (*userid == '-') {
|
|
1458 |
deny = 1;
|
|
1459 |
userid++;
|
|
1460 |
}
|
|
1461 |
|
|
1462 |
rights = cyrus_acl_strtomask(rightstr);
|
|
1463 |
|
|
1464 |
/* Add ace XML element for this userid/right pair */
|
|
1465 |
ace = xmlNewChild(acl, NULL, BAD_CAST "ace", NULL);
|
|
1466 |
|
|
1467 |
/* XXX Need to check for groups.
|
|
1468 |
* Is there any IMAP equivalent to "unauthenticated"?
|
|
1469 |
* Is there any DAV equivalent to "anonymous"?
|
|
1470 |
*/
|
|
1471 |
|
|
1472 |
node = xmlNewChild(ace, NULL, BAD_CAST "principal", NULL);
|
|
1473 |
if (!strcmp(userid, fctx->userid))
|
|
1474 |
xmlNewChild(node, NULL, BAD_CAST "self", NULL);
|
|
1475 |
else if ((strlen(userid) == fctx->req_tgt->userlen) &&
|
|
1476 |
!strncmp(userid, fctx->req_tgt->user, fctx->req_tgt->userlen))
|
|
1477 |
xmlNewChild(node, NULL, BAD_CAST "owner", NULL);
|
|
1478 |
else if (!strcmp(userid, "anyone"))
|
|
1479 |
xmlNewChild(node, NULL, BAD_CAST "authenticated", NULL);
|
|
1480 |
else {
|
|
1481 |
buf_reset(&fctx->buf);
|
|
1482 |
buf_printf(&fctx->buf, "%s/user/%s/",
|
|
1483 |
namespace_principal.prefix, userid);
|
|
1484 |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
|
1485 |
}
|
|
1486 |
|
|
1487 |
node = xmlNewChild(ace, NULL,
|
|
1488 |
BAD_CAST (deny ? "deny" : "grant"), NULL);
|
|
1489 |
add_privs(rights, flags, node, resp->parent, fctx->ns);
|
|
1490 |
|
|
1491 |
if (fctx->req_tgt->resource) {
|
|
1492 |
node = xmlNewChild(ace, NULL, BAD_CAST "inherited", NULL);
|
|
1493 |
buf_reset(&fctx->buf);
|
|
1494 |
buf_printf(&fctx->buf, "%.*s",
|
|
1495 |
(int)(fctx->req_tgt->resource - fctx->req_tgt->path),
|
|
1496 |
fctx->req_tgt->path);
|
|
1497 |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
|
1498 |
}
|
|
1499 |
|
|
1500 |
userid = nextid;
|
|
1501 |
}
|
|
1502 |
|
|
1503 |
if (aclstr) free(aclstr);
|
| 1423 | 1504 |
|
| 1424 | 1505 |
return 0;
|
| 1425 | 1506 |
}
|
| 1426 | 1507 |
|
| 1427 | 1508 |
|
| 1428 | 1509 |
/* Callback to fetch DAV:acl-restrictions */
|
| 1429 | |
static int propfind_aclrestrict(xmlNodePtr prop,
|
|
1510 |
static int propfind_aclrestrict(const xmlChar *name, xmlNsPtr ns,
|
| 1430 | 1511 |
struct propfind_ctx *fctx,
|
| 1431 | 1512 |
xmlNodePtr resp __attribute__((unused)),
|
| 1432 | 1513 |
struct propstat propstat[],
|
| 1433 | 1514 |
void *rock __attribute__((unused)))
|
| 1434 | 1515 |
{
|
| 1435 | |
xmlNodePtr node;
|
| 1436 | |
|
| 1437 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1438 | |
prop, NULL, 0);
|
|
1516 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
|
1517 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
| 1439 | 1518 |
|
| 1440 | 1519 |
xmlNewChild(node, NULL, BAD_CAST "no-invert", NULL);
|
| 1441 | 1520 |
|
|
| 1444 | 1523 |
|
| 1445 | 1524 |
|
| 1446 | 1525 |
/* Callback to fetch DAV:principal-collection-set */
|
| 1447 | |
static int propfind_princolset(xmlNodePtr prop,
|
|
1526 |
static int propfind_princolset(const xmlChar *name, xmlNsPtr ns,
|
| 1448 | 1527 |
struct propfind_ctx *fctx,
|
| 1449 | 1528 |
xmlNodePtr resp __attribute__((unused)),
|
| 1450 | 1529 |
struct propstat propstat[],
|
| 1451 | 1530 |
void *rock __attribute__((unused)))
|
| 1452 | 1531 |
{
|
| 1453 | |
xmlNodePtr node;
|
| 1454 | |
|
| 1455 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1456 | |
prop, NULL, 0);
|
|
1532 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
|
1533 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
| 1457 | 1534 |
|
| 1458 | 1535 |
buf_reset(&fctx->buf);
|
| 1459 | 1536 |
buf_printf(&fctx->buf, "%s/", namespace_principal.prefix);
|
|
| 1464 | 1541 |
|
| 1465 | 1542 |
|
| 1466 | 1543 |
/* Callback to fetch DAV:quota-available-bytes and DAV:quota-used-bytes */
|
| 1467 | |
static int propfind_quota(xmlNodePtr prop,
|
|
1544 |
static int propfind_quota(const xmlChar *name, xmlNsPtr ns,
|
| 1468 | 1545 |
struct propfind_ctx *fctx,
|
| 1469 | 1546 |
xmlNodePtr resp __attribute__((unused)),
|
| 1470 | 1547 |
struct propstat propstat[],
|
|
| 1484 | 1561 |
}
|
| 1485 | 1562 |
}
|
| 1486 | 1563 |
|
| 1487 | |
if (qr) {
|
| 1488 | |
if (!fctx->quota.root ||
|
| 1489 | |
strcmp(fctx->quota.root, qr)) {
|
| 1490 | |
/* Different quotaroot - read it */
|
| 1491 | |
|
| 1492 | |
syslog(LOG_DEBUG, "reading quota for '%s'", qr);
|
| 1493 | |
|
| 1494 | |
fctx->quota.root = strcpy(prevroot, qr);
|
| 1495 | |
|
| 1496 | |
quota_read(&fctx->quota, NULL, 0);
|
| 1497 | |
}
|
| 1498 | |
|
| 1499 | |
buf_reset(&fctx->buf);
|
| 1500 | |
if (!xmlStrcmp(prop->name, BAD_CAST "quota-available-bytes")) {
|
| 1501 | |
/* Calculate limit in bytes and subtract usage */
|
| 1502 | |
uquota_t limit = fctx->quota.limit * QUOTA_UNITS;
|
| 1503 | |
|
| 1504 | |
buf_printf(&fctx->buf, UQUOTA_T_FMT, limit - fctx->quota.used);
|
| 1505 | |
}
|
| 1506 | |
else if (fctx->record) {
|
| 1507 | |
/* Bytes used by resource */
|
| 1508 | |
buf_printf(&fctx->buf, "%u", fctx->record->size);
|
| 1509 | |
}
|
| 1510 | |
else if (fctx->mailbox) {
|
| 1511 | |
/* Bytes used by calendar collection */
|
| 1512 | |
buf_printf(&fctx->buf, UQUOTA_T_FMT,
|
| 1513 | |
fctx->mailbox->i.quota_mailbox_used);
|
| 1514 | |
}
|
| 1515 | |
else {
|
| 1516 | |
/* Bytes used by entire hierarchy */
|
| 1517 | |
buf_printf(&fctx->buf, UQUOTA_T_FMT, fctx->quota.used);
|
| 1518 | |
}
|
| 1519 | |
|
| 1520 | |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1521 | |
prop, BAD_CAST buf_cstring(&fctx->buf), 0);
|
|
1564 |
if (!qr) return HTTP_NOT_FOUND;
|
|
1565 |
|
|
1566 |
if (!fctx->quota.root ||
|
|
1567 |
strcmp(fctx->quota.root, qr)) {
|
|
1568 |
/* Different quotaroot - read it */
|
|
1569 |
|
|
1570 |
syslog(LOG_DEBUG, "reading quota for '%s'", qr);
|
|
1571 |
|
|
1572 |
fctx->quota.root = strcpy(prevroot, qr);
|
|
1573 |
|
|
1574 |
quota_read(&fctx->quota, NULL, 0);
|
|
1575 |
}
|
|
1576 |
|
|
1577 |
buf_reset(&fctx->buf);
|
|
1578 |
if (!xmlStrcmp(name, BAD_CAST "quota-available-bytes")) {
|
|
1579 |
/* Calculate limit in bytes and subtract usage */
|
|
1580 |
uquota_t limit = fctx->quota.limit * QUOTA_UNITS;
|
|
1581 |
|
|
1582 |
buf_printf(&fctx->buf, UQUOTA_T_FMT, limit - fctx->quota.used);
|
|
1583 |
}
|
|
1584 |
else if (fctx->record) {
|
|
1585 |
/* Bytes used by resource */
|
|
1586 |
buf_printf(&fctx->buf, "%u", fctx->record->size);
|
|
1587 |
}
|
|
1588 |
else if (fctx->mailbox) {
|
|
1589 |
/* Bytes used by calendar collection */
|
|
1590 |
buf_printf(&fctx->buf, UQUOTA_T_FMT,
|
|
1591 |
fctx->mailbox->i.quota_mailbox_used);
|
| 1522 | 1592 |
}
|
| 1523 | 1593 |
else {
|
| 1524 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1525 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1526 | |
}
|
|
1594 |
/* Bytes used by entire hierarchy */
|
|
1595 |
buf_printf(&fctx->buf, UQUOTA_T_FMT, fctx->quota.used);
|
|
1596 |
}
|
|
1597 |
|
|
1598 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1599 |
name, ns, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 1527 | 1600 |
|
| 1528 | 1601 |
return 0;
|
| 1529 | 1602 |
}
|
| 1530 | 1603 |
|
| 1531 | 1604 |
|
| 1532 | 1605 |
/* Callback to fetch DAV:current-user-principal */
|
| 1533 | |
static int propfind_curprin(xmlNodePtr prop,
|
|
1606 |
static int propfind_curprin(const xmlChar *name, xmlNsPtr ns,
|
| 1534 | 1607 |
struct propfind_ctx *fctx,
|
| 1535 | 1608 |
xmlNodePtr resp __attribute__((unused)),
|
| 1536 | 1609 |
struct propstat propstat[],
|
| 1537 | 1610 |
void *rock __attribute__((unused)))
|
| 1538 | 1611 |
{
|
| 1539 | |
xmlNodePtr node;
|
| 1540 | |
|
| 1541 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1542 | |
prop, NULL, 0);
|
|
1612 |
xmlNodePtr node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV],
|
|
1613 |
&propstat[PROPSTAT_OK], name, ns, NULL, 0);
|
| 1543 | 1614 |
|
| 1544 | 1615 |
if (fctx->userid) {
|
| 1545 | 1616 |
buf_reset(&fctx->buf);
|
|
| 1556 | 1627 |
|
| 1557 | 1628 |
|
| 1558 | 1629 |
/* Callback to fetch DAV:add-member */
|
| 1559 | |
static int propfind_addmember(xmlNodePtr prop,
|
|
1630 |
static int propfind_addmember(const xmlChar *name, xmlNsPtr ns,
|
| 1560 | 1631 |
struct propfind_ctx *fctx,
|
| 1561 | 1632 |
xmlNodePtr resp __attribute__((unused)),
|
| 1562 | 1633 |
struct propstat propstat[],
|
| 1563 | 1634 |
void *rock __attribute__((unused)))
|
| 1564 | 1635 |
{
|
| 1565 | |
if (fctx->req_tgt->collection && /* Until Apple Contacts is fixed */
|
| 1566 | |
fctx->req_tgt->namespace == URL_NS_CALENDAR) {
|
| 1567 | |
xmlNodePtr node;
|
| 1568 | |
int len;
|
| 1569 | |
|
| 1570 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1571 | |
prop, NULL, 0);
|
| 1572 | |
|
| 1573 | |
len = fctx->req_tgt->resource ?
|
| 1574 | |
(size_t) (fctx->req_tgt->resource - fctx->req_tgt->path) :
|
| 1575 | |
strlen(fctx->req_tgt->path);
|
| 1576 | |
buf_reset(&fctx->buf);
|
| 1577 | |
buf_printf(&fctx->buf, "%.*s", len, fctx->req_tgt->path);
|
| 1578 | |
|
| 1579 | |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
| 1580 | |
}
|
| 1581 | |
else {
|
| 1582 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1583 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1584 | |
}
|
|
1636 |
xmlNodePtr node;
|
|
1637 |
int len;
|
|
1638 |
|
|
1639 |
if (!fctx->req_tgt->collection) return HTTP_NOT_FOUND;
|
|
1640 |
|
|
1641 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1642 |
name, ns, NULL, 0);
|
|
1643 |
|
|
1644 |
len = fctx->req_tgt->resource ?
|
|
1645 |
(size_t) (fctx->req_tgt->resource - fctx->req_tgt->path) :
|
|
1646 |
strlen(fctx->req_tgt->path);
|
|
1647 |
buf_reset(&fctx->buf);
|
|
1648 |
buf_printf(&fctx->buf, "%.*s", len, fctx->req_tgt->path);
|
|
1649 |
|
|
1650 |
xml_add_href(node, NULL, buf_cstring(&fctx->buf));
|
| 1585 | 1651 |
|
| 1586 | 1652 |
return 0;
|
| 1587 | 1653 |
}
|
| 1588 | 1654 |
|
| 1589 | 1655 |
|
| 1590 | 1656 |
/* Callback to fetch DAV:sync-token and CS:getctag */
|
| 1591 | |
static int propfind_sync_token(xmlNodePtr prop,
|
|
1657 |
static int propfind_sync_token(const xmlChar *name, xmlNsPtr ns,
|
| 1592 | 1658 |
struct propfind_ctx *fctx,
|
| 1593 | 1659 |
xmlNodePtr resp __attribute__((unused)),
|
| 1594 | 1660 |
struct propstat propstat[],
|
| 1595 | 1661 |
void *rock __attribute__((unused)))
|
| 1596 | 1662 |
{
|
| 1597 | |
if (fctx->mailbox && !fctx->record) {
|
| 1598 | |
buf_reset(&fctx->buf);
|
| 1599 | |
buf_printf(&fctx->buf, XML_NS_CYRUS "sync/%u-" MODSEQ_FMT,
|
| 1600 | |
fctx->mailbox->i.uidvalidity,
|
| 1601 | |
fctx->mailbox->i.highestmodseq);
|
| 1602 | |
|
| 1603 | |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1604 | |
prop, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 1605 | |
}
|
| 1606 | |
else {
|
| 1607 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1608 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1609 | |
}
|
|
1663 |
if (!fctx->mailbox || fctx->record) return HTTP_NOT_FOUND;
|
|
1664 |
|
|
1665 |
buf_reset(&fctx->buf);
|
|
1666 |
buf_printf(&fctx->buf, XML_NS_CYRUS "sync/%u-" MODSEQ_FMT,
|
|
1667 |
fctx->mailbox->i.uidvalidity,
|
|
1668 |
fctx->mailbox->i.highestmodseq);
|
|
1669 |
|
|
1670 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1671 |
name, ns, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 1610 | 1672 |
|
| 1611 | 1673 |
return 0;
|
| 1612 | 1674 |
}
|
| 1613 | 1675 |
|
| 1614 | 1676 |
|
| 1615 | 1677 |
/* Callback to fetch CALDAV:calendar-data and CARDDAV:address-data */
|
| 1616 | |
static int propfind_getdata(xmlNodePtr prop,
|
|
1678 |
static int propfind_getdata(const xmlChar *name, xmlNsPtr ns,
|
| 1617 | 1679 |
struct propfind_ctx *fctx,
|
| 1618 | 1680 |
xmlNodePtr resp __attribute__((unused)),
|
| 1619 | 1681 |
struct propstat propstat[],
|
| 1620 | 1682 |
void *rock __attribute__((unused)))
|
| 1621 | 1683 |
{
|
| 1622 | |
if (fctx->record) {
|
| 1623 | |
xmlNodePtr data;
|
| 1624 | |
|
| 1625 | |
if (!fctx->msg_base) {
|
| 1626 | |
mailbox_map_message(fctx->mailbox, fctx->record->uid,
|
| 1627 | |
&fctx->msg_base, &fctx->msg_size);
|
| 1628 | |
}
|
| 1629 | |
|
| 1630 | |
data = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1631 | |
prop, NULL, 0);
|
| 1632 | |
xmlAddChild(data,
|
| 1633 | |
xmlNewCDataBlock(fctx->root->doc,
|
| 1634 | |
BAD_CAST fctx->msg_base +
|
| 1635 | |
fctx->record->header_size,
|
| 1636 | |
fctx->record->size -
|
| 1637 | |
fctx->record->header_size));
|
| 1638 | |
|
| 1639 | |
fctx->fetcheddata = 1;
|
| 1640 | |
}
|
| 1641 | |
else {
|
| 1642 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1643 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1644 | |
}
|
|
1684 |
xmlNodePtr data;
|
|
1685 |
|
|
1686 |
if (!fctx->record) return HTTP_NOT_FOUND;
|
|
1687 |
|
|
1688 |
if (!fctx->msg_base) {
|
|
1689 |
mailbox_map_message(fctx->mailbox, fctx->record->uid,
|
|
1690 |
&fctx->msg_base, &fctx->msg_size);
|
|
1691 |
}
|
|
1692 |
|
|
1693 |
data = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1694 |
name, ns, NULL, 0);
|
|
1695 |
xmlAddChild(data,
|
|
1696 |
xmlNewCDataBlock(fctx->root->doc,
|
|
1697 |
BAD_CAST fctx->msg_base +
|
|
1698 |
fctx->record->header_size,
|
|
1699 |
fctx->record->size -
|
|
1700 |
fctx->record->header_size));
|
|
1701 |
|
|
1702 |
fctx->fetcheddata = 1;
|
| 1645 | 1703 |
|
| 1646 | 1704 |
return 0;
|
| 1647 | 1705 |
}
|
|
| 1651 | 1709 |
* CALDAV:schedule-inbox-URL, CALDAV:schedule-outbox-URL,
|
| 1652 | 1710 |
* and CALDAV:schedule-default-calendar-URL
|
| 1653 | 1711 |
*/
|
| 1654 | |
static int propfind_calurl(xmlNodePtr prop,
|
|
1712 |
static int propfind_calurl(const xmlChar *name, xmlNsPtr ns,
|
| 1655 | 1713 |
struct propfind_ctx *fctx,
|
| 1656 | |
xmlNodePtr resp,
|
|
1714 |
xmlNodePtr resp __attribute__((unused)),
|
| 1657 | 1715 |
struct propstat propstat[],
|
| 1658 | 1716 |
void *rock)
|
| 1659 | 1717 |
{
|
| 1660 | 1718 |
xmlNodePtr node;
|
| 1661 | 1719 |
const char *cal = (const char *) rock;
|
| 1662 | 1720 |
|
| 1663 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 1664 | |
if (fctx->userid &&
|
| 1665 | |
/* sched-def-cal-URL only defined on sched-inbox-URL */
|
| 1666 | |
((fctx->req_tgt->namespace == URL_NS_CALENDAR &&
|
| 1667 | |
fctx->req_tgt->collection && cal &&
|
| 1668 | |
!strcmp(fctx->req_tgt->collection, SCHED_INBOX) &&
|
| 1669 | |
!strcmp(cal, SCHED_DEFAULT))
|
| 1670 | |
/* others only defined on principals */
|
| 1671 | |
|| (fctx->req_tgt->namespace == URL_NS_PRINCIPAL))) {
|
| 1672 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1673 | |
prop, NULL, 0);
|
| 1674 | |
|
| 1675 | |
buf_reset(&fctx->buf);
|
| 1676 | |
buf_printf(&fctx->buf, "%s/user/%s/%s",
|
| 1677 | |
namespace_calendar.prefix, fctx->userid, cal ? cal : "");
|
| 1678 | |
|
| 1679 | |
xml_add_href(node, fctx->ns[NS_DAV], buf_cstring(&fctx->buf));
|
| 1680 | |
}
|
| 1681 | |
else {
|
| 1682 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1683 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1684 | |
}
|
|
1721 |
if (!fctx->userid) return HTTP_NOT_FOUND;
|
|
1722 |
|
|
1723 |
/* sched-def-cal-URL only defined on sched-inbox-URL */
|
|
1724 |
if (!xmlStrcmp(name, BAD_CAST "schedule-default-calendar-URL") &&
|
|
1725 |
(!fctx->req_tgt->collection ||
|
|
1726 |
strcmp(fctx->req_tgt->collection, SCHED_INBOX)))
|
|
1727 |
return HTTP_NOT_FOUND;
|
|
1728 |
|
|
1729 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1730 |
name, ns, NULL, 0);
|
|
1731 |
|
|
1732 |
buf_reset(&fctx->buf);
|
|
1733 |
buf_printf(&fctx->buf, "%s/user/%s/%s",
|
|
1734 |
namespace_calendar.prefix, fctx->userid, cal ? cal : "");
|
|
1735 |
|
|
1736 |
xml_add_href(node, fctx->ns[NS_DAV], buf_cstring(&fctx->buf));
|
| 1685 | 1737 |
|
| 1686 | 1738 |
return 0;
|
| 1687 | 1739 |
}
|
| 1688 | 1740 |
|
| 1689 | 1741 |
|
| 1690 | 1742 |
/* Callback to fetch CALDAV:supported-calendar-component-set */
|
| 1691 | |
static int propfind_calcompset(xmlNodePtr prop,
|
|
1743 |
static int propfind_calcompset(const xmlChar *name, xmlNsPtr ns,
|
| 1692 | 1744 |
struct propfind_ctx *fctx,
|
| 1693 | 1745 |
xmlNodePtr resp __attribute__((unused)),
|
| 1694 | 1746 |
struct propstat propstat[],
|
| 1695 | 1747 |
void *rock __attribute__((unused)))
|
| 1696 | 1748 |
{
|
|
1749 |
const char *prop_annot = ANNOT_NS "CALDAV:supported-calendar-component-set";
|
| 1697 | 1750 |
struct annotation_data attrib;
|
| 1698 | 1751 |
unsigned long types = 0;
|
|
1752 |
xmlNodePtr set, node;
|
|
1753 |
const struct cal_comp_t *comp;
|
| 1699 | 1754 |
int r = 0;
|
| 1700 | 1755 |
|
| 1701 | |
if ((fctx->req_tgt->namespace == URL_NS_CALENDAR) &&
|
| 1702 | |
fctx->req_tgt->collection && !fctx->req_tgt->resource) {
|
| 1703 | |
const char *prop_annot =
|
| 1704 | |
ANNOT_NS "CALDAV:supported-calendar-component-set";
|
| 1705 | |
|
| 1706 | |
if (!(r = annotatemore_lookup(fctx->mailbox->name, prop_annot,
|
| 1707 | |
/* shared */ "", &attrib))) {
|
| 1708 | |
if (attrib.value)
|
| 1709 | |
types = strtoul(attrib.value, NULL, 10);
|
| 1710 | |
else
|
| 1711 | |
types = -1; /* ALL components types */
|
| 1712 | |
}
|
| 1713 | |
}
|
| 1714 | |
|
| 1715 | |
if (r) {
|
| 1716 | |
xml_add_prop(HTTP_SERVER_ERROR, fctx->ns[NS_DAV],
|
| 1717 | |
&propstat[PROPSTAT_ERROR], prop, NULL, 0);
|
| 1718 | |
}
|
| 1719 | |
else if (types) {
|
| 1720 | |
xmlNodePtr set, node;
|
| 1721 | |
const struct cal_comp_t *comp;
|
| 1722 | |
|
| 1723 | |
set = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1724 | |
prop, NULL, 0);
|
| 1725 | |
/* Create "comp" elements from the stored bitmask */
|
| 1726 | |
for (comp = cal_comps; comp->name; comp++) {
|
| 1727 | |
if (types & comp->type) {
|
| 1728 | |
node = xmlNewChild(set, fctx->ns[NS_CALDAV],
|
| 1729 | |
BAD_CAST "comp", NULL);
|
| 1730 | |
xmlNewProp(node, BAD_CAST "name", BAD_CAST comp->name);
|
| 1731 | |
}
|
| 1732 | |
}
|
| 1733 | |
}
|
| 1734 | |
else {
|
| 1735 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1736 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
|
1756 |
if (!fctx->req_tgt->collection) return HTTP_NOT_FOUND;
|
|
1757 |
|
|
1758 |
if (!(r = annotatemore_lookup(fctx->mailbox->name, prop_annot,
|
|
1759 |
/* shared */ "", &attrib))) {
|
|
1760 |
if (attrib.value)
|
|
1761 |
types = strtoul(attrib.value, NULL, 10);
|
|
1762 |
else
|
|
1763 |
types = -1; /* ALL components types */
|
|
1764 |
}
|
|
1765 |
|
|
1766 |
if (r) return HTTP_SERVER_ERROR;
|
|
1767 |
if (!types) return HTTP_NOT_FOUND;
|
|
1768 |
|
|
1769 |
set = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1770 |
name, ns, NULL, 0);
|
|
1771 |
/* Create "comp" elements from the stored bitmask */
|
|
1772 |
for (comp = cal_comps; comp->name; comp++) {
|
|
1773 |
if (types & comp->type) {
|
|
1774 |
node = xmlNewChild(set, fctx->ns[NS_CALDAV],
|
|
1775 |
BAD_CAST "comp", NULL);
|
|
1776 |
xmlNewProp(node, BAD_CAST "name", BAD_CAST comp->name);
|
|
1777 |
}
|
| 1737 | 1778 |
}
|
| 1738 | 1779 |
|
| 1739 | 1780 |
return 0;
|
|
| 1784 | 1825 |
buf_cstring(&pctx->buf), NULL,
|
| 1785 | 1826 |
buf_len(&pctx->buf), 0,
|
| 1786 | 1827 |
&pctx->tid))) {
|
| 1787 | |
xml_add_prop(HTTP_OK, pctx->ns[NS_DAV],
|
| 1788 | |
&propstat[PROPSTAT_OK], prop, NULL, 0);
|
|
1828 |
xml_add_prop(HTTP_OK, pctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1829 |
prop->name, prop->ns, NULL, 0);
|
| 1789 | 1830 |
}
|
| 1790 | 1831 |
else {
|
| 1791 | 1832 |
xml_add_prop(HTTP_SERVER_ERROR, pctx->ns[NS_DAV],
|
| 1792 | |
&propstat[PROPSTAT_ERROR], prop, NULL, 0);
|
|
1833 |
&propstat[PROPSTAT_ERROR],
|
|
1834 |
prop->name, prop->ns, NULL, 0);
|
| 1793 | 1835 |
}
|
| 1794 | 1836 |
|
| 1795 | 1837 |
return 0;
|
|
| 1804 | 1846 |
}
|
| 1805 | 1847 |
|
| 1806 | 1848 |
xml_add_prop(HTTP_FORBIDDEN, pctx->ns[NS_DAV], &propstat[PROPSTAT_FORBID],
|
| 1807 | |
prop, NULL, precond);
|
|
1849 |
prop->name, prop->ns, NULL, precond);
|
| 1808 | 1850 |
|
| 1809 | 1851 |
*pctx->ret = HTTP_FORBIDDEN;
|
| 1810 | 1852 |
|
|
| 1812 | 1854 |
}
|
| 1813 | 1855 |
|
| 1814 | 1856 |
/* Callback to fetch CALDAV:supported-calendar-data */
|
| 1815 | |
static int propfind_suppcaldata(xmlNodePtr prop,
|
|
1857 |
static int propfind_suppcaldata(const xmlChar *name, xmlNsPtr ns,
|
| 1816 | 1858 |
struct propfind_ctx *fctx,
|
| 1817 | 1859 |
xmlNodePtr resp __attribute__((unused)),
|
| 1818 | 1860 |
struct propstat propstat[],
|
|
| 1820 | 1862 |
{
|
| 1821 | 1863 |
xmlNodePtr node;
|
| 1822 | 1864 |
|
| 1823 | |
if ((fctx->req_tgt->namespace == URL_NS_CALENDAR) &&
|
| 1824 | |
fctx->req_tgt->collection && !fctx->req_tgt->resource) {
|
| 1825 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1826 | |
prop, NULL, 0);
|
| 1827 | |
|
| 1828 | |
node = xmlNewChild(node, fctx->ns[NS_CALDAV],
|
| 1829 | |
BAD_CAST "calendar-data", NULL);
|
| 1830 | |
xmlNewProp(node, BAD_CAST "content-type", BAD_CAST "text/calendar");
|
| 1831 | |
xmlNewProp(node, BAD_CAST "version", BAD_CAST "2.0");
|
| 1832 | |
}
|
| 1833 | |
else {
|
| 1834 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1835 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1836 | |
}
|
|
1865 |
if (!fctx->req_tgt->collection) return HTTP_NOT_FOUND;
|
|
1866 |
|
|
1867 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1868 |
name, ns, NULL, 0);
|
|
1869 |
|
|
1870 |
node = xmlNewChild(node, fctx->ns[NS_CALDAV],
|
|
1871 |
BAD_CAST "calendar-data", NULL);
|
|
1872 |
xmlNewProp(node, BAD_CAST "content-type", BAD_CAST "text/calendar");
|
|
1873 |
xmlNewProp(node, BAD_CAST "version", BAD_CAST "2.0");
|
| 1837 | 1874 |
|
| 1838 | 1875 |
return 0;
|
| 1839 | 1876 |
}
|
| 1840 | 1877 |
|
| 1841 | 1878 |
|
| 1842 | 1879 |
/* Callback to fetch CALDAV:schedule-tag */
|
| 1843 | |
static int propfind_schedtag(xmlNodePtr prop,
|
|
1880 |
static int propfind_schedtag(const xmlChar *name, xmlNsPtr ns,
|
| 1844 | 1881 |
struct propfind_ctx *fctx,
|
| 1845 | |
xmlNodePtr resp,
|
|
1882 |
xmlNodePtr resp __attribute__((unused)),
|
| 1846 | 1883 |
struct propstat propstat[],
|
| 1847 | 1884 |
void *rock __attribute__((unused)))
|
| 1848 | 1885 |
{
|
| 1849 | 1886 |
struct caldav_data *cdata = (struct caldav_data *) fctx->data;
|
| 1850 | 1887 |
|
| 1851 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 1852 | |
if (cdata->sched_tag) {
|
| 1853 | |
/* add DQUOTEs */
|
| 1854 | |
buf_reset(&fctx->buf);
|
| 1855 | |
buf_printf(&fctx->buf, "\"%s\"", cdata->sched_tag);
|
| 1856 | |
|
| 1857 | |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1858 | |
prop, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 1859 | |
}
|
| 1860 | |
else {
|
| 1861 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1862 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1863 | |
}
|
|
1888 |
if (!cdata->sched_tag) return HTTP_NOT_FOUND;
|
|
1889 |
|
|
1890 |
/* add DQUOTEs */
|
|
1891 |
buf_reset(&fctx->buf);
|
|
1892 |
buf_printf(&fctx->buf, "\"%s\"", cdata->sched_tag);
|
|
1893 |
|
|
1894 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1895 |
name, ns, BAD_CAST buf_cstring(&fctx->buf), 0);
|
| 1864 | 1896 |
|
| 1865 | 1897 |
return 0;
|
| 1866 | 1898 |
}
|
| 1867 | 1899 |
|
| 1868 | 1900 |
|
| 1869 | 1901 |
/* Callback to fetch CALDAV:calendar-user-address-set */
|
| 1870 | |
static int propfind_caluseraddr(xmlNodePtr prop,
|
|
1902 |
static int propfind_caluseraddr(const xmlChar *name, xmlNsPtr ns,
|
| 1871 | 1903 |
struct propfind_ctx *fctx,
|
| 1872 | |
xmlNodePtr resp,
|
|
1904 |
xmlNodePtr resp __attribute__((unused)),
|
| 1873 | 1905 |
struct propstat propstat[],
|
| 1874 | 1906 |
void *rock __attribute__((unused)))
|
| 1875 | 1907 |
{
|
| 1876 | 1908 |
xmlNodePtr node;
|
| 1877 | 1909 |
|
| 1878 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 1879 | |
if (fctx->userid) {
|
| 1880 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1881 | |
prop, NULL, 0);
|
| 1882 | |
|
| 1883 | |
/* XXX This needs to be done via an LDAP/DB lookup */
|
| 1884 | |
buf_reset(&fctx->buf);
|
| 1885 | |
buf_printf(&fctx->buf, "mailto:%s@%s", fctx->userid, config_servername);
|
| 1886 | |
|
| 1887 | |
xmlNewChild(node, fctx->ns[NS_DAV], BAD_CAST "href",
|
| 1888 | |
BAD_CAST buf_cstring(&fctx->buf));
|
| 1889 | |
}
|
| 1890 | |
else {
|
| 1891 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1892 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1893 | |
}
|
|
1910 |
if (!fctx->userid) return HTTP_NOT_FOUND;
|
|
1911 |
|
|
1912 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1913 |
name, ns, NULL, 0);
|
|
1914 |
|
|
1915 |
/* XXX This needs to be done via an LDAP/DB lookup */
|
|
1916 |
buf_reset(&fctx->buf);
|
|
1917 |
buf_printf(&fctx->buf, "mailto:%s@%s", fctx->userid, config_servername);
|
|
1918 |
|
|
1919 |
xmlNewChild(node, fctx->ns[NS_DAV], BAD_CAST "href",
|
|
1920 |
BAD_CAST buf_cstring(&fctx->buf));
|
| 1894 | 1921 |
|
| 1895 | 1922 |
return 0;
|
| 1896 | 1923 |
}
|
| 1897 | 1924 |
|
| 1898 | 1925 |
|
| 1899 | 1926 |
/* Callback to fetch CALDAV:schedule-calendar-transp */
|
| 1900 | |
static int propfind_caltransp(xmlNodePtr prop,
|
|
1927 |
static int propfind_caltransp(const xmlChar *name, xmlNsPtr ns,
|
| 1901 | 1928 |
struct propfind_ctx *fctx,
|
| 1902 | |
xmlNodePtr resp,
|
|
1929 |
xmlNodePtr resp __attribute__((unused)),
|
| 1903 | 1930 |
struct propstat propstat[],
|
| 1904 | 1931 |
void *rock __attribute__((unused)))
|
| 1905 | 1932 |
{
|
|
1933 |
const char *prop_annot = ANNOT_NS "CALDAV:schedule-calendar-transp";
|
| 1906 | 1934 |
struct annotation_data attrib;
|
| 1907 | 1935 |
const char *value = NULL;
|
|
1936 |
xmlNodePtr node;
|
| 1908 | 1937 |
int r = 0;
|
| 1909 | 1938 |
|
| 1910 | |
if ((fctx->req_tgt->namespace == URL_NS_CALENDAR) &&
|
| 1911 | |
fctx->req_tgt->collection && !fctx->req_tgt->resource) {
|
| 1912 | |
const char *prop_annot =
|
| 1913 | |
ANNOT_NS "CALDAV:schedule-calendar-transp";
|
| 1914 | |
|
| 1915 | |
if (!(r = annotatemore_lookup(fctx->mailbox->name, prop_annot,
|
| 1916 | |
/* shared */ "", &attrib))
|
| 1917 | |
&& attrib.value) {
|
| 1918 | |
value = attrib.value;
|
| 1919 | |
}
|
| 1920 | |
}
|
| 1921 | |
|
| 1922 | |
ensure_ns(fctx->ns, NS_CALDAV, resp->parent, XML_NS_CALDAV, "C");
|
| 1923 | |
if (r) {
|
| 1924 | |
xml_add_prop(HTTP_SERVER_ERROR, fctx->ns[NS_DAV],
|
| 1925 | |
&propstat[PROPSTAT_ERROR], prop, NULL, 0);
|
| 1926 | |
}
|
| 1927 | |
else if (value) {
|
| 1928 | |
xmlNodePtr node;
|
| 1929 | |
|
| 1930 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 1931 | |
prop, NULL, 0);
|
| 1932 | |
xmlNewChild(node, fctx->ns[NS_CALDAV], BAD_CAST value, NULL);
|
| 1933 | |
}
|
| 1934 | |
else {
|
| 1935 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 1936 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 1937 | |
}
|
|
1939 |
if (!fctx->req_tgt->collection) return HTTP_NOT_FOUND;
|
|
1940 |
|
|
1941 |
if (!(r = annotatemore_lookup(fctx->mailbox->name, prop_annot,
|
|
1942 |
/* shared */ "", &attrib)) && attrib.value) {
|
|
1943 |
value = attrib.value;
|
|
1944 |
}
|
|
1945 |
|
|
1946 |
if (r) return HTTP_SERVER_ERROR;
|
|
1947 |
if (!value) return HTTP_NOT_FOUND;
|
|
1948 |
|
|
1949 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
1950 |
name, ns, NULL, 0);
|
|
1951 |
xmlNewChild(node, fctx->ns[NS_CALDAV], BAD_CAST value, NULL);
|
| 1938 | 1952 |
|
| 1939 | 1953 |
return 0;
|
| 1940 | 1954 |
}
|
|
| 1968 | 1982 |
else {
|
| 1969 | 1983 |
/* Unknown value */
|
| 1970 | 1984 |
xml_add_prop(HTTP_CONFLICT, pctx->ns[NS_DAV],
|
| 1971 | |
&propstat[PROPSTAT_CONFLICT], prop, NULL, 0);
|
|
1985 |
&propstat[PROPSTAT_CONFLICT],
|
|
1986 |
prop->name, prop->ns, NULL, 0);
|
| 1972 | 1987 |
|
| 1973 | 1988 |
*pctx->ret = HTTP_FORBIDDEN;
|
| 1974 | 1989 |
|
|
| 1983 | 1998 |
strlen(transp), 0,
|
| 1984 | 1999 |
&pctx->tid)) {
|
| 1985 | 2000 |
xml_add_prop(HTTP_OK, pctx->ns[NS_DAV],
|
| 1986 | |
&propstat[PROPSTAT_OK], prop, NULL, 0);
|
|
2001 |
&propstat[PROPSTAT_OK], prop->name, prop->ns, NULL, 0);
|
| 1987 | 2002 |
}
|
| 1988 | 2003 |
else {
|
| 1989 | 2004 |
xml_add_prop(HTTP_SERVER_ERROR, pctx->ns[NS_DAV],
|
| 1990 | |
&propstat[PROPSTAT_ERROR], prop, NULL, 0);
|
|
2005 |
&propstat[PROPSTAT_ERROR],
|
|
2006 |
prop->name, prop->ns, NULL, 0);
|
| 1991 | 2007 |
}
|
| 1992 | 2008 |
}
|
| 1993 | 2009 |
else {
|
| 1994 | 2010 |
xml_add_prop(HTTP_FORBIDDEN, pctx->ns[NS_DAV],
|
| 1995 | |
&propstat[PROPSTAT_FORBID], prop, NULL, 0);
|
|
2011 |
&propstat[PROPSTAT_FORBID],
|
|
2012 |
prop->name, prop->ns, NULL, 0);
|
| 1996 | 2013 |
|
| 1997 | 2014 |
*pctx->ret = HTTP_FORBIDDEN;
|
| 1998 | 2015 |
}
|
|
| 2001 | 2018 |
}
|
| 2002 | 2019 |
|
| 2003 | 2020 |
|
|
2021 |
/* Callback to write calendar-timezone property */
|
|
2022 |
static int proppatch_timezone(xmlNodePtr prop, unsigned set,
|
|
2023 |
struct proppatch_ctx *pctx,
|
|
2024 |
struct propstat propstat[],
|
|
2025 |
void *rock __attribute__((unused)))
|
|
2026 |
{
|
|
2027 |
if ((pctx->req_tgt->namespace == URL_NS_CALENDAR) &&
|
|
2028 |
pctx->req_tgt->collection && !pctx->req_tgt->resource) {
|
|
2029 |
xmlChar *freeme = NULL;
|
|
2030 |
const char *value = NULL;
|
|
2031 |
size_t len = 0;
|
|
2032 |
unsigned valid = 1;
|
|
2033 |
|
|
2034 |
if (set) {
|
|
2035 |
icalcomponent *ical = NULL;
|
|
2036 |
|
|
2037 |
freeme = xmlNodeGetContent(prop);
|
|
2038 |
value = (const char *) freeme;
|
|
2039 |
len = strlen(value);
|
|
2040 |
|
|
2041 |
/* Parse and validate the iCal data */
|
|
2042 |
ical = icalparser_parse_string(value);
|
|
2043 |
if (!ical || (icalcomponent_isa(ical) != ICAL_VCALENDAR_COMPONENT)) {
|
|
2044 |
xml_add_prop(HTTP_FORBIDDEN, pctx->ns[NS_DAV],
|
|
2045 |
&propstat[PROPSTAT_FORBID],
|
|
2046 |
prop->name, prop->ns, NULL,
|
|
2047 |
CALDAV_VALID_DATA);
|
|
2048 |
*pctx->ret = HTTP_FORBIDDEN;
|
|
2049 |
valid = 0;
|
|
2050 |
}
|
|
2051 |
else if (!icalcomponent_get_first_component(ical,
|
|
2052 |
ICAL_VTIMEZONE_COMPONENT)
|
|
2053 |
|| icalcomponent_get_first_real_component(ical)) {
|
|
2054 |
xml_add_prop(HTTP_FORBIDDEN, pctx->ns[NS_DAV],
|
|
2055 |
&propstat[PROPSTAT_FORBID],
|
|
2056 |
prop->name, prop->ns, NULL,
|
|
2057 |
CALDAV_VALID_OBJECT);
|
|
2058 |
*pctx->ret = HTTP_FORBIDDEN;
|
|
2059 |
valid = 0;
|
|
2060 |
}
|
|
2061 |
}
|
|
2062 |
|
|
2063 |
if (valid) {
|
|
2064 |
buf_reset(&pctx->buf);
|
|
2065 |
buf_printf(&pctx->buf, ANNOT_NS "<%s>%s",
|
|
2066 |
(const char *) prop->ns->href, prop->name);
|
|
2067 |
|
|
2068 |
if (!annotatemore_write_entry(pctx->mailboxname,
|
|
2069 |
buf_cstring(&pctx->buf),
|
|
2070 |
/* shared */ "", value, NULL,
|
|
2071 |
len, 0, &pctx->tid)) {
|
|
2072 |
xml_add_prop(HTTP_OK, pctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
2073 |
prop->name, prop->ns, NULL, 0);
|
|
2074 |
}
|
|
2075 |
else {
|
|
2076 |
xml_add_prop(HTTP_SERVER_ERROR, pctx->ns[NS_DAV],
|
|
2077 |
&propstat[PROPSTAT_ERROR],
|
|
2078 |
prop->name, prop->ns, NULL, 0);
|
|
2079 |
}
|
|
2080 |
}
|
|
2081 |
|
|
2082 |
if (freeme) xmlFree(freeme);
|
|
2083 |
}
|
|
2084 |
else {
|
|
2085 |
xml_add_prop(HTTP_FORBIDDEN, pctx->ns[NS_DAV],
|
|
2086 |
&propstat[PROPSTAT_FORBID], prop->name, prop->ns, NULL, 0);
|
|
2087 |
|
|
2088 |
*pctx->ret = HTTP_FORBIDDEN;
|
|
2089 |
}
|
|
2090 |
|
|
2091 |
return 0;
|
|
2092 |
}
|
|
2093 |
|
|
2094 |
|
| 2004 | 2095 |
/* Callback to fetch CARDDAV:addressbook-home-set */
|
| 2005 | |
static int propfind_abookurl(xmlNodePtr prop,
|
|
2096 |
static int propfind_abookurl(const xmlChar *name, xmlNsPtr ns,
|
| 2006 | 2097 |
struct propfind_ctx *fctx,
|
| 2007 | |
xmlNodePtr resp,
|
|
2098 |
xmlNodePtr resp __attribute__((unused)),
|
| 2008 | 2099 |
struct propstat propstat[],
|
| 2009 | 2100 |
void *rock)
|
| 2010 | 2101 |
{
|
| 2011 | 2102 |
xmlNodePtr node;
|
| 2012 | 2103 |
const char *abook = (const char *) rock;
|
| 2013 | 2104 |
|
| 2014 | |
ensure_ns(fctx->ns, NS_CARDDAV, resp->parent, XML_NS_CARDDAV, "C");
|
| 2015 | |
if (fctx->userid &&
|
| 2016 | |
(fctx->req_tgt->namespace == URL_NS_PRINCIPAL)) {
|
| 2017 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 2018 | |
prop, NULL, 0);
|
| 2019 | |
|
| 2020 | |
buf_reset(&fctx->buf);
|
| 2021 | |
buf_printf(&fctx->buf, "%s/user/%s/%s", namespace_addressbook.prefix,
|
| 2022 | |
fctx->userid, abook ? abook : "");
|
| 2023 | |
|
| 2024 | |
xml_add_href(node, fctx->ns[NS_DAV], buf_cstring(&fctx->buf));
|
| 2025 | |
}
|
| 2026 | |
else {
|
| 2027 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 2028 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 2029 | |
}
|
|
2105 |
if (!fctx->userid) return HTTP_NOT_FOUND;
|
|
2106 |
|
|
2107 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
2108 |
name, ns, NULL, 0);
|
|
2109 |
|
|
2110 |
buf_reset(&fctx->buf);
|
|
2111 |
buf_printf(&fctx->buf, "%s/user/%s/%s", namespace_addressbook.prefix,
|
|
2112 |
fctx->userid, abook ? abook : "");
|
|
2113 |
|
|
2114 |
xml_add_href(node, fctx->ns[NS_DAV], buf_cstring(&fctx->buf));
|
| 2030 | 2115 |
|
| 2031 | 2116 |
return 0;
|
| 2032 | 2117 |
}
|
| 2033 | 2118 |
|
| 2034 | 2119 |
|
| 2035 | 2120 |
/* Callback to fetch CARDDAV:supported-address-data */
|
| 2036 | |
static int propfind_suppaddrdata(xmlNodePtr prop,
|
|
2121 |
static int propfind_suppaddrdata(const xmlChar *name, xmlNsPtr ns,
|
| 2037 | 2122 |
struct propfind_ctx *fctx,
|
| 2038 | 2123 |
xmlNodePtr resp __attribute__((unused)),
|
| 2039 | 2124 |
struct propstat propstat[],
|
|
| 2041 | 2126 |
{
|
| 2042 | 2127 |
xmlNodePtr node;
|
| 2043 | 2128 |
|
| 2044 | |
if ((fctx->req_tgt->namespace == URL_NS_ADDRESSBOOK) &&
|
| 2045 | |
fctx->req_tgt->collection && !fctx->req_tgt->resource) {
|
| 2046 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 2047 | |
prop, NULL, 0);
|
| 2048 | |
|
| 2049 | |
node = xmlNewChild(node, fctx->ns[NS_CARDDAV],
|
| 2050 | |
BAD_CAST "address-data-type", NULL);
|
| 2051 | |
xmlNewProp(node, BAD_CAST "content-type", BAD_CAST "text/vcard");
|
| 2052 | |
xmlNewProp(node, BAD_CAST "version", BAD_CAST "3.0");
|
| 2053 | |
}
|
| 2054 | |
else {
|
| 2055 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 2056 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 2057 | |
}
|
|
2129 |
if (!fctx->req_tgt->collection) return HTTP_NOT_FOUND;
|
|
2130 |
|
|
2131 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
2132 |
name, ns, NULL, 0);
|
|
2133 |
|
|
2134 |
node = xmlNewChild(node, fctx->ns[NS_CARDDAV],
|
|
2135 |
BAD_CAST "address-data-type", NULL);
|
|
2136 |
xmlNewProp(node, BAD_CAST "content-type", BAD_CAST "text/vcard");
|
|
2137 |
xmlNewProp(node, BAD_CAST "version", BAD_CAST "3.0");
|
| 2058 | 2138 |
|
| 2059 | 2139 |
return 0;
|
| 2060 | 2140 |
}
|
| 2061 | 2141 |
|
| 2062 | 2142 |
|
| 2063 | 2143 |
/* Callback to fetch properties from resource header */
|
| 2064 | |
static int propfind_fromhdr(xmlNodePtr prop,
|
|
2144 |
static int propfind_fromhdr(const xmlChar *name, xmlNsPtr ns,
|
| 2065 | 2145 |
struct propfind_ctx *fctx,
|
| 2066 | 2146 |
xmlNodePtr resp __attribute__((unused)),
|
| 2067 | 2147 |
struct propstat propstat[],
|
| 2068 | 2148 |
void *hdrname)
|
| 2069 | 2149 |
{
|
| 2070 | |
if (fctx->record) {
|
| 2071 | |
if (mailbox_cached_header((const char *) hdrname) != BIT32_MAX &&
|
| 2072 | |
!mailbox_cacherecord(fctx->mailbox, fctx->record)) {
|
| 2073 | |
unsigned size;
|
| 2074 | |
struct protstream *stream;
|
| 2075 | |
hdrcache_t hdrs = NULL;
|
| 2076 | |
const char **hdr;
|
| 2077 | |
|
| 2078 | |
size = cacheitem_size(fctx->record, CACHE_HEADERS);
|
| 2079 | |
stream = prot_readmap(cacheitem_base(fctx->record,
|
| 2080 | |
CACHE_HEADERS), size);
|
| 2081 | |
hdrs = spool_new_hdrcache();
|
| 2082 | |
spool_fill_hdrcache(stream, NULL, hdrs, NULL);
|
| 2083 | |
prot_free(stream);
|
| 2084 | |
|
| 2085 | |
if ((hdr = spool_getheader(hdrs, (const char *) hdrname))) {
|
| 2086 | |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 2087 | |
prop, BAD_CAST hdr[0], 0);
|
| 2088 | |
}
|
| 2089 | |
|
| 2090 | |
spool_free_hdrcache(hdrs);
|
| 2091 | |
|
| 2092 | |
if (hdr) return 0;
|
| 2093 | |
}
|
| 2094 | |
}
|
| 2095 | |
|
| 2096 | |
xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV], &propstat[PROPSTAT_NOTFOUND],
|
| 2097 | |
prop, NULL, 0);
|
| 2098 | |
|
| 2099 | |
return 0;
|
|
2150 |
int r = HTTP_NOT_FOUND;
|
|
2151 |
|
|
2152 |
if (!fctx->record) return HTTP_NOT_FOUND;
|
|
2153 |
|
|
2154 |
if (mailbox_cached_header((const char *) hdrname) != BIT32_MAX &&
|
|
2155 |
!mailbox_cacherecord(fctx->mailbox, fctx->record)) {
|
|
2156 |
unsigned size;
|
|
2157 |
struct protstream *stream;
|
|
2158 |
hdrcache_t hdrs = NULL;
|
|
2159 |
const char **hdr;
|
|
2160 |
|
|
2161 |
size = cacheitem_size(fctx->record, CACHE_HEADERS);
|
|
2162 |
stream = prot_readmap(cacheitem_base(fctx->record,
|
|
2163 |
CACHE_HEADERS), size);
|
|
2164 |
hdrs = spool_new_hdrcache();
|
|
2165 |
spool_fill_hdrcache(stream, NULL, hdrs, NULL);
|
|
2166 |
prot_free(stream);
|
|
2167 |
|
|
2168 |
if ((hdr = spool_getheader(hdrs, (const char *) hdrname))) {
|
|
2169 |
xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
2170 |
name, ns, BAD_CAST hdr[0], 0);
|
|
2171 |
r = 0;
|
|
2172 |
}
|
|
2173 |
|
|
2174 |
spool_free_hdrcache(hdrs);
|
|
2175 |
}
|
|
2176 |
|
|
2177 |
return r;
|
| 2100 | 2178 |
}
|
| 2101 | 2179 |
|
| 2102 | 2180 |
|
| 2103 | 2181 |
/* Callback to read a property from annotation DB */
|
| 2104 | |
static int propfind_fromdb(xmlNodePtr prop,
|
|
2182 |
static int propfind_fromdb(const xmlChar *name, xmlNsPtr ns,
|
| 2105 | 2183 |
struct propfind_ctx *fctx,
|
| 2106 | 2184 |
xmlNodePtr resp __attribute__((unused)),
|
| 2107 | 2185 |
struct propstat propstat[],
|
|
| 2113 | 2191 |
|
| 2114 | 2192 |
buf_reset(&fctx->buf);
|
| 2115 | 2193 |
buf_printf(&fctx->buf, ANNOT_NS "<%s>%s",
|
| 2116 | |
(const char *) prop->ns->href, prop->name);
|
|
2194 |
(const char *) ns->href, name);
|
| 2117 | 2195 |
|
| 2118 | 2196 |
memset(&attrib, 0, sizeof(struct annotation_data));
|
| 2119 | 2197 |
|
|
| 2121 | 2199 |
!(r = annotatemore_lookup(fctx->mailbox->name, buf_cstring(&fctx->buf),
|
| 2122 | 2200 |
/* shared */ "", &attrib))) {
|
| 2123 | 2201 |
if (!attrib.value &&
|
| 2124 | |
!xmlStrcmp(prop->name, BAD_CAST "displayname")) {
|
|
2202 |
!xmlStrcmp(name, BAD_CAST "displayname")) {
|
| 2125 | 2203 |
/* Special case empty displayname -- use last segment of path */
|
| 2126 | 2204 |
attrib.value = strrchr(fctx->mailbox->name, '.') + 1;
|
| 2127 | 2205 |
attrib.size = strlen(attrib.value);
|
| 2128 | 2206 |
}
|
| 2129 | 2207 |
}
|
| 2130 | 2208 |
|
| 2131 | |
if (r) {
|
| 2132 | |
node = xml_add_prop(HTTP_SERVER_ERROR, fctx->ns[NS_DAV],
|
| 2133 | |
&propstat[PROPSTAT_ERROR], prop, NULL, 0);
|
| 2134 | |
}
|
| 2135 | |
else if (attrib.value) {
|
| 2136 | |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 2137 | |
prop, NULL, 0);
|
| 2138 | |
xmlAddChild(node, xmlNewCDataBlock(fctx->root->doc,
|
| 2139 | |
BAD_CAST attrib.value, attrib.size));
|
| 2140 | |
}
|
| 2141 | |
else {
|
| 2142 | |
node = xml_add_prop(HTTP_NOT_FOUND, fctx->ns[NS_DAV],
|
| 2143 | |
&propstat[PROPSTAT_NOTFOUND], prop, NULL, 0);
|
| 2144 | |
}
|
|
2209 |
if (r) return HTTP_SERVER_ERROR;
|
|
2210 |
if (!attrib.value) return HTTP_NOT_FOUND;
|
|
2211 |
|
|
2212 |
node = xml_add_prop(HTTP_OK, fctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
|
2213 |
name, ns, NULL, 0);
|
|
2214 |
xmlAddChild(node, xmlNewCDataBlock(fctx->root->doc,
|
|
2215 |
BAD_CAST attrib.value, attrib.size));
|
| 2145 | 2216 |
|
| 2146 | 2217 |
return 0;
|
| 2147 | 2218 |
}
|
|
| 2173 | 2244 |
value, NULL, len, 0,
|
| 2174 | 2245 |
&pctx->tid))) {
|
| 2175 | 2246 |
xml_add_prop(HTTP_OK, pctx->ns[NS_DAV], &propstat[PROPSTAT_OK],
|
| 2176 | |
prop, NULL, 0);
|
|
2247 |
prop->name, prop->ns, NULL, 0);
|
| 2177 | 2248 |
}
|
| 2178 | 2249 |
else {
|
| 2179 | 2250 |
xml_add_prop(HTTP_SERVER_ERROR, pctx->ns[NS_DAV],
|
| 2180 | |
&propstat[PROPSTAT_ERROR], prop, NULL, 0);
|
|
2251 |
&propstat[PROPSTAT_ERROR], prop->name, prop->ns, NULL, 0);
|
| 2181 | 2252 |
}
|
| 2182 | 2253 |
|
| 2183 | 2254 |
if (freeme) xmlFree(freeme);
|
|
| 2189 | 2260 |
/* Array of known "live" properties */
|
| 2190 | 2261 |
static const struct prop_entry {
|
| 2191 | 2262 |
const char *name; /* Property name */
|
| 2192 | |
const char *ns; /* Property namespace */
|
| 2193 | |
unsigned allprop; /* Should we fetch for allprop? */
|
| 2194 | |
int (*get)(xmlNodePtr node, /* Callback to fetch property */
|
| 2195 | |
struct propfind_ctx *fctx, xmlNodePtr resp,
|
|
2263 |
unsigned ns; /* Property namespace */
|
|
2264 |
unsigned char flags; /* Flags for how/where props apply */
|
|
2265 |
int (*get)(const xmlChar *name, /* Callback to fetch property */
|
|
2266 |
xmlNsPtr ns, struct propfind_ctx *fctx, xmlNodePtr resp,
|
| 2196 | 2267 |
struct propstat propstat[], void *rock);
|
| 2197 | 2268 |
int (*put)(xmlNodePtr prop, /* Callback to write property */
|
| 2198 | 2269 |
unsigned set, struct proppatch_ctx *pctx,
|
|
| 2201 | 2272 |
} prop_entries[] = {
|
| 2202 | 2273 |
|
| 2203 | 2274 |
/* WebDAV (RFC 4918) properties */
|
| 2204 | |
{ "creationdate", XML_NS_DAV, 1, propfind_creationdate, NULL, NULL },
|
| 2205 | |
{ "displayname", XML_NS_DAV, 1, propfind_fromdb, proppatch_todb, NULL },
|
| 2206 | |
{ "getcontentlanguage", XML_NS_DAV, 1,
|
|
2275 |
{ "creationdate", NS_DAV,
|
|
2276 |
PROP_ALLPROP | PROP_COLLECTION | PROP_RESOURCE,
|
|
2277 |
propfind_creationdate, NULL, NULL },
|
|
2278 |
{ "displayname", NS_DAV,
|
|
2279 |
PROP_ALLPROP | PROP_PRINCIPAL | PROP_COLLECTION | PROP_RESOURCE,
|
|
2280 |
propfind_fromdb, proppatch_todb, NULL },
|
|
2281 |
{ "getcontentlanguage", NS_DAV, PROP_ALLPROP | PROP_RESOURCE,
|
| 2207 | 2282 |
propfind_fromhdr, NULL, "Content-Language" },
|
| 2208 | |
{ "getcontentlength", XML_NS_DAV, 1, propfind_getlength, NULL, NULL },
|
| 2209 | |
{ "getcontenttype", XML_NS_DAV, 1, propfind_fromhdr, NULL, "Content-Type" },
|
| 2210 | |
{ "getetag", XML_NS_DAV, 1, propfind_getetag, NULL, NULL },
|
| 2211 | |
{ "getlastmodified", XML_NS_DAV, 1, propfind_getlastmod, NULL, NULL },
|
| 2212 | |
{ "lockdiscovery", XML_NS_DAV, 1, propfind_lockdisc, NULL, NULL },
|
| 2213 | |
{ "resourcetype", XML_NS_DAV, 1,
|
|
2283 |
{ "getcontentlength", NS_DAV, PROP_ALLPROP | PROP_RESOURCE,
|
|
2284 |
propfind_getlength, NULL, NULL },
|
|
2285 |
{ "getcontenttype", NS_DAV,
|
|
2286 |
PROP_ALLPROP | PROP_COLLECTION | PROP_RESOURCE,
|
|
2287 |
propfind_getcontenttype, NULL, "Content-Type" },
|
|
2288 |
{ "getetag", NS_DAV, PROP_ALLPROP | PROP_COLLECTION | PROP_RESOURCE,
|
|
2289 |
propfind_getetag, NULL, NULL },
|
|
2290 |
{ "getlastmodified", NS_DAV,
|
|
2291 |
PROP_ALLPROP | /*PROP_COLLECTION |*/ PROP_RESOURCE,
|
|
2292 |
propfind_getlastmod, NULL, NULL },
|
|
2293 |
{ "lockdiscovery", NS_DAV, PROP_ALLPROP | PROP_RESOURCE,
|
|
2294 |
propfind_lockdisc, NULL, NULL },
|
|
2295 |
{ "resourcetype", NS_DAV,
|
|
2296 |
PROP_ALLPROP | PROP_PRINCIPAL | PROP_COLLECTION | PROP_RESOURCE,
|
| 2214 | 2297 |
propfind_restype, proppatch_restype, NULL },
|
| 2215 | |
{ "supportedlock", XML_NS_DAV, 1, propfind_suplock, NULL, NULL },
|
|
2298 |
{ "supportedlock", NS_DAV, PROP_ALLPROP | PROP_RESOURCE,
|
|
2299 |
propfind_suplock, NULL, NULL },
|
| 2216 | 2300 |
|
| 2217 | 2301 |
/* WebDAV Versioning (RFC 3253) properties */
|
| 2218 | |
{ "supported-report-set", XML_NS_DAV, 0, propfind_reportset, NULL, NULL },
|
|
2302 |
{ "supported-report-set", NS_DAV, PROP_PRINCIPAL | PROP_COLLECTION,
|
|
2303 |
propfind_reportset, NULL, NULL },
|
| 2219 | 2304 |
|
| 2220 | 2305 |
/* WebDAV ACL (RFC 3744) properties */
|
| 2221 | |
{ "alternate-URI-set", XML_NS_DAV, 0, NULL, NULL, NULL },
|
| 2222 | |
{ "principal-URL", XML_NS_DAV, 0, propfind_principalurl, NULL, NULL },
|
| 2223 | |
{ "group-member-set", XML_NS_DAV, 0, NULL, NULL, NULL },
|
| 2224 | |
{ "group-membership", XML_NS_DAV, 0, NULL, NULL, NULL },
|
| 2225 | |
{ "owner", XML_NS_DAV, 0, propfind_owner, NULL, NULL },
|
| 2226 | |
{ "group", XML_NS_DAV, 0, NULL, NULL, NULL },
|
| 2227 | |
{ "supported-privilege-set", XML_NS_DAV, 0,
|
|
2306 |
{ "alternate-URI-set", NS_DAV, 0, NULL, NULL, NULL },
|
|
2307 |
{ "principal-URL", NS_DAV, PROP_PRINCIPAL,
|
|
2308 |
propfind_principalurl, NULL, NULL },
|
|
2309 |
{ "group-member-set", NS_DAV, 0, NULL, NULL, NULL },
|
|
2310 |
{ "group-membership", NS_DAV, 0, NULL, NULL, NULL },
|
|
2311 |
{ "owner", NS_DAV, PROP_COLLECTION | PROP_RESOURCE,
|
|
2312 |
propfind_owner, NULL, NULL },
|
|
2313 |
{ "group", NS_DAV, 0, NULL, NULL, NULL },
|
|
2314 |
{ "supported-privilege-set", NS_DAV, PROP_COLLECTION | PROP_RESOURCE,
|
| 2228 | 2315 |
propfind_supprivset, NULL, NULL },
|
| 2229 | |
{ "current-user-privilege-set", XML_NS_DAV, 0,
|
|
2316 |
{ "current-user-privilege-set", NS_DAV, PROP_COLLECTION | PROP_RESOURCE,
|
| 2230 | 2317 |
propfind_curprivset, NULL, NULL },
|
| 2231 | |
{ "acl", XML_NS_DAV, 0, propfind_acl, NULL, NULL },
|
| 2232 | |
{ "acl-restrictions", XML_NS_DAV, 0, propfind_aclrestrict, NULL, NULL },
|
| 2233 | |
{ "inherited-acl-set", XML_NS_DAV, 0, NULL, NULL, NULL },
|
| 2234 | |
{ "principal-collection-set", XML_NS_DAV, 0,
|
|
2318 |
{ "acl", NS_DAV, PROP_COLLECTION | PROP_RESOURCE,
|
|
2319 |
propfind_acl, NULL, NULL },
|
|
2320 |
{ "acl-restrictions", NS_DAV, PROP_COLLECTION | PROP_RESOURCE,
|
|
2321 |
propfind_aclrestrict, NULL, NULL },
|
|
2322 |
{ "inherited-acl-set", NS_DAV, 0, NULL, NULL, NULL },
|
|
2323 |
{ "principal-collection-set", NS_DAV,
|
|
2324 |
PROP_ROOT | PROP_PRINCIPAL | PROP_COLLECTION | PROP_RESOURCE,
|
| 2235 | 2325 |
propfind_princolset, NULL, NULL },
|
| 2236 | 2326 |
|
| 2237 | 2327 |
/* WebDAV Quota (RFC 4331) properties */
|
| 2238 | |
{ "quota-available-bytes", XML_NS_DAV, 0, propfind_quota, NULL, NULL },
|
| 2239 | |
{ "quota-used-bytes", XML_NS_DAV, 0, propfind_quota, NULL, NULL },
|
|
2328 |
{ "quota-available-bytes", NS_DAV, PROP_COLLECTION,
|
|
2329 |
propfind_quota, NULL, NULL },
|
|
2330 |
{ "quota-used-bytes", NS_DAV, PROP_COLLECTION,
|
|
2331 |
propfind_quota, NULL, NULL },
|
| 2240 | 2332 |
|
| 2241 | 2333 |
/* WebDAV Current Principal (RFC 5397) properties */
|
| 2242 | |
{ "current-user-principal", XML_NS_DAV, 0, propfind_curprin, NULL, NULL },
|
|
2334 |
{ "current-user-principal", NS_DAV,
|
|
2335 |
PROP_ROOT | PROP_PRINCIPAL | PROP_COLLECTION | PROP_RESOURCE,
|
|
2336 |
propfind_curprin, NULL, NULL },
|
| 2243 | 2337 |
|
| 2244 | 2338 |
/* WebDAV POST (RFC 5995) properties */
|
| 2245 | |
{ "add-member", XML_NS_DAV, 0, propfind_addmember, NULL, NULL },
|
|
2339 |
{ "add-member", NS_DAV, PROP_COLLECTION
|
|
2340 |
| PROP_CALENDAR, /* Until Apple Contacts is fixed */
|
|
2341 |
propfind_addmember, NULL, NULL },
|
| 2246 | 2342 |
|
| 2247 | 2343 |
/* WebDAV Sync (RFC 6578) properties */
|
| 2248 | |
{ "sync-token", XML_NS_DAV, 1, propfind_sync_token, NULL, NULL },
|
|
2344 |
{ "sync-token", NS_DAV, PROP_COLLECTION,
|
|
2345 |
propfind_sync_token, NULL, NULL },
|
| 2249 | 2346 |
|
| 2250 | 2347 |
/* CalDAV (RFC 4791) properties */
|
| 2251 | |
{ "calendar-data", XML_NS_CALDAV, 0, propfind_getdata, NULL, NULL },
|
| 2252 | |
{ "calendar-description", XML_NS_CALDAV, 0,
|
|
2348 |
{ "calendar-data", NS_CALDAV, PROP_RESOURCE | PROP_CALENDAR,
|
|
2349 |
propfind_getdata, NULL, NULL },
|
|
2350 |
{ "calendar-description", NS_CALDAV, PROP_COLLECTION | PROP_CALENDAR,
|
| 2253 | 2351 |
propfind_fromdb, proppatch_todb, NULL },
|
| 2254 | |
{ "calendar-home-set", XML_NS_CALDAV, 0, propfind_calurl, NULL, NULL },
|
| 2255 | |
{ "calendar-timezone", XML_NS_CALDAV, 0,
|
|
2352 |
{ "calendar-home-set", NS_CALDAV, PROP_PRINCIPAL,
|
|
2353 |
propfind_calurl, NULL, NULL },
|
|
2354 |
{ "calendar-timezone", NS_CALDAV, PROP_COLLECTION | PROP_CALENDAR,
|
|
2355 |
propfind_fromdb, proppatch_timezone, NULL },
|
|
2356 |
{ "supported-calendar-component-set", NS_CALDAV,
|
|
2357 |
PROP_COLLECTION | PROP_CALENDAR,
|
|
2358 |
propfind_calcompset, proppatch_calcompset, NULL },
|
|
2359 |
{ "supported-calendar-data", NS_CALDAV, PROP_COLLECTION | PROP_CALENDAR,
|
|
2360 |
propfind_suppcaldata, NULL, NULL },
|
|
2361 |
{ "max-resource-size", NS_CALDAV, 0, NULL, NULL, NULL },
|
|
2362 |
{ "min-date-time", NS_CALDAV, 0, NULL, NULL, NULL },
|
|
2363 |
{ "max-date-time", NS_CALDAV, 0, NULL, NULL, NULL },
|
|
2364 |
{ "max-instances", NS_CALDAV, 0, NULL, NULL, NULL },
|
|
2365 |
{ "max-attendees-per-instance", NS_CALDAV, 0, NULL, NULL, NULL },
|
|
2366 |
|
|
2367 |
/* CalDAV Scheduling (RFC 6638) properties */
|
|
2368 |
{ "schedule-tag", NS_CALDAV, PROP_RESOURCE | PROP_CALENDAR,
|
|
2369 |
propfind_schedtag, NULL, NULL },
|
|
2370 |
{ "schedule-inbox-URL", NS_CALDAV, PROP_PRINCIPAL,
|
|
2371 |
propfind_calurl, NULL, SCHED_INBOX },
|
|
2372 |
{ "schedule-outbox-URL", NS_CALDAV, PROP_PRINCIPAL,
|
|
2373 |
propfind_calurl, NULL, SCHED_OUTBOX },
|
|
2374 |
{ "schedule-default-calendar-URL", NS_CALDAV, PROP_COLLECTION,
|
|
2375 |
propfind_calurl, NULL, SCHED_DEFAULT },
|
|
2376 |
{ "schedule-calendar-transp", NS_CALDAV,
|
|
2377 |
PROP_COLLECTION | PROP_CALENDAR,
|
|
2378 |
propfind_caltransp, proppatch_caltransp, NULL },
|
|
2379 |
{ "calendar-user-address-set", NS_CALDAV, PROP_PRINCIPAL,
|
|
2380 |
propfind_caluseraddr, NULL, NULL },
|
|
2381 |
{ "calendar-user-type", NS_CALDAV, 0, NULL, NULL, NULL },
|
|
2382 |
|
|
2383 |
/* CardDAV (RFC 6352) properties */
|
|
2384 |
{ "address-data", NS_CARDDAV, PROP_RESOURCE | PROP_ADDRESSBOOK,
|
|
2385 |
propfind_getdata, NULL, NULL },
|
|
2386 |
{ "addressbook-description", NS_CARDDAV,
|
|
2387 |
PROP_COLLECTION | PROP_ADDRESSBOOK,
|
| 2256 | 2388 |
propfind_fromdb, proppatch_todb, NULL },
|
| 2257 | |
{ "supported-calendar-component-set", XML_NS_CALDAV, 0,
|
| 2258 | |
propfind_calcompset, proppatch_calcompset, NULL },
|
| 2259 | |
{ "supported-calendar-data", XML_NS_CALDAV, 0,
|
| 2260 | |
propfind_suppcaldata, NULL, NULL },
|
| 2261 | |
{ "max-resource-size", XML_NS_CALDAV, 0, NULL, NULL, NULL },
|
| 2262 | |
{ "min-date-time", XML_NS_CALDAV, 0, NULL, NULL, NULL },
|
| 2263 | |
{ "max-date-time", XML_NS_CALDAV, 0, NULL, NULL, NULL },
|
| 2264 | |
{ "max-instances", XML_NS_CALDAV, 0, NULL, NULL, NULL },
|
| 2265 | |
{ "max-attendees-per-instance", XML_NS_CALDAV, 0, NULL, NULL, NULL },
|
| 2266 | |
|
| 2267 | |
/* CalDAV Scheduling (RFC 6638) properties */
|
| 2268 | |
{ "schedule-tag", XML_NS_CALDAV, 0, propfind_schedtag, NULL, NULL },
|
| 2269 | |
{ "schedule-inbox-URL", XML_NS_CALDAV, 0,
|
| 2270 | |
propfind_calurl, NULL, SCHED_INBOX },
|
| 2271 | |
{ "schedule-outbox-URL", XML_NS_CALDAV, 0,
|
| 2272 | |
propfind_calurl, NULL, SCHED_OUTBOX },
|
| 2273 | |
{ "schedule-default-calendar-URL", XML_NS_CALDAV, 0,
|
| 2274 | |
propfind_calurl, NULL, SCHED_DEFAULT },
|
| 2275 | |
{ "schedule-calendar-transp", XML_NS_CALDAV, 0,
|
| 2276 | |
propfind_caltransp, proppatch_caltransp, NULL },
|
| 2277 | |
{ "calendar-user-address-set", XML_NS_CALDAV, 0,
|
| 2278 | |
propfind_caluseraddr, NULL, NULL },
|
| 2279 | |
{ "calendar-user-type", XML_NS_CALDAV, 0, NULL, NULL, NULL },
|
| 2280 | |
|
| 2281 | |
/* CardDAV (RFC 6352) properties */
|
| 2282 | |
{ "address-data", XML_NS_CARDDAV, 0, propfind_getdata, NULL, NULL },
|
| 2283 | |
{ "addressbook-description", XML_NS_CARDDAV, 0,
|
| 2284 | |
propfind_fromdb, proppatch_todb, NULL },
|
| 2285 | |
{ "addressbook-home-set", XML_NS_CARDDAV, 0,
|
|
2389 |
{ "addressbook-home-set", NS_CARDDAV, PROP_PRINCIPAL,
|
| 2286 | 2390 |
propfind_abookurl, NULL, NULL },
|
| 2287 | |
{ "supported-address-data", XML_NS_CARDDAV, 0,
|
|
2391 |
{ "supported-address-data", NS_CARDDAV,
|
|
2392 |
PROP_COLLECTION | PROP_ADDRESSBOOK,
|
| 2288 | 2393 |
propfind_suppaddrdata, NULL, NULL },
|
| 2289 | |
{ "max-resource-size", XML_NS_CARDDAV, 0, NULL, NULL, NULL },
|
|
2394 |
{ "max-resource-size", NS_CARDDAV, 0, NULL, NULL, NULL },
|
| 2290 | 2395 |
|
| 2291 | 2396 |
/* Apple Calendar Server properties */
|
| 2292 | |
{ "getctag", XML_NS_CS, 1, propfind_sync_token, NULL, NULL },
|
| 2293 | |
|
| 2294 | |
/* Apple iCal properties */
|
| 2295 | |
{ "calendar-color", XML_NS_ICAL, 0,
|
| 2296 | |
propfind_fromdb, proppatch_todb, NULL },
|
| 2297 | |
{ "calendar-order", XML_NS_ICAL, 0,
|
| 2298 | |
propfind_fromdb, proppatch_todb, NULL },
|
| 2299 | |
|
| 2300 | |
{ NULL, NULL, 0, NULL, NULL, NULL }
|
|
2397 |
{ "getctag", NS_CS, PROP_ALLPROP | PROP_COLLECTION,
|
|
2398 |
propfind_sync_token, NULL, NULL },
|
|
2399 |
|
|
2400 |
{ NULL, 0, 0, NULL, NULL, NULL }
|
| 2301 | 2401 |
};
|
|
2402 |
|
|
2403 |
|
|
2404 |
/* annotemore_findall callback for adding dead properties (allprop/propname) */
|
|
2405 |
static int allprop_cb(const char *mailbox __attribute__((unused)),
|
|
2406 |
const char *entry,
|
|
2407 |
const char *userid, struct annotation_data *attrib,
|
|
2408 |
void *rock)
|
|
2409 |
{
|
|
2410 |
struct allprop_rock *arock = (struct allprop_rock *) rock;
|
|
2411 |
const struct prop_entry *pentry;
|
|
2412 |
char *href, *name;
|
|
2413 |
xmlNsPtr ns;
|
|
2414 |
xmlNodePtr node;
|
|
2415 |
|
|
2416 |
/* Make sure its a shared entry or the user's private one */
|
|
2417 |
if (*userid && strcmp(userid, arock->fctx->userid)) return 0;
|
|
2418 |
|
|
2419 |
/* Split entry into namespace href and name ( <href>name ) */
|
|
2420 |
buf_setcstr(&arock->fctx->buf, entry + strlen(ANNOT_NS) + 1);
|
|
2421 |
href = (char *) buf_cstring(&arock->fctx->buf);
|
|
2422 |
if ((name = strchr(href, '>'))) *name++ = '\0';
|
|
2423 |
|
|
2424 |
/* Look for a match against live properties */
|
|
2425 |
for (pentry = prop_entries;
|
|
2426 |
pentry->name &&
|
|
2427 |
(strcmp(name, pentry->name) ||
|
|
2428 |
strcmp(href, known_namespaces[pentry->ns].href));
|
|
2429 |
pentry++);
|
|
2430 |
|
|
2431 |
if (pentry->name &&
|
|
2432 |
(arock->fctx->mode == PROPFIND_ALL /* Skip all live properties */
|
|
2433 |
|| (pentry->flags & PROP_ALLPROP))) /* Skip those already included */
|
|
2434 |
return 0;
|
|
2435 |
|
|
2436 |
/* Look for an instance of this namespace in our response */
|
|
2437 |
ns = hash_lookup(href, arock->fctx->ns_table);
|
|
2438 |
if (!ns) {
|
|
2439 |
char prefix[5];
|
|
2440 |
snprintf(prefix, sizeof(prefix), "X%u", arock->fctx->prefix_count++);
|
|
2441 |
ns = xmlNewNs(arock->fctx->root, BAD_CAST href, BAD_CAST prefix);
|
|
2442 |
hash_insert(href, ns, arock->fctx->ns_table);
|
|
2443 |
}
|
|
2444 |
|
|
2445 |
/* Add the dead property to the response */
|
|
2446 |
node = xml_add_prop(HTTP_OK, arock->fctx->ns[NS_DAV],
|
|
2447 |
&arock->propstat[PROPSTAT_OK],
|
|
2448 |
BAD_CAST name, ns, NULL, 0);
|
|
2449 |
|
|
2450 |
if (arock->fctx->mode == PROPFIND_ALL) {
|
|
2451 |
xmlAddChild(node, xmlNewCDataBlock(arock->fctx->root->doc,
|
|
2452 |
BAD_CAST attrib->value,
|
|
2453 |
attrib->size));
|
|
2454 |
}
|
|
2455 |
|
|
2456 |
return 0;
|
|
2457 |
}
|
|
2458 |
|
|
2459 |
|
|
2460 |
static int prescreen_prop(const struct prop_entry *entry,
|
|
2461 |
xmlNodePtr prop,
|
|
2462 |
struct propfind_ctx *fctx)
|
|
2463 |
{
|
|
2464 |
xmlChar *type = NULL, *ver = NULL;
|
|
2465 |
unsigned allowed = 1;
|
|
2466 |
|
|
2467 |
switch (fctx->req_tgt->namespace) {
|
|
2468 |
case URL_NS_PRINCIPAL:
|
|
2469 |
if (!(entry->flags & PROP_PRINCIPAL)) allowed = 0;
|
|
2470 |
break;
|
|
2471 |
|
|
2472 |
case URL_NS_CALENDAR:
|
|
2473 |
if ((entry->flags & PROP_ADDRESSBOOK) ||
|
|
2474 |
(fctx->req_tgt->resource &&
|
|
2475 |
!(entry->flags & PROP_RESOURCE))) {
|
|
2476 |
allowed = 0;
|
|
2477 |
}
|
|
2478 |
|
|
2479 |
/* Sanity check any calendar-data "property" request */
|
|
2480 |
else if (prop && !xmlStrcmp(prop->name, BAD_CAST "calendar-data") &&
|
|
2481 |
(((type = xmlGetProp(prop, BAD_CAST "content-type"))
|
|
2482 |
&& xmlStrcmp(type, BAD_CAST "text/calendar")) ||
|
|
2483 |
((ver = xmlGetProp(prop, BAD_CAST "version")) &&
|
|
2484 |
xmlStrcmp(ver, BAD_CAST "2.0")))) {
|
|
2485 |
allowed = 0;
|
|
2486 |
fctx->err->precond = CALDAV_SUPP_DATA;
|
|
2487 |
*fctx->ret = HTTP_FORBIDDEN;
|
|
2488 |
}
|
|
2489 |
break;
|
|
2490 |
|
|
2491 |
case URL_NS_ADDRESSBOOK:
|
|
2492 |
if ((entry->flags & PROP_CALENDAR) ||
|
|
2493 |
(fctx->req_tgt->resource &&
|
|
2494 |
!(entry->flags & PROP_RESOURCE))) {
|
|
2495 |
allowed = 0;
|
|
2496 |
}
|
|
2497 |
|
|
2498 |
/* Sanity check any address-data "property" request */
|
|
2499 |
else if (prop && !xmlStrcmp(prop->name, BAD_CAST "address-data") &&
|
|
2500 |
(((type = xmlGetProp(prop, BAD_CAST "content-type"))
|
|
2501 |
&& xmlStrcmp(type, BAD_CAST "text/vcard")) ||
|
|
2502 |
((ver = xmlGetProp(prop, BAD_CAST "version")) &&
|
|
2503 |
xmlStrcmp(ver, BAD_CAST "3.0")))) {
|
|
2504 |
allowed = 0;
|
|
2505 |
fctx->err->precond = CALDAV_SUPP_DATA;
|
|
2506 |
*fctx->ret = HTTP_FORBIDDEN;
|
|
2507 |
}
|
|
2508 |
break;
|
|
2509 |
|
|
2510 |
default:
|
|
2511 |
if (!(entry->flags & PROP_ROOT)) allowed = 0;
|
|
2512 |
break;
|
|
2513 |
}
|
|
2514 |
|
|
2515 |
if (type) xmlFree(type);
|
|
2516 |
if (ver) xmlFree(ver);
|
|
2517 |
|
|
2518 |
return allowed;
|
|
2519 |
}
|
| 2302 | 2520 |
|
| 2303 | 2521 |
|
| 2304 | 2522 |
/* Parse the requested properties and create a linked list of fetch callbacks.
|
|
| 2306 | 2524 |
*/
|
| 2307 | 2525 |
static int preload_proplist(xmlNodePtr proplist, struct propfind_ctx *fctx)
|
| 2308 | 2526 |
{
|
|
2527 |
int ret = 0;
|
| 2309 | 2528 |
xmlNodePtr prop;
|
| 2310 | 2529 |
const struct prop_entry *entry;
|
| 2311 | 2530 |
|
|
2531 |
if (fctx->mode == PROPFIND_ALL || fctx->mode == PROPFIND_NAME) {
|
|
2532 |
xmlNsPtr nsDef;
|
|
2533 |
|
|
2534 |
/* Add live properties for allprop/propname */
|
|
2535 |
for (entry = prop_entries; entry->name; entry++) {
|
|
2536 |
if (entry->flags & PROP_ALLPROP) {
|
|
2537 |
/* Pre-screen request based on prop flags */
|
|
2538 |
int allowed = prescreen_prop(entry, NULL, fctx);
|
|
2539 |
|
|
2540 |
if (allowed || fctx->mode == PROP_ALLPROP) {
|
|
2541 |
struct propfind_entry_list *nentry =
|
|
2542 |
xzmalloc(sizeof(struct propfind_entry_list));
|
|
2543 |
|
|
2544 |
ensure_ns(fctx->ns, entry->ns, fctx->root,
|
|
2545 |
known_namespaces[entry->ns].href,
|
|
2546 |
known_namespaces[entry->ns].prefix);
|
|
2547 |
|
|
2548 |
nentry->name = BAD_CAST entry->name;
|
|
2549 |
nentry->ns = fctx->ns[entry->ns];
|
|
2550 |
if (allowed) {
|
|
2551 |
nentry->flags = entry->flags;
|
|
2552 |
nentry->get = entry->get;
|
|
2553 |
nentry->rock = entry->rock;
|
|
2554 |
}
|
|
2555 |
nentry->next = fctx->elist;
|
|
2556 |
fctx->elist = nentry;
|
|
2557 |
}
|
|
2558 |
}
|
|
2559 |
}
|
|
2560 |
|
|
2561 |
/* Add all namespaces attached to the response to our hash table */
|
|
2562 |
construct_hash_table(fctx->ns_table, 10, 1);
|
|
2563 |
|
|
2564 |
for (nsDef = fctx->root->nsDef; nsDef; nsDef = nsDef->next) {
|
|
2565 |
hash_insert((const char *) nsDef->href, nsDef, fctx->ns_table);
|
|
2566 |
}
|
|
2567 |
}
|
|
2568 |
|
| 2312 | 2569 |
/* Iterate through requested properties */
|
| 2313 | |
for (prop = proplist; prop; prop = prop->next) {
|
|
2570 |
for (prop = proplist; !*fctx->ret && prop; prop = prop->next) {
|
| 2314 | 2571 |
if (prop->type == XML_ELEMENT_NODE) {
|
| 2315 | |
struct propfind_entry_list *nentry =
|
| 2316 | |
xzmalloc(sizeof(struct propfind_entry_list));
|
|
2572 |
struct propfind_entry_list *nentry;
|
| 2317 | 2573 |
|
| 2318 | 2574 |
/* Look for a match against our known properties */
|
| 2319 | 2575 |
for (entry = prop_entries;
|
| 2320 | 2576 |
entry->name &&
|
| 2321 | 2577 |
(strcmp((const char *) prop->name, entry->name) ||
|
| 2322 | |
strcmp((const char *) prop->ns->href, entry->ns));
|
|
2578 |
strcmp((const char *) prop->ns->href,
|
|
2579 |
known_namespaces[entry->ns].href));
|
| 2323 | 2580 |
entry++);
|
| 2324 | 2581 |
|
| 2325 | |
nentry->prop = prop;
|
|
2582 |
/* Skip properties already included by allprop */
|
|
2583 |
if (fctx->mode == PROPFIND_ALL && (entry->flags & PROP_ALLPROP))
|
|
2584 |
continue;
|
|
2585 |
|
|
2586 |
nentry = xzmalloc(sizeof(struct propfind_entry_list));
|
|
2587 |
nentry->name = prop->name;
|
|
2588 |
nentry->ns = prop->ns;
|
| 2326 | 2589 |
if (entry->name) {
|
| 2327 | |
/* Found a match */
|
| 2328 | |
nentry->get = entry->get;
|
| 2329 | |
nentry->rock = entry->rock;
|
|
2590 |
/* Found a match - Pre-screen request based on prop flags */
|
|
2591 |
if (prescreen_prop(entry, prop, fctx)) {
|
|
2592 |
nentry->flags = entry->flags;
|
|
2593 |
nentry->get = entry->get;
|
|
2594 |
nentry->rock = entry->rock;
|
|
2595 |
}
|
| 2330 | 2596 |
}
|
| 2331 | 2597 |
else {
|
| 2332 | 2598 |
/* No match, treat as a dead property */
|
|
2599 |
nentry->flags = PROP_COLLECTION;
|
| 2333 | 2600 |
nentry->get = propfind_fromdb;
|
| 2334 | 2601 |
nentry->rock = NULL;
|
| 2335 | 2602 |
}
|
|
| 2338 | 2605 |
}
|
| 2339 | 2606 |
}
|
| 2340 | 2607 |
|
| 2341 | |
return 0;
|
|
2608 |
return ret;
|
| 2342 | 2609 |
}
|
| 2343 | 2610 |
|
| 2344 | 2611 |
|
|
| 2361 | 2628 |
!xmlStrcmp(instr->name, BAD_CAST "remove")) set = 0;
|
| 2362 | 2629 |
else {
|
| 2363 | 2630 |
syslog(LOG_INFO, "Unknown PROPPATCH instruction");
|
| 2364 | |
*pctx->errstr = "Unknown PROPPATCH instruction";
|
|
2631 |
pctx->err->desc = "Unknown PROPPATCH instruction";
|
| 2365 | 2632 |
return HTTP_BAD_REQUEST;
|
| 2366 | 2633 |
}
|
| 2367 | 2634 |
|
|
| 2369 | 2636 |
for (prop = instr->children;
|
| 2370 | 2637 |
prop && prop->type != XML_ELEMENT_NODE; prop = prop->next);
|
| 2371 | 2638 |
if (!prop || xmlStrcmp(prop->name, BAD_CAST "prop")) {
|
| 2372 | |
*pctx->errstr = "Missing prop element";
|
|
2639 |
pctx->err->desc = "Missing prop element";
|
| 2373 | 2640 |
return HTTP_BAD_REQUEST;
|
| 2374 | 2641 |
}
|
| 2375 | 2642 |
|
|
| 2382 | 2649 |
for (entry = prop_entries;
|
| 2383 | 2650 |
entry->name &&
|
| 2384 | 2651 |
(strcmp((const char *) prop->name, entry->name) ||
|
| 2385 | |
strcmp((const char *) prop->ns->href, entry->ns));
|
|
2652 |
strcmp((const char *) prop->ns->href,
|
|
2653 |
known_namespaces[entry->ns].href));
|
| 2386 | 2654 |
entry++);
|
| 2387 | 2655 |
|
| 2388 | 2656 |
if (entry->name) {
|
|
| 2390 | 2658 |
/* Protected property */
|
| 2391 | 2659 |
xml_add_prop(HTTP_FORBIDDEN, pctx->ns[NS_DAV],
|
| 2392 | 2660 |
&propstat[PROPSTAT_FORBID],
|
| 2393 | |
prop, NULL,
|
|
2661 |
prop->name, prop->ns, NULL,
|
| 2394 | 2662 |
DAV_PROT_PROP);
|
| 2395 | 2663 |
*pctx->ret = HTTP_FORBIDDEN;
|
| 2396 | 2664 |
}
|
|
| 2556 | 2824 |
/* Remote mailbox */
|
| 2557 | 2825 |
struct backend *be;
|
| 2558 | 2826 |
|
| 2559 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
2827 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 2560 | 2828 |
&backend_cached, NULL, NULL, httpd_in);
|
| 2561 | 2829 |
if (!be) return HTTP_UNAVAILABLE;
|
| 2562 | 2830 |
|
|
| 2648 | 2916 |
}
|
| 2649 | 2917 |
|
| 2650 | 2918 |
if (!xmlStrcmp(prin->name, BAD_CAST "self")) {
|
| 2651 | |
userid = httpd_userid;
|
|
2919 |
userid = proxy_userid;
|
| 2652 | 2920 |
}
|
| 2653 | 2921 |
#if 0 /* XXX Do we need to support this? */
|
| 2654 | 2922 |
else if (!xmlStrcmp(prin->name, BAD_CAST "owner")) {
|
|
| 2888 | 3156 |
|
| 2889 | 3157 |
if (server) {
|
| 2890 | 3158 |
/* Remote source mailbox */
|
| 2891 | |
src_be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
3159 |
src_be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 2892 | 3160 |
&backend_cached, NULL, NULL, httpd_in);
|
| 2893 | 3161 |
if (!src_be) return HTTP_UNAVAILABLE;
|
| 2894 | 3162 |
}
|
|
| 2919 | 3187 |
|
| 2920 | 3188 |
if (server) {
|
| 2921 | 3189 |
/* Remote destination mailbox */
|
| 2922 | |
dest_be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
3190 |
dest_be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 2923 | 3191 |
&backend_cached, NULL, NULL, httpd_in);
|
| 2924 | 3192 |
if (!dest_be) return HTTP_UNAVAILABLE;
|
| 2925 | 3193 |
}
|
|
| 2948 | 3216 |
if (!*cparams->davdb.db) {
|
| 2949 | 3217 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 2950 | 3218 |
"Check 'configdirectory' permissions or "
|
| 2951 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
3219 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 2952 | 3220 |
txn->error.desc = "DAV database is not opened";
|
| 2953 | 3221 |
return HTTP_SERVER_ERROR;
|
| 2954 | 3222 |
}
|
|
| 3018 | 3286 |
}
|
| 3019 | 3287 |
|
| 3020 | 3288 |
/* Check any preconditions on source */
|
| 3021 | |
precond = check_precond(txn, (void **) ddata, etag, lastmod, 0);
|
|
3289 |
precond = check_precond(txn, (void **) ddata, etag, lastmod);
|
| 3022 | 3290 |
|
| 3023 | 3291 |
switch (precond) {
|
| 3024 | 3292 |
case HTTP_OK:
|
|
| 3137 | 3405 |
/* Remote mailbox */
|
| 3138 | 3406 |
struct backend *be;
|
| 3139 | 3407 |
|
| 3140 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
3408 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 3141 | 3409 |
&backend_cached, NULL, NULL, httpd_in);
|
| 3142 | 3410 |
if (!be) return HTTP_UNAVAILABLE;
|
| 3143 | 3411 |
|
|
| 3149 | 3417 |
if (!*dparams->davdb.db) {
|
| 3150 | 3418 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 3151 | 3419 |
"Check 'configdirectory' permissions or "
|
| 3152 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
3420 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 3153 | 3421 |
txn->error.desc = "DAV database is not opened";
|
| 3154 | 3422 |
return HTTP_SERVER_ERROR;
|
| 3155 | 3423 |
}
|
|
| 3213 | 3481 |
}
|
| 3214 | 3482 |
|
| 3215 | 3483 |
/* Check any preconditions */
|
| 3216 | |
precond = dparams->check_precond(txn, (void *) ddata, etag, lastmod, 0);
|
|
3484 |
precond = dparams->check_precond(txn, (void *) ddata, etag, lastmod);
|
| 3217 | 3485 |
|
| 3218 | 3486 |
switch (precond) {
|
| 3219 | 3487 |
case HTTP_OK:
|
|
| 3304 | 3572 |
/* Remote mailbox */
|
| 3305 | 3573 |
struct backend *be;
|
| 3306 | 3574 |
|
| 3307 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
3575 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 3308 | 3576 |
&backend_cached, NULL, NULL, httpd_in);
|
| 3309 | 3577 |
if (!be) return HTTP_UNAVAILABLE;
|
| 3310 | 3578 |
|
|
| 3316 | 3584 |
if (!*gparams->davdb.db) {
|
| 3317 | 3585 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 3318 | 3586 |
"Check 'configdirectory' permissions or "
|
| 3319 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
3587 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 3320 | 3588 |
txn->error.desc = "DAV database is not opened";
|
| 3321 | 3589 |
return HTTP_SERVER_ERROR;
|
| 3322 | 3590 |
}
|
|
| 3352 | 3620 |
offset = record.header_size;
|
| 3353 | 3621 |
datalen = record.size - offset;
|
| 3354 | 3622 |
|
| 3355 | |
txn->flags.ranges = !txn->flags.ce;
|
|
3623 |
txn->flags.ranges = 1;
|
| 3356 | 3624 |
etag = message_guid_encode(&record.guid);
|
| 3357 | 3625 |
lastmod = record.internaldate;
|
| 3358 | 3626 |
}
|
|
| 3365 | 3633 |
}
|
| 3366 | 3634 |
|
| 3367 | 3635 |
/* Check any preconditions, including range request */
|
| 3368 | |
precond = gparams->check_precond(txn, (void *) ddata, etag, lastmod,
|
| 3369 | |
datalen);
|
|
3636 |
precond = gparams->check_precond(txn, (void *) ddata, etag, lastmod);
|
| 3370 | 3637 |
|
| 3371 | 3638 |
switch (precond) {
|
| 3372 | 3639 |
case HTTP_OK:
|
| 3373 | |
break;
|
| 3374 | |
|
| 3375 | 3640 |
case HTTP_PARTIAL:
|
| 3376 | |
/* Set data parameters for range */
|
| 3377 | |
offset += resp_body->range->first;
|
| 3378 | |
datalen = resp_body->range->last - resp_body->range->first + 1;
|
| 3379 | |
break;
|
| 3380 | |
|
| 3381 | 3641 |
case HTTP_NOT_MODIFIED:
|
| 3382 | |
/* Fill in ETag for 304 response */
|
|
3642 |
/* Fill in ETag, Last-Modified, Expires, and Cache-Control */
|
| 3383 | 3643 |
resp_body->etag = etag;
|
|
3644 |
resp_body->lastmod = lastmod;
|
|
3645 |
resp_body->maxage = 3600; /* 1 hr */
|
|
3646 |
txn->flags.cc |= CC_MAXAGE | CC_REVALIDATE; /* don't use stale data */
|
|
3647 |
|
|
3648 |
if (precond != HTTP_NOT_MODIFIED) break;
|
| 3384 | 3649 |
|
| 3385 | 3650 |
default:
|
| 3386 | 3651 |
/* We failed a precondition - don't perform the request */
|
|
| 3388 | 3653 |
goto done;
|
| 3389 | 3654 |
}
|
| 3390 | 3655 |
|
| 3391 | |
/* Fill in Last-Modified, ETag, and Content-Type */
|
| 3392 | |
resp_body->lastmod = lastmod;
|
| 3393 | |
resp_body->etag = etag;
|
| 3394 | |
|
| 3395 | 3656 |
if (record.uid) {
|
| 3396 | 3657 |
resp_body->type = gparams->content_type;
|
| 3397 | 3658 |
|
|
| 3406 | 3667 |
}
|
| 3407 | 3668 |
}
|
| 3408 | 3669 |
|
| 3409 | |
if (resp_body->range && resp_body->range->next) {
|
| 3410 | |
/* multiple ranges */
|
| 3411 | |
multipart_byteranges(txn, msg_base + record.header_size);
|
| 3412 | |
}
|
| 3413 | |
else write_body(precond, txn, data, datalen);
|
|
3670 |
write_body(precond, txn, data, datalen);
|
| 3414 | 3671 |
|
| 3415 | 3672 |
if (msg_base)
|
| 3416 | 3673 |
mailbox_unmap_message(mailbox, record.uid, &msg_base, &msg_size);
|
|
| 3485 | 3742 |
/* Remote mailbox */
|
| 3486 | 3743 |
struct backend *be;
|
| 3487 | 3744 |
|
| 3488 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
3745 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 3489 | 3746 |
&backend_cached, NULL, NULL, httpd_in);
|
| 3490 | 3747 |
if (!be) return HTTP_UNAVAILABLE;
|
| 3491 | 3748 |
|
|
| 3497 | 3754 |
if (!*lparams->davdb.db) {
|
| 3498 | 3755 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 3499 | 3756 |
"Check 'configdirectory' permissions or "
|
| 3500 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
3757 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 3501 | 3758 |
txn->error.desc = "DAV database is not opened";
|
| 3502 | 3759 |
return HTTP_SERVER_ERROR;
|
| 3503 | 3760 |
}
|
|
| 3545 | 3802 |
}
|
| 3546 | 3803 |
|
| 3547 | 3804 |
/* Check any preconditions */
|
| 3548 | |
precond = lparams->check_precond(txn, ddata, etag, lastmod, 0);
|
|
3805 |
precond = lparams->check_precond(txn, ddata, etag, lastmod);
|
| 3549 | 3806 |
|
| 3550 | 3807 |
switch (precond) {
|
| 3551 | 3808 |
case HTTP_OK:
|
|
| 3742 | 3999 |
p = strchr(server, '!');
|
| 3743 | 4000 |
if (p) *p++ = '\0';
|
| 3744 | 4001 |
|
| 3745 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
4002 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 3746 | 4003 |
&backend_cached, NULL, NULL, httpd_in);
|
| 3747 | 4004 |
if (!be) return HTTP_UNAVAILABLE;
|
| 3748 | 4005 |
|
|
| 3793 | 4050 |
pctx.root = root;
|
| 3794 | 4051 |
pctx.ns = ns;
|
| 3795 | 4052 |
pctx.tid = NULL;
|
| 3796 | |
pctx.errstr = &txn->error.desc;
|
|
4053 |
pctx.err = &txn->error;
|
| 3797 | 4054 |
pctx.ret = &r;
|
| 3798 | 4055 |
|
| 3799 | 4056 |
/* Execute the property patch instructions */
|
|
| 3938 | 4195 |
if ((r = mboxlist_lookup(mboxname, &mbentry, NULL))) {
|
| 3939 | 4196 |
syslog(LOG_INFO, "mboxlist_lookup(%s) failed: %s",
|
| 3940 | 4197 |
mboxname, error_message(r));
|
| 3941 | |
*fctx->errstr = error_message(r);
|
|
4198 |
fctx->err->desc = error_message(r);
|
| 3942 | 4199 |
*fctx->ret = HTTP_SERVER_ERROR;
|
| 3943 | 4200 |
goto done;
|
| 3944 | 4201 |
}
|
|
| 3950 | 4207 |
if ((r = mailbox_open_irl(mboxname, &mailbox))) {
|
| 3951 | 4208 |
syslog(LOG_INFO, "mailbox_open_irl(%s) failed: %s",
|
| 3952 | 4209 |
mboxname, error_message(r));
|
| 3953 | |
*fctx->errstr = error_message(r);
|
|
4210 |
fctx->err->desc = error_message(r);
|
| 3954 | 4211 |
*fctx->ret = HTTP_SERVER_ERROR;
|
| 3955 | 4212 |
goto done;
|
| 3956 | 4213 |
}
|
|
| 4025 | 4282 |
const char **hdr;
|
| 4026 | 4283 |
unsigned depth;
|
| 4027 | 4284 |
xmlDocPtr indoc = NULL, outdoc = NULL;
|
| 4028 | |
xmlNodePtr root, cur = NULL;
|
|
4285 |
xmlNodePtr root, cur = NULL, props = NULL;
|
| 4029 | 4286 |
xmlNsPtr ns[NUM_NAMESPACE];
|
|
4287 |
struct hash_table ns_table = { 0, NULL, NULL };
|
| 4030 | 4288 |
struct propfind_ctx fctx;
|
| 4031 | 4289 |
struct propfind_entry_list *elist = NULL;
|
| 4032 | 4290 |
|
|
| 4082 | 4340 |
/* Remote mailbox */
|
| 4083 | 4341 |
struct backend *be;
|
| 4084 | 4342 |
|
| 4085 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
4343 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 4086 | 4344 |
&backend_cached, NULL, NULL, httpd_in);
|
| 4087 | 4345 |
if (!be) return HTTP_UNAVAILABLE;
|
| 4088 | 4346 |
|
|
| 4093 | 4351 |
if (!*fparams->davdb.db) {
|
| 4094 | 4352 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 4095 | 4353 |
"Check 'configdirectory' permissions or "
|
| 4096 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
4354 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 4097 | 4355 |
txn->error.desc = "DAV database is not opened";
|
| 4098 | 4356 |
return HTTP_SERVER_ERROR;
|
| 4099 | 4357 |
}
|
|
| 4112 | 4370 |
if (ret) goto done;
|
| 4113 | 4371 |
|
| 4114 | 4372 |
if (!root) {
|
| 4115 | |
/* XXX allprop request */
|
|
4373 |
/* Empty request */
|
|
4374 |
fctx.mode = PROPFIND_ALL;
|
| 4116 | 4375 |
}
|
| 4117 | 4376 |
else {
|
| 4118 | 4377 |
indoc = root->doc;
|
| 4119 | |
|
| 4120 | |
/* XXX Need to support propname request too! */
|
| 4121 | 4378 |
|
| 4122 | 4379 |
/* Make sure its a propfind element */
|
| 4123 | 4380 |
if (xmlStrcmp(root->name, BAD_CAST "propfind")) {
|
|
| 4134 | 4391 |
spool_cache_header(xstrdup(":type"), xstrdup((const char *) cur->name),
|
| 4135 | 4392 |
txn->req_hdrs);
|
| 4136 | 4393 |
|
| 4137 | |
/* Make sure its a prop element */
|
| 4138 | |
/* XXX TODO: Check for allprop and propname too */
|
| 4139 | |
if (!cur || xmlStrcmp(cur->name, BAD_CAST "prop")) {
|
|
4394 |
/* Make sure its a known element */
|
|
4395 |
if (!cur) {
|
|
4396 |
ret = HTTP_BAD_REQUEST;
|
|
4397 |
goto done;
|
|
4398 |
}
|
|
4399 |
else if (!xmlStrcmp(cur->name, BAD_CAST "allprop")) {
|
|
4400 |
fctx.mode = PROPFIND_ALL;
|
|
4401 |
|
|
4402 |
/* Check for 'include' element */
|
|
4403 |
for (cur = cur->next;
|
|
4404 |
cur && cur->type != XML_ELEMENT_NODE; cur = cur->next);
|
|
4405 |
|
|
4406 |
if (cur && !xmlStrcmp(cur->name, BAD_CAST "include")) {
|
|
4407 |
props = cur->children;
|
|
4408 |
}
|
|
4409 |
}
|
|
4410 |
else if (!xmlStrcmp(cur->name, BAD_CAST "propname")) {
|
|
4411 |
fctx.mode = PROPFIND_NAME;
|
|
4412 |
fctx.prefer = PREFER_MIN; /* Don't want 404 (Not Found) */
|
|
4413 |
}
|
|
4414 |
else if (!xmlStrcmp(cur->name, BAD_CAST "prop")) {
|
|
4415 |
fctx.mode = PROPFIND_PROP;
|
|
4416 |
props = cur->children;
|
|
4417 |
}
|
|
4418 |
else {
|
| 4140 | 4419 |
ret = HTTP_BAD_REQUEST;
|
| 4141 | 4420 |
goto done;
|
| 4142 | 4421 |
}
|
|
| 4154 | 4433 |
/* Populate our propfind context */
|
| 4155 | 4434 |
fctx.req_tgt = &txn->req_tgt;
|
| 4156 | 4435 |
fctx.depth = depth;
|
| 4157 | |
fctx.prefer = get_preferences(txn);
|
| 4158 | |
fctx.userid = httpd_userid;
|
|
4436 |
fctx.prefer |= get_preferences(txn);
|
|
4437 |
fctx.userid = proxy_userid;
|
|
4438 |
fctx.int_userid = httpd_userid;
|
| 4159 | 4439 |
fctx.userisadmin = httpd_userisadmin;
|
| 4160 | 4440 |
fctx.authstate = httpd_authstate;
|
| 4161 | 4441 |
fctx.mailbox = NULL;
|
|
| 4172 | 4452 |
fctx.elist = NULL;
|
| 4173 | 4453 |
fctx.root = root;
|
| 4174 | 4454 |
fctx.ns = ns;
|
| 4175 | |
fctx.errstr = &txn->error.desc;
|
|
4455 |
fctx.ns_table = &ns_table;
|
|
4456 |
fctx.err = &txn->error;
|
| 4176 | 4457 |
fctx.ret = &ret;
|
| 4177 | 4458 |
fctx.fetcheddata = 0;
|
| 4178 | 4459 |
|
| 4179 | 4460 |
/* Parse the list of properties and build a list of callbacks */
|
| 4180 | |
preload_proplist(cur->children, &fctx);
|
|
4461 |
preload_proplist(props, &fctx);
|
| 4181 | 4462 |
|
| 4182 | 4463 |
if (!txn->req_tgt.collection &&
|
| 4183 | 4464 |
(!depth || !(fctx.prefer & PREFER_NOROOT))) {
|
|
| 4238 | 4519 |
|
| 4239 | 4520 |
buf_free(&fctx.buf);
|
| 4240 | 4521 |
|
|
4522 |
free_hash_table(&ns_table, NULL);
|
|
4523 |
|
| 4241 | 4524 |
if (outdoc) xmlFreeDoc(outdoc);
|
| 4242 | 4525 |
if (indoc) xmlFreeDoc(indoc);
|
| 4243 | 4526 |
|
|
| 4304 | 4587 |
/* Remote mailbox */
|
| 4305 | 4588 |
struct backend *be;
|
| 4306 | 4589 |
|
| 4307 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
4590 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 4308 | 4591 |
&backend_cached, NULL, NULL, httpd_in);
|
| 4309 | 4592 |
if (!be) return HTTP_UNAVAILABLE;
|
| 4310 | 4593 |
|
|
| 4352 | 4635 |
pctx.root = resp;
|
| 4353 | 4636 |
pctx.ns = ns;
|
| 4354 | 4637 |
pctx.tid = NULL;
|
| 4355 | |
pctx.errstr = &txn->error.desc;
|
|
4638 |
pctx.err = &txn->error;
|
| 4356 | 4639 |
pctx.ret = &r;
|
| 4357 | 4640 |
|
| 4358 | 4641 |
/* Execute the property patch instructions */
|
|
| 4392 | 4675 |
static unsigned post_count = 0;
|
| 4393 | 4676 |
int r, ret;
|
| 4394 | 4677 |
size_t len;
|
| 4395 | |
char *p;
|
| 4396 | 4678 |
|
| 4397 | 4679 |
/* Response should not be cached */
|
| 4398 | 4680 |
txn->flags.cc |= CC_NOCACHE;
|
|
| 4414 | 4696 |
|
| 4415 | 4697 |
/* Append a unique resource name to URL path and perform a PUT */
|
| 4416 | 4698 |
len = strlen(txn->req_tgt.path);
|
| 4417 | |
p = txn->req_tgt.path + len;
|
| 4418 | |
|
| 4419 | |
snprintf(p, MAX_MAILBOX_PATH - len, "%x-%d-%ld-%u.ics",
|
| 4420 | |
strhash(txn->req_tgt.path), getpid(), time(0), post_count++);
|
|
4699 |
txn->req_tgt.resource = txn->req_tgt.path + len;
|
|
4700 |
txn->req_tgt.reslen =
|
|
4701 |
snprintf(txn->req_tgt.resource, MAX_MAILBOX_PATH - len,
|
|
4702 |
"%x-%d-%ld-%u.ics",
|
|
4703 |
strhash(txn->req_tgt.path), getpid(), time(0), post_count++);
|
| 4421 | 4704 |
|
| 4422 | 4705 |
/* Tell client where to find the new resource */
|
| 4423 | 4706 |
txn->location = txn->req_tgt.path;
|
|
| 4448 | 4731 |
uquota_t size = 0;
|
| 4449 | 4732 |
unsigned flags = 0;
|
| 4450 | 4733 |
|
| 4451 | |
/* Response should not be cached */
|
| 4452 | |
txn->flags.cc |= CC_NOCACHE;
|
| 4453 | |
|
| 4454 | |
/* Parse the path */
|
| 4455 | |
if ((r = pparams->parse_path(txn->req_uri->path,
|
| 4456 | |
&txn->req_tgt, &txn->error.desc))) return r;
|
| 4457 | |
|
| 4458 | |
/* Make sure method is allowed (only allowed on resources) */
|
| 4459 | |
if (!(txn->req_tgt.allow & ALLOW_WRITE)) return HTTP_NOT_ALLOWED;
|
|
4734 |
if (txn->meth == METH_PUT) {
|
|
4735 |
/* Response should not be cached */
|
|
4736 |
txn->flags.cc |= CC_NOCACHE;
|
|
4737 |
|
|
4738 |
/* Parse the path */
|
|
4739 |
if ((r = pparams->parse_path(txn->req_uri->path,
|
|
4740 |
&txn->req_tgt, &txn->error.desc))) {
|
|
4741 |
return r;
|
|
4742 |
}
|
|
4743 |
|
|
4744 |
/* Make sure method is allowed (only allowed on resources) */
|
|
4745 |
if (!(txn->req_tgt.allow & ALLOW_WRITE)) return HTTP_NOT_ALLOWED;
|
|
4746 |
}
|
| 4460 | 4747 |
|
| 4461 | 4748 |
/* Make sure Content-Range isn't specified */
|
| 4462 | 4749 |
if (spool_getheader(txn->req_hdrs, "Content-Range"))
|
|
| 4497 | 4784 |
/* Remote mailbox */
|
| 4498 | 4785 |
struct backend *be;
|
| 4499 | 4786 |
|
| 4500 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
4787 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 4501 | 4788 |
&backend_cached, NULL, NULL, httpd_in);
|
| 4502 | 4789 |
if (!be) return HTTP_UNAVAILABLE;
|
| 4503 | 4790 |
|
|
| 4509 | 4796 |
if (!*pparams->davdb.db) {
|
| 4510 | 4797 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 4511 | 4798 |
"Check 'configdirectory' permissions or "
|
| 4512 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
4799 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 4513 | 4800 |
txn->error.desc = "DAV database is not opened";
|
| 4514 | 4801 |
return HTTP_SERVER_ERROR;
|
| 4515 | 4802 |
}
|
|
| 4557 | 4844 |
mailbox_unlock_index(mailbox, NULL);
|
| 4558 | 4845 |
|
| 4559 | 4846 |
/* Check any preconditions */
|
| 4560 | |
precond = pparams->check_precond(txn, ddata, etag, lastmod, 0);
|
|
4847 |
precond = pparams->check_precond(txn, ddata, etag, lastmod);
|
| 4561 | 4848 |
|
| 4562 | 4849 |
switch (precond) {
|
| 4563 | 4850 |
case HTTP_OK:
|
|
| 4674 | 4961 |
else if (!xmlStrcmp(node->name, BAD_CAST "sync-level") &&
|
| 4675 | 4962 |
(str = xmlNodeListGetString(inroot->doc, node->children, 1))) {
|
| 4676 | 4963 |
if (!strcmp((char *) str, "infinity")) {
|
| 4677 | |
*fctx->errstr =
|
|
4964 |
fctx->err->desc =
|
| 4678 | 4965 |
"This server DOES NOT support infinite depth requests";
|
| 4679 | 4966 |
ret = HTTP_SERVER_ERROR;
|
| 4680 | 4967 |
}
|
| 4681 | 4968 |
else if ((sscanf((char *) str, "%u", &fctx->depth) != 1) ||
|
| 4682 | 4969 |
(fctx->depth != 1)) {
|
| 4683 | |
*fctx->errstr = "Illegal sync-level";
|
|
4970 |
fctx->err->desc = "Illegal sync-level";
|
| 4684 | 4971 |
ret = HTTP_BAD_REQUEST;
|
| 4685 | 4972 |
}
|
| 4686 | 4973 |
}
|
|
| 4704 | 4991 |
|
| 4705 | 4992 |
/* Check Depth */
|
| 4706 | 4993 |
if (!fctx->depth) {
|
| 4707 | |
*fctx->errstr = "Illegal sync-level";
|
|
4994 |
fctx->err->desc = "Illegal sync-level";
|
| 4708 | 4995 |
ret = HTTP_BAD_REQUEST;
|
| 4709 | 4996 |
goto done;
|
| 4710 | 4997 |
}
|
|
| 4758 | 5045 |
|
| 4759 | 5046 |
if (!nresp) {
|
| 4760 | 5047 |
/* DAV:number-of-matches-within-limits */
|
| 4761 | |
*fctx->errstr = "Unable to truncate results";
|
|
5048 |
fctx->err->desc = "Unable to truncate results";
|
| 4762 | 5049 |
ret = HTTP_FORBIDDEN; /* HTTP_NO_STORAGE ? */
|
| 4763 | 5050 |
goto done;
|
| 4764 | 5051 |
}
|
|
| 4826 | 5113 |
int ret = 0, r;
|
| 4827 | 5114 |
const char **hdr;
|
| 4828 | 5115 |
unsigned depth = 0;
|
| 4829 | |
xmlNodePtr inroot = NULL, outroot = NULL, cur, prop = NULL;
|
|
5116 |
xmlNodePtr inroot = NULL, outroot = NULL, cur, props = NULL;
|
| 4830 | 5117 |
const struct report_type_t *report = NULL;
|
| 4831 | 5118 |
xmlNsPtr ns[NUM_NAMESPACE];
|
|
5119 |
struct hash_table ns_table = { 0, NULL, NULL };
|
| 4832 | 5120 |
struct propfind_ctx fctx;
|
| 4833 | 5121 |
struct propfind_entry_list *elist = NULL;
|
| 4834 | 5122 |
|
|
| 4918 | 5206 |
/* Remote mailbox */
|
| 4919 | 5207 |
struct backend *be;
|
| 4920 | 5208 |
|
| 4921 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
5209 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 4922 | 5210 |
&backend_cached, NULL, NULL, httpd_in);
|
| 4923 | 5211 |
if (!be) ret = HTTP_UNAVAILABLE;
|
| 4924 | 5212 |
else ret = http_pipe_req_resp(be, txn);
|
|
| 4929 | 5217 |
if (!*rparams->davdb.db) {
|
| 4930 | 5218 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 4931 | 5219 |
"Check 'configdirectory' permissions or "
|
| 4932 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
5220 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 4933 | 5221 |
txn->error.desc = "DAV database is not opened";
|
| 4934 | 5222 |
return HTTP_SERVER_ERROR;
|
| 4935 | 5223 |
}
|
|
| 4941 | 5229 |
for (cur = inroot->children; cur; cur = cur->next) {
|
| 4942 | 5230 |
if (cur->type == XML_ELEMENT_NODE) {
|
| 4943 | 5231 |
if (!xmlStrcmp(cur->name, BAD_CAST "allprop")) {
|
| 4944 | |
syslog(LOG_WARNING, "REPORT %s w/allprop", report->name);
|
| 4945 | |
txn->error.desc = "Unsupported REPORT option <allprop>\r\n";
|
| 4946 | |
ret = HTTP_NOT_IMPLEMENTED;
|
| 4947 | |
goto done;
|
|
5232 |
fctx.mode = PROPFIND_ALL;
|
|
5233 |
break;
|
| 4948 | 5234 |
}
|
| 4949 | 5235 |
else if (!xmlStrcmp(cur->name, BAD_CAST "propname")) {
|
| 4950 | |
syslog(LOG_WARNING, "REPORT %s w/propname", report->name);
|
| 4951 | |
txn->error.desc = "Unsupported REPORT option <propname>\r\n";
|
| 4952 | |
ret = HTTP_NOT_IMPLEMENTED;
|
| 4953 | |
goto done;
|
|
5236 |
fctx.mode = PROPFIND_NAME;
|
|
5237 |
fctx.prefer = PREFER_MIN; /* Don't want 404 (Not Found) */
|
|
5238 |
break;
|
| 4954 | 5239 |
}
|
| 4955 | 5240 |
else if (!xmlStrcmp(cur->name, BAD_CAST "prop")) {
|
| 4956 | |
prop = cur;
|
|
5241 |
fctx.mode = PROPFIND_PROP;
|
|
5242 |
props = cur->children;
|
| 4957 | 5243 |
break;
|
| 4958 | 5244 |
}
|
| 4959 | 5245 |
}
|
| 4960 | 5246 |
}
|
| 4961 | 5247 |
|
| 4962 | |
if (!prop && (report->flags & REPORT_NEED_PROPS)) {
|
|
5248 |
if (!props && (report->flags & REPORT_NEED_PROPS)) {
|
| 4963 | 5249 |
txn->error.desc = "Missing <prop> element in REPORT\r\n";
|
| 4964 | 5250 |
ret = HTTP_BAD_REQUEST;
|
| 4965 | 5251 |
goto done;
|
|
| 4976 | 5262 |
/* Populate our propfind context */
|
| 4977 | 5263 |
fctx.req_tgt = &txn->req_tgt;
|
| 4978 | 5264 |
fctx.depth = depth;
|
| 4979 | |
fctx.prefer = get_preferences(txn);
|
| 4980 | |
fctx.userid = httpd_userid;
|
|
5265 |
fctx.prefer |= get_preferences(txn);
|
|
5266 |
fctx.userid = proxy_userid;
|
|
5267 |
fctx.int_userid = httpd_userid;
|
| 4981 | 5268 |
fctx.userisadmin = httpd_userisadmin;
|
| 4982 | 5269 |
fctx.authstate = httpd_authstate;
|
| 4983 | 5270 |
fctx.mailbox = NULL;
|
|
| 4986 | 5273 |
fctx.elist = NULL;
|
| 4987 | 5274 |
fctx.root = outroot;
|
| 4988 | 5275 |
fctx.ns = ns;
|
| 4989 | |
fctx.errstr = &txn->error.desc;
|
|
5276 |
fctx.ns_table = &ns_table;
|
|
5277 |
fctx.err = &txn->error;
|
| 4990 | 5278 |
fctx.ret = &ret;
|
| 4991 | 5279 |
fctx.fetcheddata = 0;
|
| 4992 | 5280 |
|
| 4993 | 5281 |
/* Parse the list of properties and build a list of callbacks */
|
| 4994 | |
if (prop) preload_proplist(prop->children, &fctx);
|
|
5282 |
if (fctx.mode) ret = preload_proplist(props, &fctx);
|
| 4995 | 5283 |
|
| 4996 | 5284 |
/* Process the requested report */
|
| 4997 | |
ret = (*report->proc)(txn, inroot, &fctx);
|
|
5285 |
if (!ret) ret = (*report->proc)(txn, inroot, &fctx);
|
| 4998 | 5286 |
|
| 4999 | 5287 |
/* Output the XML response */
|
| 5000 | 5288 |
if (!ret && outroot) {
|
|
| 5014 | 5302 |
}
|
| 5015 | 5303 |
|
| 5016 | 5304 |
buf_free(&fctx.buf);
|
|
5305 |
|
|
5306 |
free_hash_table(&ns_table, NULL);
|
| 5017 | 5307 |
|
| 5018 | 5308 |
if (inroot) xmlFreeDoc(inroot->doc);
|
| 5019 | 5309 |
if (outroot) xmlFreeDoc(outroot->doc);
|
|
| 5075 | 5365 |
/* Remote mailbox */
|
| 5076 | 5366 |
struct backend *be;
|
| 5077 | 5367 |
|
| 5078 | |
be = proxy_findserver(server, &http_protocol, httpd_userid,
|
|
5368 |
be = proxy_findserver(server, &http_protocol, proxy_userid,
|
| 5079 | 5369 |
&backend_cached, NULL, NULL, httpd_in);
|
| 5080 | 5370 |
if (!be) return HTTP_UNAVAILABLE;
|
| 5081 | 5371 |
|
|
| 5087 | 5377 |
if (!*lparams->davdb.db) {
|
| 5088 | 5378 |
syslog(LOG_ERR, "DAV database for user '%s' is not opened. "
|
| 5089 | 5379 |
"Check 'configdirectory' permissions or "
|
| 5090 | |
"'proxyservers' option on backend server.", httpd_userid);
|
|
5380 |
"'proxyservers' option on backend server.", proxy_userid);
|
| 5091 | 5381 |
txn->error.desc = "DAV database is not opened";
|
| 5092 | 5382 |
return HTTP_SERVER_ERROR;
|
| 5093 | 5383 |
}
|
|
| 5160 | 5450 |
}
|
| 5161 | 5451 |
|
| 5162 | 5452 |
/* Check any preconditions */
|
| 5163 | |
precond = lparams->check_precond(txn, ddata, etag, lastmod, 0);
|
|
5453 |
precond = lparams->check_precond(txn, ddata, etag, lastmod);
|
| 5164 | 5454 |
|
| 5165 | 5455 |
if (precond != HTTP_OK) {
|
| 5166 | 5456 |
/* We failed a precondition - don't perform the request */
|