X-Git-Url: http://dolda2000.com/gitweb/?a=blobdiff_plain;f=daemon%2Fclient.c;h=5b080fb1a53c7786feea027e6e146d557a2868d8;hb=c5d236324fe6500844a86263e754339a2b3190f0;hp=e7fa0e72ce0a2f4aa20914a9b9f3b534b8f8ae43;hpb=d3372da97568d5e1f35fa19787c8ec8af93a0435;p=doldaconnect.git

diff --git a/daemon/client.c b/daemon/client.c
index e7fa0e7..5b080fb 100644
--- a/daemon/client.c
+++ b/daemon/client.c
@@ -36,9 +36,9 @@
 #include "log.h"
 #include "utils.h"
 #include "module.h"
-#include "tiger.h"
 #include "net.h"
 #include "sysevents.h"
+#include <tiger.h>
 
 struct scanstate
 {
@@ -56,12 +56,24 @@ struct scanqueue
 static int conf_share(int argc, wchar_t **argv);
 static void freecache(struct sharecache *node);
 static void checkhashes(void);
+static void writehashcache(int now);
 
 static struct configvar myvars[] =
 {
+    /** The default nick name to use. The nickname can also be
+     * specified for individual hubs, overriding this setting. */
     {CONF_VAR_STRING, "defnick", {.str = L"DoldaConnect user"}},
+    /** When scanning shares, this bitmask is consulted for every
+     * regular file. Unless the file's mode has the bits specified by
+     * this mask set, it will not be shared. */
     {CONF_VAR_INT, "scanfilemask", {.num = 0004}},
+    /** When scanning shares, this bitmask is consulted for every
+     * directory encountered. Unless the directory's mode has the bits
+     * specified by this mask set, it will be ignored and any files
+     * under it will not be shared. */
     {CONF_VAR_INT, "scandirmask", {.num = 0005}},
+    /** The filename to use for the hash cache (see the FILES section
+     * for more information). */
     {CONF_VAR_STRING, "hashcache", {.str = L"dc-hashcache"}},
     {CONF_VAR_END}
 };
@@ -76,7 +88,12 @@ static struct scanstate *scanjob = NULL;
 static struct scanqueue *scanqueue = NULL;
 static struct sharepoint *shares = NULL;
 static struct hashcache *hashcache = NULL;
-static pid_t hashjob = 0;
+static struct timer *hashwritetimer = NULL;
+/* Set initially to -1, but changed to 0 the first time run() is
+ * called. This is to avoid forking a hash job before daemonizing,
+ * since that would make the daemon unable to wait() for the hash
+ * job. */
+static pid_t hashjob = -1;
 struct sharecache *shareroot = NULL;
 unsigned long long sharesize = 0;
 GCBCHAIN(sharechangecb, unsigned long long);
@@ -131,6 +148,88 @@ static void dumpsharecache(struct sharecache *node, int l)
     }
 }
 
