Changeset 1494

Timestamp:

12/29/2006 11:38:18 PM (21 months ago)

Author:

darix

Message:

- merged a few fixes from the 1.4.x branch to trunk

Location:

trunk

Files:

• src/SConscript (modified) (1 diff)
• src/array.c (modified) (3 diffs)
• src/configfile-glue.c (modified) (2 diffs)
• src/http_auth.c (modified) (3 diffs)
• src/mod_cml.c (modified) (2 diffs)
• src/mod_cml_lua.c (modified) (1 diff)
• src/mod_dirlisting.c (modified) (1 diff)
• src/mod_fastcgi.c (modified) (1 diff)
• src/mod_status.c (modified) (2 diffs)
• src/mod_webdav.c (modified) (13 diffs)
• src/plugin.c (modified) (1 diff)
• src/response.c (modified) (2 diffs)
• src/spawn-fcgi.c (modified) (1 diff)
• tests/fcgi-auth.c (modified) (1 diff)
• tests/fcgi-responder.c (modified) (1 diff)

trunk/src/SConscript

@@ -125 +125 @@
                 'src' : [ 'mod_auth.c', 'http_auth_digest.c', 'http_auth.c' ], 
                 'lib' : [ env['LIBCRYPT'], env['LIBLDAP'], env['LIBLBER'] ] },
-        'mod_webdav' : { 'src' : [ 'mod_webdav.c' ], 'lib' : [ env['LIBXML2'], env['LIBSQLITE3'] ] },
+        'mod_webdav' : { 'src' : [ 'mod_webdav.c' ], 'lib' : [ env['LIBXML2'], env['LIBSQLITE3'], env['LIBUUID'] ] },
         'mod_sql_vhost_core' : { 'src' : [ 'mod_sql_vhost_core.c' ] },
         'mod_mysql_vhost' : { 'src' : [ 'mod_mysql_vhost.c' ], 'lib' : [ env['LIBMYSQL'] ] },

trunk/src/array.c

@@ -261 +261 @@
         int i;
         for (i = 0; i < depth; i ++) {
-                fprintf(stderr, "    ");
+                fprintf(stdout, "    ");
         }
 }
@@ -305 +305 @@
         }
         if (oneline) {
-                fprintf(stderr, "(");
+                fprintf(stdout, "(");
                 for (i = 0; i < a->used; i++) {
                         data_unset *du = a->data[i];
                         if (i != 0) {
-                                fprintf(stderr, ", ");
+                                fprintf(stdout, ", ");
                         }
                         du->print(du, depth + 1);
                 }
-                fprintf(stderr, ")");
+                fprintf(stdout, ")");
                 return 0;
         }
 
         maxlen = array_get_max_key_length(a);
-        fprintf(stderr, "(\n");
+        fprintf(stdout, "(\n");
         for (i = 0; i < a->used; i++) {
                 data_unset *du = a->data[i];
@@ -326 +326 @@
 
                         if (i && (i % 5) == 0) {
-                                fprintf(stderr, "# %zd\n", i);
+                                fprintf(stdout, "# %zd\n", i);
                                 array_print_indent(depth + 1);
                         }
-                        fprintf(stderr, "\"%s\"", du->key->ptr);
+                        fprintf(stdout, "\"%s\"", du->key->ptr);
                         for (j = maxlen - strlen(du->key->ptr); j > 0; j --) {
-                                fprintf(stderr, " ");
+                                fprintf(stdout, " ");
                         }
-                        fprintf(stderr, " => ");
+                        fprintf(stdout, " => ");
                 }
                 du->print(du, depth + 1);
-                fprintf(stderr, ",\n");
+                fprintf(stdout, ",\n");
         }
         if (!(i && (i - 1 % 5) == 0)) {
                 array_print_indent(depth + 1);
-                fprintf(stderr, "# %zd\n", i);
+                fprintf(stdout, "# %zd\n", i);
         }
         array_print_indent(depth);
-        fprintf(stderr, ")");
+        fprintf(stdout, ")");
 
         return 0;

trunk/src/configfile-glue.c

