webcit/groupdav_main.c

   1 /*
   2  * $Id$
   3  *
   4  * Entry point for GroupDAV functions
   5  *
   6  */
   7
   8 #include "webcit.h"
   9 #include "webserver.h"
  10 #include "groupdav.h"
  11
  12
  13 /*
  14  * Output HTTP headers which are common to all requests.
  15  *
  16  * Please observe that we don't use the usual output_headers()
  17  * and wDumpContent() functions in the GroupDAV subsystem, so we
  18  * do our own header stuff here.
  19  *
  20  */
  21 void groupdav_common_headers(void) {
  22         hprintf(
  23                 "Server: %s / %s\r\n"
  24                 "Connection: close\r\n",
  25                 PACKAGE_STRING, ChrPtr(serv_info.serv_software)
  26         );
  27 }
  28
  29
  30
  31 /*
  32  * string conversion function
  33  */
  34 void euid_escapize(char *target, const char *source) {
  35         int i, len;
  36         int target_length = 0;
  37
  38         strcpy(target, "");
  39         len = strlen(source);
  40         for (i=0; i<len; ++i) {
  41                 if ( (isalnum(source[i])) || (source[i]=='-') || (source[i]=='_') ) {
  42                         target[target_length] = source[i];
  43                         target[++target_length] = 0;
  44                 }
  45                 else {
  46                         sprintf(&target[target_length], "=%02X", (0xFF & source[i]));
  47                         target_length += 3;
  48                 }
  49         }
  50 }
  51
  52 /*
  53  * string conversion function
  54  */
  55 void euid_unescapize(char *target, const char *source) {
  56         int a, b, len;
  57         char hex[3];
  58         int target_length = 0;
  59
  60         strcpy(target, "");
  61
  62         len = strlen(source);
  63         for (a = 0; a < len; ++a) {
  64                 if (source[a] == '=') {
  65                         hex[0] = source[a + 1];
  66                         hex[1] = source[a + 2];
  67                         hex[2] = 0;
  68                         b = 0;
  69                         sscanf(hex, "%02x", &b);
  70                         target[target_length] = b;
  71                         target[++target_length] = 0;
  72                         a += 2;
  73                 }
  74                 else {
  75                         target[target_length] = source[a];
  76                         target[++target_length] = 0;
  77                 }
  78         }
  79 }
  80
  81
  82
  83
  84 /*
  85  * Main entry point for GroupDAV requests
  86  */
  87 void groupdav_main(HashList *HTTPHeaders,
  88                    StrBuf *DavPathname,
  89                    StrBuf *DavMethod,
  90                    StrBuf *dav_content_type,
  91                    int dav_content_length,
  92                    StrBuf *dav_content,
  93                    int Offset
  94 ) {
  95         void *vLine;
  96         char dav_ifmatch[256];
  97         int dav_depth;
  98         char *ds;
  99         int i, len;
 100
 101         strcpy(dav_ifmatch, "");
 102         dav_depth = 0;
 103
 104         if (IsEmptyStr(WC->http_host) &&
 105             GetHash(HTTPHeaders, HKEY("HOST"), &vLine) &&
 106             (vLine != NULL)) {
 107                 safestrncpy(WC->http_host, ChrPtr((StrBuf*)vLine),
 108                             sizeof WC->http_host);
 109         }
 110         if (GetHash(HTTPHeaders, HKEY("IF-MATCH"), &vLine) &&
 111             (vLine != NULL)) {
 112                 safestrncpy(dav_ifmatch, ChrPtr((StrBuf*)vLine),
 113                             sizeof dav_ifmatch);
 114         }
 115         if (GetHash(HTTPHeaders, HKEY("DEPTH"), &vLine) &&
 116             (vLine != NULL)) {
 117                 if (!strcasecmp(ChrPtr((StrBuf*)vLine), "infinity")) {
 118                         dav_depth = 32767;
 119                 }
 120                 else if (strcmp(ChrPtr((StrBuf*)vLine), "0") == 0) {
 121                         dav_depth = 0;
 122                 }
 123                 else if (strcmp(ChrPtr((StrBuf*)vLine), "1") == 0) {
 124                         dav_depth = 1;
 125                 }
 126         }
 127
 128         if (!WC->logged_in) {
 129                 hprintf("HTTP/1.1 401 Unauthorized\r\n");
 130                 groupdav_common_headers();
 131                 hprintf("WWW-Authenticate: Basic realm=\"%s\"\r\n",
 132                         ChrPtr(serv_info.serv_humannode));
 133                 hprintf("Content-Length: 0\r\n");
 134                 end_burst();
 135                 return;
 136         }
 137
 138 //      extract_token(dav_method, req->line, 0, ' ', sizeof dav_method);
 139 //      extract_token(dav_pathname, req->line, 1, ' ', sizeof dav_pathname);
 140         //// TODO unescape_input(dav_pathname);
 141
 142         /* If the request does not begin with "/groupdav", prepend it.  If
 143          * we happen to introduce a double-slash, that's ok; we'll strip it
 144          * in the next step.
 145          *
 146          * (THIS IS DISABLED BECAUSE WE ARE NOW TRYING TO DO REAL DAV.)
 147          *
 148         if (strncasecmp(dav_pathname, "/groupdav", 9)) {
 149                 char buf[512];
 150                 snprintf(buf, sizeof buf, "/groupdav/%s", dav_pathname);
 151                 safestrncpy(dav_pathname, buf, sizeof dav_pathname);
 152         }
 153          *
 154          */
 155
 156         /* Remove any stray double-slashes in pathname */
 157         while (ds=strstr(ChrPtr(DavPathname), "//"), ds != NULL) {
 158                 strcpy(ds, ds+1);
 159         }
 160
 161         /*
 162          * If there's an If-Match: header, strip out the quotes if present, and
 163          * then if all that's left is an asterisk, make it go away entirely.
 164          */
 165         len = strlen(dav_ifmatch);
 166         if (len > 0) {
 167                 stripltlen(dav_ifmatch, &len);
 168                 if (dav_ifmatch[0] == '\"') {
 169                         memmove (dav_ifmatch, &dav_ifmatch[1], len);
 170                         len --;
 171                         for (i=0; i<len; ++i) {
 172                                 if (dav_ifmatch[i] == '\"') {
 173                                         dav_ifmatch[i] = 0;
 174                                         len = i - 1;
 175                                 }
 176                         }
 177                 }
 178                 if (!strcmp(dav_ifmatch, "*")) {
 179                         strcpy(dav_ifmatch, "");
 180                 }
 181         }
 182
 183         /*
 184          * The OPTIONS method is not required by GroupDAV.  This is an
 185          * experiment to determine what might be involved in supporting
 186          * other variants of DAV in the future.
 187          */
 188         if (!strcasecmp(ChrPtr(DavMethod), "OPTIONS")) {
 189                 groupdav_options(DavPathname);
 190                 return;
 191         }
 192
 193         /*
 194          * The PROPFIND method is basically used to list all objects in a
 195          * room, or to list all relevant rooms on the server.
 196          */
 197         if (!strcasecmp(ChrPtr(DavMethod), "PROPFIND")) {
 198                 groupdav_propfind(DavPathname, dav_depth,
 199                                   dav_content_type, dav_content,
 200                                   Offset);
 201                 return;
 202         }
 203
 204         /*
 205          * The GET method is used for fetching individual items.
 206          */
 207         if (!strcasecmp(ChrPtr(DavMethod), "GET")) {
 208                 groupdav_get(DavPathname);
 209                 return;
 210         }
 211
 212         /*
 213          * The PUT method is used to add or modify items.
 214          */
 215         if (!strcasecmp(ChrPtr(DavMethod), "PUT")) {
 216                 groupdav_put(DavPathname, dav_ifmatch,
 217                              ChrPtr(dav_content_type), dav_content,
 218                              Offset);
 219                 return;
 220         }
 221
 222         /*
 223          * The DELETE method kills, maims, and destroys.
 224          */
 225         if (!strcasecmp(ChrPtr(DavMethod), "DELETE")) {
 226                 groupdav_delete(DavPathname, dav_ifmatch);
 227                 return;
 228         }
 229
 230         /*
 231          * Couldn't find what we were looking for.  Die in a car fire.
 232          */
 233         hprintf("HTTP/1.1 501 Method not implemented\r\n");
 234         groupdav_common_headers();
 235         hprintf("Content-Type: text/plain\r\n");
 236         wprintf("GroupDAV method \"%s\" is not implemented.\r\n",
 237                 ChrPtr(DavMethod));
 238         end_burst();
 239 }
 240
 241
 242 /*
 243  * Output our host prefix for globally absolute URL's.
 244  */
 245 void groupdav_identify_host(void) {
 246         if (!IsEmptyStr(WC->http_host)) {
 247                 wprintf("%s://%s",
 248                         (is_https ? "https" : "http"),
 249                         WC->http_host);
 250         }
 251 }