use proper PRIV_TASK scope with the digest object, verified in md5.vtc

src/tests/md5.vtc

@@ -313,3 +313,90 @@ client c1 {
 	expect resp.http.rfc2202t6 == "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd"
 	expect resp.http.rfc2202t7 == "6f630fad67cda0ee1fb1f562db3aa53e"
 } -run
+
+# Test re-use of digest objects in backend and client contexts
+server s1 -repeat 10 {
+        rxreq
+        txresp -hdr "Cache-Control: max-age=0"
+} -start
+
+varnish v1 -vcl+backend {
+	import blobdigest from "${vmod_topbuild}/src/.libs/libvmod_blobdigest.so";
+	import blobcode;
+
+	sub vcl_init {
+		new a = blobcode.blob(IDENTITY, "a");
+		new abcd = blobcode.blob(IDENTITY, "abcd");
+		new pangram =
+		  blobcode.blob(IDENTITY,
+		                "The quick brown fox jumps over the lazy dog");
+
+		new d1 = blobdigest.digest(MD5, a.get());
+		new d2 = blobdigest.digest(MD5, abcd.get());
+		new d3 = blobdigest.digest(MD5);
+		new d4 = blobdigest.digest(MD5, pangram.get());
+	}
+
+	sub vcl_recv {
+		set req.http.a = blobcode.encode(HEXUC, d1.final());
+
+		if (!d2.update(blobcode.decode(IDENTITY,
+		                               "efghijklmnopqrstuvwxyz"))) {
+			return(synth(500));
+		}
+		set req.http.alphalc = blobcode.encode(HEXUC, d2.final());
+	}
+
+	sub vcl_backend_fetch {
+		if (!d1.update(blobcode.decode(IDENTITY, "bc"))) {
+			return(abandon);
+		}
+		set bereq.http.abc = blobcode.encode(HEXUC, d1.final());
+
+		if (!d2.update(blobcode.decode(IDENTITY,
+		     "bcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"))) {
+			return(abandon);
+		}
+		set bereq.http.alphasoup = blobcode.encode(HEXUC, d2.final());
+	}
+
+	sub vcl_backend_response {
+		set beresp.http.abc = bereq.http.abc;
+		set beresp.http.alphasoup = bereq.http.alphasoup;
+
+		set beresp.http.empty = blobcode.encode(HEXUC, d3.final());
+
+		if (!d4.update(blobcode.decode(IDENTITY, "."))) {
+			return(abandon);
+		}
+		set beresp.http.pangramperiod
+		  = blobcode.encode(HEXLC, d4.final());
+	}
+
+	sub vcl_deliver {
+		set resp.http.a = req.http.a;
+		set resp.http.alphalc = req.http.alphalc;
+
+		if (!d3.update(blobcode.decode(IDENTITY, "message digest"))) {
+			return(synth(500));
+		}
+		set resp.http.msgdigest = blobcode.encode(HEXUC, d3.final());
+
+		set resp.http.pangram = blobcode.encode(HEXLC, d4.final());
+	}
+}
+
+client c1 -repeat 10 {
+	txreq
+	rxresp
+	expect resp.status == 200
+
+	expect resp.http.empty == "D41D8CD98F00B204E9800998ECF8427E"
+	expect resp.http.a == "0CC175B9C0F1B6A831C399E269772661"
+	expect resp.http.abc == "900150983CD24FB0D6963F7D28E17F72"
+	expect resp.http.msgdigest == "F96B697D7CB7938D525A2F31AAF161D0"
+	expect resp.http.alphalc == "C3FCD3D76192E4007DFB496CCA67E13B"
+	expect resp.http.alphasoup == "8215EF0796A20BCAAAE116D3876C664A"
+	expect resp.http.pangram == "9e107d9d372bb6826bd81d3542a419d6"
+	expect resp.http.pangramperiod == "e4d909c290d0fb1ca068ffaddf22cbd0"
+} -run

src/vmod_blobdigest.c

@@ -29,7 +29,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <pthread.h>
 
 #include "config.h"
 
@@ -58,7 +57,6 @@ struct digest_task {
 	unsigned	magic;
 #define VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC 0x646937a8
 	hash_ctx	ctx;
-	unsigned	xid;
 	int		finalized;
 };
 
@@ -67,7 +65,6 @@ struct vmod_blobdigest_digest {
 #define VMOD_BLOBDIGEST_DIGEST_MAGIC 0xaccb2e25
 	hash_ctx	ctx;
 	char		*vcl_name;
-	pthread_key_t	task;
 	enum algorithm	hash;
 };
 