@@ -60 +60 @@
                                         } else {
                                                 log_error_write(srv, __FILE__, __LINE__, "sssd",
-                                                                "the key of and array can only be a string or a integer, variable:",
+                                                                "the key of an array can only be a string or a integer, variable:",
                                                                 cv[i].key, "type:", da->value->data[j]->type);
 
@@ -103 +103 @@
                                 }
 
-                                log_error_write(srv, __FILE__, __LINE__, "ssb", "get a string but expected a short:", cv[i].key, ds->value);
+                                log_error_write(srv, __FILE__, __LINE__, "ssb", "got a string but expected a short:", cv[i].key, ds->value);
 
                                 return -1;

trunk/src/http_auth.c

@@ -39 +39 @@
 # include "md5.h"
 #endif
+
+/**
+ * the $apr1$ handling is taken from apache 1.3.x
+ */
+
+/*
+ * The apr_md5_encode() routine uses much code obtained from the FreeBSD 3.0
+ * MD5 crypt() function, which is licenced as follows:
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ */
 
 handler_t auth_ldap_init(server *srv, mod_auth_plugin_config *s);
@@ -406 +421 @@
 }
 
+#define APR_MD5_DIGESTSIZE 16
+#define APR1_ID "$apr1$"
+
+/*
+ * The following MD5 password encryption code was largely borrowed from
+ * the FreeBSD 3.0 /usr/src/lib/libcrypt/crypt.c file, which is
+ * licenced as stated at the top of this file.
+ */
+
+static void to64(char *s, unsigned long v, int n)
+{
+    static unsigned char itoa64[] =         /* 0 ... 63 => ASCII - 64 */
+        "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+    while (--n >= 0) {
+        *s++ = itoa64[v&0x3f];
+        v >>= 6;
+    }
+}
+
+static void apr_md5_encode(const char *pw, const char *salt, char *result, size_t nbytes) {
+    /*
+     * Minimum size is 8 bytes for salt, plus 1 for the trailing NUL,
+     * plus 4 for the '$' separators, plus the password hash itself.
+     * Let's leave a goodly amount of leeway.
+     */
+
+    char passwd[120], *p;
+    const char *sp, *ep;
+    unsigned char final[APR_MD5_DIGESTSIZE];
+    ssize_t sl, pl, i;
+    MD5_CTX ctx, ctx1;
+    unsigned long l;
+
+    /*
+     * Refine the salt first.  It's possible we were given an already-hashed
+     * string as the salt argument, so extract the actual salt value from it
+     * if so.  Otherwise just use the string up to the first '$' as the salt.
+     */
+    sp = salt;
+
+    /*
+     * If it starts with the magic string, then skip that.
+     */
+    if (!strncmp(sp, APR1_ID, strlen(APR1_ID))) {
+        sp += strlen(APR1_ID);
+    }
+
+    /*
+     * It stops at the first '$' or 8 chars, whichever comes first
+     */
+    for (ep = sp; (*ep != '\0') && (*ep != '$') && (ep < (sp + 8)); ep++) {
+        continue;
+    }
+
+    /*
+     * Get the length of the true salt
+     */
+    sl = ep - sp;
+
+    /*
+     * 'Time to make the doughnuts..'
+     */
+    MD5_Init(&ctx);
+
+    /*
+     * The password first, since that is what is most unknown
+     */
+    MD5_Update(&ctx, pw, strlen(pw));
+
+    /*
+     * Then our magic string
+     */
+    MD5_Update(&ctx, APR1_ID, strlen(APR1_ID));
+
+    /*
+     * Then the raw salt
+     */
+    MD5_Update(&ctx, sp, sl);
+
+    /*
+     * Then just as many characters of the MD5(pw, salt, pw)
+     */
+    MD5_Init(&ctx1);
+    MD5_Update(&ctx1, pw, strlen(pw));
+    MD5_Update(&ctx1, sp, sl);
+    MD5_Update(&ctx1, pw, strlen(pw));
+    MD5_Final(final, &ctx1);
+    for (pl = strlen(pw); pl > 0; pl -= APR_MD5_DIGESTSIZE) {
+        MD5_Update(&ctx, final,
+                      (pl > APR_MD5_DIGESTSIZE) ? APR_MD5_DIGESTSIZE : pl);
+    }
+
+    /*
+     * Don't leave anything around in vm they could use.
+     */
+    memset(final, 0, sizeof(final));
+
+    /*
+     * Then something really weird...
+     */
+    for (i = strlen(pw); i != 0; i >>= 1) {
+        if (i & 1) {
+            MD5_Update(&ctx, final, 1);
+        }
+        else {
+            MD5_Update(&ctx, pw, 1);
+        }
+    }
+
+    /*
+     * Now make the output string.  We know our limitations, so we
+     * can use the string routines without bounds checking.
+     */
+    strcpy(passwd, APR1_ID);
+    strncat(passwd, sp, sl);
+    strcat(passwd, "$");
+
+    MD5_Final(final, &ctx);
+
+    /*
+     * And now, just to make sure things don't run too fast..
+     * On a 60 Mhz Pentium this takes 34 msec, so you would
+     * need 30 seconds to build a 1000 entry dictionary...
+     */
+    for (i = 0; i < 1000; i++) {
+        MD5_Init(&ctx1);
+        if (i & 1) {
+            MD5_Update(&ctx1, pw, strlen(pw));
+        }
+        else {
+            MD5_Update(&ctx1, final, APR_MD5_DIGESTSIZE);
+        }
+        if (i % 3) {
+            MD5_Update(&ctx1, sp, sl);
+        }
+
+        if (i % 7) {
+            MD5_Update(&ctx1, pw, strlen(pw));
+        }
+
+        if (i & 1) {
+            MD5_Update(&ctx1, final, APR_MD5_DIGESTSIZE);
+        }
+        else {
+            MD5_Update(&ctx1, pw, strlen(pw));
+        }
+        MD5_Final(final,&ctx1);
+    }
+
+    p = passwd + strlen(passwd);
+
+    l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p, l, 4); p += 4;
+    l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p, l, 4); p += 4;
+    l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p, l, 4); p += 4;
+    l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p, l, 4); p += 4;
+    l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p, l, 4); p += 4;
+    l =                    final[11]                ; to64(p, l, 2); p += 2;
+    *p = '\0';
+
+    /*
+     * Don't leave anything around in vm they could use.
+     */
+    memset(final, 0, sizeof(final));
+
+        /* FIXME
+         */
+#define apr_cpystrn strncpy
+    apr_cpystrn(result, passwd, nbytes - 1);
+}
+
+
 /**
  *
@@ -442 +629 @@
                 }
         } else if (p->conf.auth_backend == AUTH_BACKEND_HTPASSWD) {
+                char sample[120];
+                if (!strncmp(password->ptr, APR1_ID, strlen(APR1_ID))) {
+                        /*
+                         * The hash was created using $apr1$ custom algorithm.
+                         */
+                        apr_md5_encode(pw, password->ptr, sample, sizeof(sample));
+                        return (strcmp(sample, password->ptr) == 0) ? 0 : 1;
+                } else {
 #ifdef HAVE_CRYPT
                 char salt[32];

trunk/src/mod_cml.c

@@ -178 +178 @@
         buffer *b;
         char *c;
-        int ret;
 
         /* cleanup basedir */
@@ -204 +203 @@
          *   - get-param-based
          */
-
         return cache_parse_lua(srv, con, p, cml_file);
-
 }
 