+struct hash *newhash(wchar_t *algo, size_t len, char *buf)
+{
+    struct hash *ret;
+    
+    ret = smalloc(sizeof(*ret));
+    memset(ret, 0, sizeof(*ret));
+    ret->algo = swcsdup(algo);
+    ret->len = len;
+    ret->buf = memcpy(smalloc(len), buf, len);
+    return(ret);
+}
+
+void freehash(struct hash *hash)
+{
+    free(hash->algo);
+    free(hash->buf);
+    free(hash);
+}
+
+struct hash *duphash(struct hash *hash)
+{
+    return(newhash(hash->algo, hash->len, hash->buf));
+}
+
+struct hash *parsehash(wchar_t *text)
+{
+    wchar_t *p;
+    char *mbsbuf, *decbuf;
+    size_t buflen;
+    struct hash *ret;
+    
+    if((p = wcschr(text, L':')) == NULL)
+	return(NULL);
+    *(p++) = L'\0';
+    if((mbsbuf = icwcstombs(p, "US-ASCII")) == NULL)
+	return(NULL);
+    decbuf = base64decode(mbsbuf, &buflen);
+    free(mbsbuf);
+    if(decbuf == NULL)
+	return(NULL);
+    ret = newhash(text, buflen, decbuf);
+    free(decbuf);
+    return(ret);
+}
+
+wchar_t *unparsehash(struct hash *hash)
+{
+    static wchar_t *buf = NULL;
+    wchar_t *whbuf;
+    char *hbuf;
+    size_t bufsize, bufdata;
+    
+    if(buf != NULL)
+	free(buf);
+    buf = NULL;
+    bufsize = bufdata = 0;
+    hbuf = base64encode(hash->buf, hash->len);
+    if((whbuf = icmbstowcs(hbuf, "US-ASCII")) == NULL)
+    {
+	flog(LOG_CRIT, "bug! could not convert base64 from us-ascii: %s", strerror(errno));
+	abort();
+    }
+    free(hbuf);
+    bufcat(buf, hash->algo, wcslen(hash->algo));
+    addtobuf(buf, ':');
+    bufcat(buf, whbuf, wcslen(whbuf));
+    free(whbuf);
+    addtobuf(buf, 0);
+    return(buf);
+}
+
+int hashcmp(struct hash *h1, struct hash *h2)
+{
+    if(wcscmp(h1->algo, h2->algo))
+	return(0);
+    if(h1->len != h2->len)
+	return(0);
+    if(memcmp(h1->buf, h2->buf, h1->len))
+	return(0);
+    return(1);
+}
+
 static struct hashcache *newhashcache(void)
 {
     struct hashcache *new;
@@ -156,52 +255,6 @@ static void freehashcache(struct hashcache *hc)
     free(hc);
 }
 
-static char *findhashcachefile(int filldef)
-{
-    static char ret[128];
-    char *hcname;
-    
-    if(getenv("HOME") != NULL)
-    {
-	snprintf(ret, sizeof(ret), "%s/.dc-hashcache", getenv("HOME"));
-	if(!access(ret, R_OK))
-	    return(ret);
-    }
-    if((hcname = icswcstombs(confgetstr("cli", "hashcache"), NULL, NULL)) == NULL)
-    {
-	flog(LOG_WARNING, "could not convert hash cache name into local charset: %s", strerror(errno));
-	return(NULL);
-    }
-    if(strchr(hcname, '/') != NULL)
-    {
-	if(!access(hcname, R_OK))
-	{
-	    strcpy(ret, hcname);
-	    return(ret);
-	}
-    } else {
-	snprintf(ret, sizeof(ret), "/etc/%s", hcname);
-	if(!access(ret, R_OK))
-	    return(ret);
-	snprintf(ret, sizeof(ret), "/usr/etc/%s", hcname);
-	if(!access(ret, R_OK))
-	    return(ret);
-	snprintf(ret, sizeof(ret), "/usr/local/etc/%s", hcname);
-	if(!access(ret, R_OK))
-	    return(ret);
-    }
-    if(filldef)
-    {
-	if(getenv("HOME") != NULL)
-	    snprintf(ret, sizeof(ret), "%s/.dc-hashcache", getenv("HOME"));
-	else
-	    snprintf(ret, sizeof(ret), "/etc/%s", hcname);
-	return(ret);
-    } else {
-	return(NULL);
-    }
-}
-
 static struct hashcache *findhashcache(dev_t dev, ino_t inode)
 {
     struct hashcache *hc;
@@ -224,7 +277,7 @@ static void readhashcache(void)
     struct hashcache *hc;
     size_t len;
     
-    if((hcname = findhashcachefile(0)) == NULL)
+    if((hcname = findfile(icswcstombs(confgetstr("cli", "hashcache"), NULL, NULL), NULL, 0)) == NULL)
 	return;
     if((stream = fopen(hcname, "r")) == NULL)
     {
@@ -278,14 +331,29 @@ static void readhashcache(void)
     fclose(stream);
 }
 
-static void writehashcache(void)
+static void hashtimercb(int cancelled, void *uudata)
+{
+    hashwritetimer = NULL;
+    if(!cancelled)
+	writehashcache(1);
+}
+
+static void writehashcache(int now)
 {
     char *buf;
     char *hcname;
     FILE *stream;
     struct hashcache *hc;
     
-    hcname = findhashcachefile(1);
+    if(!now)
+    {
+	if(hashwritetimer == NULL)
+	    hashwritetimer = timercallback(ntime() + 300, (void (*)(int, void *))hashtimercb, NULL);
+	return;
+    }
+    if(hashwritetimer != NULL)
+	canceltimer(hashwritetimer);
+    hcname = findfile(icswcstombs(confgetstr("cli", "hashcache"), NULL, NULL), NULL, 1);
     if((stream = fopen(hcname, "w")) == NULL)
     {
 	flog(LOG_WARNING, "could not write hash cache %s: %s", hcname, strerror(errno));
@@ -357,13 +425,13 @@ static void hashread(struct socket *sk, void *uudata)
 	    buf = base64decode(wv[3], NULL);
 	    memcpy(hc->tth, buf, 24);
 	    free(buf);
-	    writehashcache();
+	    writehashcache(0);
 	}
 	memmove(hashbuf, lp, hashbufdata -= (lp - hashbuf));
     }
 }
 