@@ -219,41 +216,39 @@ WS_Contains(struct ws * const restrict ws, const void * const restrict ptr,
         return ((char *)ptr >= ws->s && (char *)(ptr + len) <= ws->e);
 }
 
+static void
+free_digest_task(void *p)
+{
+        struct digest_task *task;
+        CAST_OBJ_NOTNULL(task, p, VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC);
+        FREE_OBJ(task);
+}
+
 static struct digest_task *
 get_task(const struct vrt_ctx * const restrict ctx,
 	 const struct vmod_blobdigest_digest * const restrict h)
 {
-	unsigned xid;
-	struct digest_task *task = NULL;
-	void *p;
+	struct vmod_priv *priv;
+	struct digest_task *task;
 
-	CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
-	AN(ctx->vsl);
-	xid = VXID(ctx->vsl->wid);
-
-	if ((p = pthread_getspecific(h->task)) != NULL)
-		CAST_OBJ(task, p, VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC);
-	if (p == NULL ||
-	    ! WS_Contains(ctx->ws, task, sizeof(struct digest_task))) {
-		if ((task = WS_Alloc(ctx->ws, sizeof(struct digest_task)))
-		    == NULL)
-			return NULL;
-		task->magic = VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC;
-		task->xid = ~xid;
-		AZ(pthread_setspecific(h->task, task));
-	}
-	assert(WS_Contains(ctx->ws, task, sizeof(struct digest_task)));
-	if (p == NULL || task->xid != xid) {
+	priv = VRT_priv_task(ctx, (void *)h);
+	AN(priv);
+	if (priv->priv != NULL)
+		CAST_OBJ(task, priv->priv, VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC);
+	else {
+		ALLOC_OBJ(task, VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC);
+		AN(task);
 		memcpy(&task->ctx, &h->ctx, sizeof(hash_ctx));
-		task->xid = xid;
 		task->finalized = 0;
+		priv->priv = task;
+		priv->free = free_digest_task;
 	}
 	return task;
 }
 
 VCL_VOID
 vmod_digest__init(VRT_CTX, struct vmod_blobdigest_digest **digestp,
-		const char *vcl_name, VCL_ENUM hashs, VCL_BLOB initb)
+		  const char *vcl_name, VCL_ENUM hashs, VCL_BLOB initb)
 {
 	struct vmod_blobdigest_digest *digest;
 	enum algorithm hash = parse_algorithm(hashs);
@@ -267,7 +262,6 @@ vmod_digest__init(VRT_CTX, struct vmod_blobdigest_digest **digestp,
 	*digestp = digest;
 
 	digest->hash = hash;
-	AZ(pthread_key_create(&digest->task, NULL));
 	digest->vcl_name = strdup(vcl_name);
 	AN(digest->vcl_name);
 	init(hash, &digest->ctx);
@@ -283,7 +277,6 @@ vmod_digest__fini(struct vmod_blobdigest_digest **digestp)
 	digest = *digestp;
 	*digestp = NULL;
 	CHECK_OBJ_NOTNULL(digest, VMOD_BLOBDIGEST_DIGEST_MAGIC);
-	AZ(pthread_key_delete(digest->task));
 	if (digest->vcl_name != NULL)
 		free(digest->vcl_name);
 	FREE_OBJ(digest);
@@ -304,10 +297,7 @@ vmod_digest_update(VRT_CTX, struct vmod_blobdigest_digest *h, VCL_BLOB b)
 	/* XXX: if in init or fini, just update the object context */
 
 	task = get_task(ctx, h);
-	if (task == NULL) {
-		ERRNOMEM(ctx, "digest.update()"); // XXX: use vcl_name
-		return 0;
-	}
+	CHECK_OBJ_NOTNULL(task, VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC);
 	if (task->finalized) {
 		ERR(ctx, "already finalized in digest.update()");
 		return 0;
@@ -331,10 +321,7 @@ vmod_digest_final(VRT_CTX, struct vmod_blobdigest_digest *h)
 	/* XXX: if in init or fini, just finalize the object context */
 
 	task = get_task(ctx, h);
-	if (task == NULL) {
-		ERRNOMEM(ctx, "digest.final()"); // XXX: use vcl_name
-		return NULL;
-	}
+	CHECK_OBJ_NOTNULL(task, VMOD_BLOBDIGEST_DIGEST_TASK_MAGIC);
 	if (task->finalized) {
 		ERR(ctx, "already finalized in digest.final()");
 		return NULL;