trunk/src/mod_cml_lua.c

@@ -459 +459 @@
 #else
 int cache_parse_lua(server *srv, connection *con, plugin_data *p, buffer *fn) {
+        UNUSED(srv);
+        UNUSED(con);
+        UNUSED(p);
+        UNUSED(fn);
         /* error */
         return -1;

trunk/src/mod_dirlisting.c

@@ -517 +517 @@
                 "</h2>\n"
                 "<div class=\"list\">\n"
-                "<table cellpadding=\"0\" cellspacing=\"0\">\n"
+                "<table summary=\"Directory Listing\" cellpadding=\"0\" cellspacing=\"0\">\n"
                 "<thead>"
                 "<tr>"

trunk/src/mod_fastcgi.c

@@ -24 +24 @@
 #include "stat_cache.h"
 
+#ifdef HAVE_FASTCGI_FASTCGI_H
+#include <fastcgi/fastcgi.h>
+#else
+#ifdef HAVE_FASTCGI_H
+#include <fastcgi.h>
+#else
 #include "fastcgi.h"
+#endif
+#endif /* HAVE_FASTCGI_FASTCGI_H */
 #include <stdio.h>
 

trunk/src/mod_status.c

@@ -174 +174 @@
                 BUFFER_APPEND_STRING_CONST(b, "<th class=\"status\"><a href=\"#\" class=\"sortheader\" onclick=\"resort(this);return false;\">");
                 buffer_append_string(b, key);
-                BUFFER_APPEND_STRING_CONST(b, "<span class=\"sortarrow\"></span></a></th>\n");
+                BUFFER_APPEND_STRING_CONST(b, "<span class=\"sortarrow\">:</span></a></th>\n");
         } else {
                 BUFFER_APPEND_STRING_CONST(b, "<th class=\"status\">");
@@ -678 +678 @@
                            " <body>\n"
                            "  <h1>" PACKAGE_NAME " " PACKAGE_VERSION "</h1>\n"
-                           "  <table border=\"1\">\n");
+                           "  <table summary=\"status\" border=\"1\">\n");
 
         mod_status_header_append(b, "Server-Features");

