X-Git-Url: http://dolda2000.com/gitweb/?a=blobdiff_plain;f=daemon%2Fclient.c;h=fa51d95e05c424dfd697967fc9050fbb6ec27383;hb=24a794c2e44028e8ec37b1be811b64acafaa7174;hp=e7fa0e72ce0a2f4aa20914a9b9f3b534b8f8ae43;hpb=d3372da97568d5e1f35fa19787c8ec8af93a0435;p=doldaconnect.git diff --git a/daemon/client.c b/daemon/client.c index e7fa0e7..fa51d95 100644 --- a/daemon/client.c +++ b/daemon/client.c @@ -56,6 +56,7 @@ 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[] = { @@ -76,7 +77,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 +137,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; @@ -278,13 +366,28 @@ 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; + if(!now) + { + if(hashwritetimer == NULL) + hashwritetimer = timercallback(ntime() + 300, (void (*)(int, void *))hashtimercb, NULL); + return; + } + if(hashwritetimer != NULL) + canceltimer(hashwritetimer); hcname = findhashcachefile(1); if((stream = fopen(hcname, "w")) == NULL) { @@ -357,13 +460,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 +474,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 +543,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 +557,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 +574,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 +942,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 +1065,11 @@ static int init(int hup) static int run(void) { + if(hashjob == -1) + { + hashjob = 0; + checkhashes(); + } return(doscan(10)); }