-static void hashexit(pid_t pid, int status, void *uudata)
+static void hashexit(pid_t pid, int status, struct socket *outsock)
 {
     if(pid != hashjob)
 	flog(LOG_ERR, "BUG: hashing process changed PID?! old: %i new %i", hashjob, pid);
@@ -371,6 +439,7 @@ static void hashexit(pid_t pid, int status, void *uudata)
 	flog(LOG_WARNING, "hashing process exited with non-zero status: %i", status);
     hashjob = 0;
     checkhashes();
+    putsock(outsock);
 }
 
 static int hashfile(char *path)
@@ -439,7 +508,7 @@ static int hashfile(char *path)
     close(pfd[1]);
     outsock = wrapsock(pfd[0]);
     outsock->readcb = hashread;
-    childcallback(hashjob, hashexit, NULL);
+    childcallback(hashjob, (void (*)(pid_t, int, void *))hashexit, outsock);
     return(0);
 }
 
@@ -453,16 +522,13 @@ static void checkhashes(void)
     char *path;
     
     node = shareroot->child;
-    while(1)
+    for(node = shareroot->child; node != NULL; node = nextscnode(node))
     {
-	if(node->child != NULL)
-	{
-	    node = node->child;
+	if(node->f.b.type != FILE_REG)
 	    continue;
-	}
 	if(!node->f.b.hastth)
 	{
-	    if((hc = findhashcache(node->dev, node->inode)) != NULL)
+	    if(((hc = findhashcache(node->dev, node->inode)) != NULL) && (hc->mtime == node->mtime))
 	    {
 		memcpy(node->hashtth, hc->tth, 24);
 		node->f.b.hastth = 1;
@@ -473,19 +539,14 @@ static void checkhashes(void)
 		{
 		    flog(LOG_WARNING, "could not hash %s, unsharing it", path);
 		    freecache(node);
+		    free(path);
+		    flog(LOG_INFO, "sharing %lli bytes", sharesize);
+		    continue;
 		}
 		free(path);
 		return;
 	    }
 	}
-	while(node->next == NULL)
-	{
-	    if((node = node->parent) == shareroot)
-		break;
-	}
-	if(node == shareroot)
-	    break;
-	node = node->next;
     }
 }
 
@@ -846,7 +907,7 @@ int doscan(int quantum)
 	    }
 	    type = FILE_REG;
 	} else {
-	    flog(LOG_WARNING, "unhandled file type: %i", sb.st_mode);
+	    flog(LOG_WARNING, "unhandled file type: 0%o", sb.st_mode);
 	    free(wcs);
 	    continue;
 	}
@@ -969,6 +1030,11 @@ static int init(int hup)
 
 static int run(void)
 {
+    if(hashjob == -1)
+    {
+	hashjob = 0;
+	checkhashes();
+    }
     return(doscan(10));
 }