trunk/src/mod_webdav.c

@@ -48 +48 @@
  */
 
-
+#define WEBDAV_FILE_MODE WEBDAV_FILE_MODE
+#define WEBDAV_DIR_MODE  S_IRWXU | S_IRWXG | S_IRWXO
 
 /* plugin config for all request/connections */
@@ -209 +210 @@
 
                         if (SQLITE_OK != sqlite3_open(s->sqlite_db_name->ptr, &(s->sql))) {
-                                log_error_write(srv, __FILE__, __LINE__, "s", "sqlite3_open failed");
+                                log_error_write(srv, __FILE__, __LINE__, "sbs", "sqlite3_open failed for",
+                                                s->sqlite_db_name,
+                                                sqlite3_errmsg(s->sql));
                                 return HANDLER_ERROR;
                         }
@@ -669 +672 @@
         }
 
-        if (-1 == (ofd = open(dst->path->ptr, O_WRONLY|O_TRUNC|O_CREAT|(overwrite ? 0 : O_EXCL), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))) {
+        if (-1 == (ofd = open(dst->path->ptr, O_WRONLY|O_TRUNC|O_CREAT|(overwrite ? 0 : O_EXCL), WEBDAV_FILE_MODE))) {
                 /* opening the destination failed for some reason */
                 switch(errno) {
@@ -774 +777 @@
                         } else if (S_ISDIR(st.st_mode)) {
                                 /* a directory */
-                                if (-1 == mkdir(d.path->ptr, 0700) &&
+                                if (-1 == mkdir(d.path->ptr, WEBDAV_DIR_MODE) &&
                                     errno != EEXIST) {
                                         /* WTH ? */
@@ -1151 +1154 @@
         int has_lock = 1;
 
-        UNUSED(srv);
-
 #ifdef USE_LOCKS
         data_string *ds;
 
+        UNUSED(srv);
+
         /**
-         * If can have
-         * - <lock-token>
-         * - [etag]
-         *
-         * there is NOT, AND and OR
-         * and a list can be tagged
-         *
-         * (<lock-token>) is untagged
-         * <tag> (<lock-token>) is tagged
-         *
-         * as long as we don't handle collections it is simple. :)
+         * This implementation is more fake than real
+         * we need a parser for the If: header to really handle the full scope
          *
          * X-Litmus: locks: 11 (owner_modify)
          * If: <http://127.0.0.1:1025/dav/litmus/lockme> (<opaquelocktoken:2165478d-0611-49c4-be92-e790d68a38f1>)
+         * - a tagged check:
+         *   if http://127.0.0.1:1025/dav/litmus/lockme is locked with
+         *   opaquelocktoken:2165478d-0611-49c4-be92-e790d68a38f1, go on
          *
          * X-Litmus: locks: 16 (fail_cond_put)
          * If: (<DAV:no-lock> ["-1622396671"])
+         * - untagged:
+         *   go on if the resource has the etag [...] and the lock
          */
         if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "If"))) {
+                /* Ooh, ooh. A if tag, now the fun begins.
+                 *
+                 * this can only work with a real parser
+                 **/
         } else {
                 /* we didn't provided a lock-token -> */
@@ -1192 +1195 @@
                 }
         }
+#else
+        UNUSED(srv);
 #endif
 
@@ -1496 +1501 @@
                 /* let's create the directory */
 
-                if (-1 == mkdir(con->physical.path->ptr, 0700)) {
+                if (-1 == mkdir(con->physical.path->ptr, WEBDAV_DIR_MODE)) {
                         switch(errno) {
                         case EPERM:
@@ -1654 +1659 @@
                         }
 
-                        if (-1 == (fd = open(con->physical.path->ptr, O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))) {
+                        if (-1 == (fd = open(con->physical.path->ptr, O_WRONLY, WEBDAV_FILE_MODE))) {
                                 switch (errno) {
                                 case ENOENT:
@@ -1678 +1683 @@
 
                         /* if the file doesn't exist, create it */
-                        if (-1 == (fd = open(con->physical.path->ptr, O_WRONLY|O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))) {
+                        if (-1 == (fd = open(con->physical.path->ptr, O_WRONLY|O_TRUNC, WEBDAV_FILE_MODE))) {
                                 if (errno == ENOENT &&
-                                    -1 == (fd = open(con->physical.path->ptr, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))) {
+                                    -1 == (fd = open(con->physical.path->ptr, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, WEBDAV_FILE_MODE))) {
                                         /* we can't open the file */
                                         con->http_status = 403;
@@ -1886 +1891 @@
 
                         if (-1 == stat(p->physical.path->ptr, &st)) {
-                                if (-1 == mkdir(p->physical.path->ptr, 0700)) {
+                                if (-1 == mkdir(p->physical.path->ptr, WEBDAV_DIR_MODE)) {
                                         con->http_status = 403;
                                         return HANDLER_FINISHED;
@@ -1897 +1902 @@
                                 } else {
                                         unlink(p->physical.path->ptr);
-                                        if (-1 == mkdir(p->physical.path->ptr, 0700)) {
+                                        if (-1 == mkdir(p->physical.path->ptr, WEBDAV_DIR_MODE)) {
                                                 con->http_status = 403;
                                                 return HANDLER_FINISHED;
@@ -2309 +2314 @@
 
                                                         sqlite3_bind_text(stmt, 3,
-                                                                          lockscope,
+                                                                          (const char *)lockscope,
                                                                           xmlStrlen(lockscope),
                                                                           SQLITE_TRANSIENT);
 
                                                         sqlite3_bind_text(stmt, 4,
-                                                                          locktype,
-                                                                          xmlStrlen(locktype),
+                                                                          (const char *)locktype,
+                                                                          +xmlStrlen(locktype),
                                                                           SQLITE_TRANSIENT);
 
@@ -2335 +2340 @@
 
                                                         /* looks like we survived */
-                                                        webdav_lockdiscovery(srv, con, p->tmp_buf, lockscope, locktype, depth);
+                                                        webdav_lockdiscovery(srv, con, p->tmp_buf, (const char *)lockscope, (const char *)locktype, depth);
 
                                                         con->http_status = 201;

trunk/src/plugin.c

@@ -244 +244 @@
                 }
 #else
-                if (NULL == (p->lib = dlopen(srv->tmp_buf->ptr, RTLD_LAZY))) {
+                if (NULL == (p->lib = dlopen(srv->tmp_buf->ptr, RTLD_NOW|RTLD_GLOBAL))) {
                         log_error_write(srv, __FILE__, __LINE__, "sbs", "dlopen() failed for:",
                                         srv->tmp_buf, dlerror());

trunk/src/response.c

@@ -169 +169 @@
                  * - query
                  *
-                 * (scheme)://(authority)(path)?(query)
+                 * (scheme)://(authority)(path)?(query)#fragment
                  *
                  *
@@ -183 +183 @@
                 config_patch_connection(srv, con, COMP_HTTP_USERAGENT); /* User-Agent:  */
                 config_patch_connection(srv, con, COMP_HTTP_COOKIE);    /* Cookie:  */
+
+                /** their might be a fragment which has to be cut away */
+                if (NULL != (qstr = strchr(con->request.uri->ptr, '#'))) {
+                        con->request.uri->used = qstr - con->request.uri->ptr;
+                        con->request.uri->ptr[con->request.uri->used++] = '\0';
+                }
 
                 /** extract query string from request.uri */