Don't thread ctx through safe fz_obj functions.

1 files changed, 77 insertions, 76 deletions

diff --git a/pdf/pdf_crypt.c b/pdf/pdf_crypt.c
index 81f3781a..7d5b7902 100644
--- a/pdf/pdf_crypt.c
+++ b/pdf/pdf_crypt.c
@@ -54,26 +54,27 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	fz_error error;
 	fz_obj *obj;
 
-	crypt = fz_calloc(ctx, 1, sizeof(pdf_crypt));
+	crypt = fz_malloc(ctx, sizeof(pdf_crypt));
+	memset(crypt, 0, sizeof *crypt);
 
 	/* Common to all security handlers (PDF 1.7 table 3.18) */
 
-	obj = fz_dict_gets(ctx, dict, "Filter");
-	if (!fz_is_name(ctx, obj))
+	obj = fz_dict_gets(dict, "Filter");
+	if (!fz_is_name(obj))
 	{
 		pdf_free_crypt(ctx, crypt);
 		return fz_error_make("unspecified encryption handler");
 	}
-	if (strcmp(fz_to_name(ctx, obj), "Standard") != 0)
+	if (strcmp(fz_to_name(obj), "Standard") != 0)
 	{
 		pdf_free_crypt(ctx, crypt);
-		return fz_error_make("unknown encryption handler: '%s'", fz_to_name(ctx, obj));
+		return fz_error_make("unknown encryption handler: '%s'", fz_to_name(obj));
 	}
 
 	crypt->v = 0;
-	obj = fz_dict_gets(ctx, dict, "V");
-	if (fz_is_int(ctx, obj))
-		crypt->v = fz_to_int(ctx, obj);
+	obj = fz_dict_gets(dict, "V");
+	if (fz_is_int(obj))
+		crypt->v = fz_to_int(obj);
 	if (crypt->v != 1 && crypt->v != 2 && crypt->v != 4 && crypt->v != 5)
 	{
 		pdf_free_crypt(ctx, crypt);
@@ -83,9 +84,9 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	crypt->length = 40;
 	if (crypt->v == 2 || crypt->v == 4)
 	{
-		obj = fz_dict_gets(ctx, dict, "Length");
-		if (fz_is_int(ctx, obj))
-			crypt->length = fz_to_int(ctx, obj);
+		obj = fz_dict_gets(dict, "Length");
+		if (fz_is_int(obj))
+			crypt->length = fz_to_int(obj);
 
 		/* work-around for pdf generators that assume length is in bytes */
 		if (crypt->length < 40)
@@ -123,8 +124,8 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 		crypt->strf.method = PDF_CRYPT_NONE;
 		crypt->strf.length = crypt->length;
 
-		obj = fz_dict_gets(ctx, dict, "CF");
-		if (fz_is_dict(ctx, obj))
+		obj = fz_dict_gets(dict, "CF");
+		if (fz_is_dict(obj))
 		{
 			crypt->cf = fz_keep_obj(obj);
 		}
@@ -133,10 +134,10 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 			crypt->cf = NULL;
 		}
 
-		obj = fz_dict_gets(ctx, dict, "StmF");
-		if (fz_is_name(ctx, obj))
+		obj = fz_dict_gets(dict, "StmF");
+		if (fz_is_name(obj))
 		{
-			error = pdf_parse_crypt_filter(ctx, &crypt->stmf, crypt->cf, fz_to_name(ctx, obj), crypt->length);
+			error = pdf_parse_crypt_filter(ctx, &crypt->stmf, crypt->cf, fz_to_name(obj), crypt->length);
 			if (error)
 			{
 				pdf_free_crypt(ctx, crypt);
@@ -144,10 +145,10 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 			}
 		}
 
-		obj = fz_dict_gets(ctx, dict, "StrF");
-		if (fz_is_name(ctx, obj))
+		obj = fz_dict_gets(dict, "StrF");
+		if (fz_is_name(obj))
 		{
-			error = pdf_parse_crypt_filter(ctx, &crypt->strf, crypt->cf, fz_to_name(ctx, obj), crypt->length);
+			error = pdf_parse_crypt_filter(ctx, &crypt->strf, crypt->cf, fz_to_name(obj), crypt->length);
 			if (error)
 			{
 				pdf_free_crypt(ctx, crypt);
@@ -162,36 +163,36 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 
 	/* Standard security handler (PDF 1.7 table 3.19) */
 
-	obj = fz_dict_gets(ctx, dict, "R");
-	if (fz_is_int(ctx, obj))
-		crypt->r = fz_to_int(ctx, obj);
+	obj = fz_dict_gets(dict, "R");
+	if (fz_is_int(obj))
+		crypt->r = fz_to_int(obj);
 	else
 	{
 		pdf_free_crypt(ctx, crypt);
 		return fz_error_make("encryption dictionary missing revision value");
 	}
 
-	obj = fz_dict_gets(ctx, dict, "O");
-	if (fz_is_string(ctx, obj) && fz_to_str_len(ctx, obj) == 32)
-		memcpy(crypt->o, fz_to_str_buf(ctx, obj), 32);
+	obj = fz_dict_gets(dict, "O");
+	if (fz_is_string(obj) && fz_to_str_len(obj) == 32)
+		memcpy(crypt->o, fz_to_str_buf(obj), 32);
 	/* /O and /U are supposed to be 48 bytes long for revision 5, they're often longer, though */
-	else if (crypt->r == 5 && fz_is_string(ctx, obj) && fz_to_str_len(ctx, obj) >= 48)
-		memcpy(crypt->o, fz_to_str_buf(ctx, obj), 48);
+	else if (crypt->r == 5 && fz_is_string(obj) && fz_to_str_len(obj) >= 48)
+		memcpy(crypt->o, fz_to_str_buf(obj), 48);
 	else
 	{
 		pdf_free_crypt(ctx, crypt);
 		return fz_error_make("encryption dictionary missing owner password");
 	}
 
-	obj = fz_dict_gets(ctx, dict, "U");
-	if (fz_is_string(ctx, obj) && fz_to_str_len(ctx, obj) == 32)
-		memcpy(crypt->u, fz_to_str_buf(ctx, obj), 32);
-	else if (fz_is_string(ctx, obj) && fz_to_str_len(ctx, obj) >= 48 && crypt->r == 5)
-		memcpy(crypt->u, fz_to_str_buf(ctx, obj), 48);
-	else if (fz_is_string(ctx, obj) && fz_to_str_len(ctx, obj) < 32)
+	obj = fz_dict_gets(dict, "U");
+	if (fz_is_string(obj) && fz_to_str_len(obj) == 32)
+		memcpy(crypt->u, fz_to_str_buf(obj), 32);
+	else if (fz_is_string(obj) && fz_to_str_len(obj) >= 48 && crypt->r == 5)
+		memcpy(crypt->u, fz_to_str_buf(obj), 48);
+	else if (fz_is_string(obj) && fz_to_str_len(obj) < 32)
 	{
-		fz_warn("encryption password key too short (%d)", fz_to_str_len(ctx, obj));
-		memcpy(crypt->u, fz_to_str_buf(ctx, obj), fz_to_str_len(ctx, obj));
+		fz_warn("encryption password key too short (%d)", fz_to_str_len(obj));
+		memcpy(crypt->u, fz_to_str_buf(obj), fz_to_str_len(obj));
 	}
 	else
 	{
@@ -199,9 +200,9 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 		return fz_error_make("encryption dictionary missing user password");
 	}
 
-	obj = fz_dict_gets(ctx, dict, "P");
-	if (fz_is_int(ctx, obj))
-		crypt->p = fz_to_int(ctx, obj);
+	obj = fz_dict_gets(dict, "P");
+	if (fz_is_int(obj))
+		crypt->p = fz_to_int(obj);
 	else
 	{
 		pdf_free_crypt(ctx, crypt);
@@ -210,34 +211,34 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 
 	if (crypt->r == 5)
 	{
-		obj = fz_dict_gets(ctx, dict, "OE");
-		if (!fz_is_string(ctx, obj) || fz_to_str_len(ctx, obj) != 32)
+		obj = fz_dict_gets(dict, "OE");
+		if (!fz_is_string(obj) || fz_to_str_len(obj) != 32)
 		{
 			pdf_free_crypt(ctx, crypt);
 			return fz_error_make("encryption dictionary missing owner encryption key");
 		}
-		memcpy(crypt->oe, fz_to_str_buf(ctx, obj), 32);
+		memcpy(crypt->oe, fz_to_str_buf(obj), 32);
 
-		obj = fz_dict_gets(ctx, dict, "UE");
-		if (!fz_is_string(ctx, obj) || fz_to_str_len(ctx, obj) != 32)
+		obj = fz_dict_gets(dict, "UE");
+		if (!fz_is_string(obj) || fz_to_str_len(obj) != 32)
 		{
 			pdf_free_crypt(ctx, crypt);
 			return fz_error_make("encryption dictionary missing user encryption key");
 		}
-		memcpy(crypt->ue, fz_to_str_buf(ctx, obj), 32);
+		memcpy(crypt->ue, fz_to_str_buf(obj), 32);
 	}
 
 	crypt->encrypt_metadata = 1;
-	obj = fz_dict_gets(ctx, dict, "EncryptMetadata");
-	if (fz_is_bool(ctx, obj))
-		crypt->encrypt_metadata = fz_to_bool(ctx, obj);
+	obj = fz_dict_gets(dict, "EncryptMetadata");
+	if (fz_is_bool(obj))
+		crypt->encrypt_metadata = fz_to_bool(obj);
 
 	/* Extract file identifier string */
 
-	if (fz_is_array(ctx, id) && fz_array_len(ctx, id) == 2)
+	if (fz_is_array(id) && fz_array_len(id) == 2)
 	{
-		obj = fz_array_get(ctx, id, 0);
-		if (fz_is_string(ctx, obj))
+		obj = fz_array_get(id, 0);
+		if (fz_is_string(obj))
 			crypt->id = fz_keep_obj(obj);
 	}
 	else
@@ -250,8 +251,8 @@ pdf_new_crypt(fz_context *ctx, pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 void
 pdf_free_crypt(fz_context *ctx, pdf_crypt *crypt)
 {
-	if (crypt->id) fz_drop_obj(ctx, crypt->id);
-	if (crypt->cf) fz_drop_obj(ctx, crypt->cf);
+	if (crypt->id) fz_drop_obj(crypt->id);
+	if (crypt->cf) fz_drop_obj(crypt->cf);
 	fz_free(ctx, crypt);
 }
 
@@ -280,29 +281,29 @@ pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, fz_obj *cf_obj, ch
 		return fz_okay;
 	}
 
-	dict = fz_dict_gets(ctx, cf_obj, name);
-	if (!fz_is_dict(ctx, dict))
+	dict = fz_dict_gets(cf_obj, name);
+	if (!fz_is_dict(dict))
 	{
 		return fz_error_make("cannot parse crypt filter (%d %d R)", fz_to_num(cf_obj), fz_to_gen(cf_obj));
 	}
-	obj = fz_dict_gets(ctx, dict, "CFM");
-	if (fz_is_name(ctx, obj))
+	obj = fz_dict_gets(dict, "CFM");
+	if (fz_is_name(obj))
 	{
-		if (!strcmp(fz_to_name(ctx, obj), "None"))
+		if (!strcmp(fz_to_name(obj), "None"))
 			cf->method = PDF_CRYPT_NONE;
-		else if (!strcmp(fz_to_name(ctx, obj), "V2"))
+		else if (!strcmp(fz_to_name(obj), "V2"))
 			cf->method = PDF_CRYPT_RC4;
-		else if (!strcmp(fz_to_name(ctx, obj), "AESV2"))
+		else if (!strcmp(fz_to_name(obj), "AESV2"))
 			cf->method = PDF_CRYPT_AESV2;
-		else if (!strcmp(fz_to_name(ctx, obj), "AESV3"))
+		else if (!strcmp(fz_to_name(obj), "AESV3"))
 			cf->method = PDF_CRYPT_AESV3;
 		else
-			fz_error_make("unknown encryption method: %s", fz_to_name(ctx, obj));
+			fz_error_make("unknown encryption method: %s", fz_to_name(obj));
 	}
 
-	obj = fz_dict_gets(ctx, dict, "Length");
-	if (fz_is_int(ctx, obj))
-		cf->length = fz_to_int(ctx, obj);
+	obj = fz_dict_gets(dict, "Length");
+	if (fz_is_int(obj))
+		cf->length = fz_to_int(obj);
 
 	/* the length for crypt filters is supposed to be in bytes not bits */
 	if (cf->length < 40)
@@ -358,7 +359,7 @@ pdf_compute_encryption_key(pdf_crypt *crypt, unsigned char *password, int pwlen,
 	fz_md5_update(&md5, buf, 4);
 
 	/* Step 5 - pass first element of ID array */
-	fz_md5_update(&md5, (unsigned char *)fz_to_str_buf(crypt->ctx, crypt->id), fz_to_str_len(crypt->ctx, crypt->id));
+	fz_md5_update(&md5, (unsigned char *)fz_to_str_buf(crypt->id), fz_to_str_len(crypt->id));
 
 	/* Step 6 (revision 4 or greater) - if metadata is not encrypted pass 0xFFFFFFFF */
 	if (crypt->r >= 4)
@@ -467,7 +468,7 @@ pdf_compute_user_password(pdf_crypt *crypt, unsigned char *password, int pwlen,
 
 		fz_md5_init(&md5);
 		fz_md5_update(&md5, padding, 32);
-		fz_md5_update(&md5, (unsigned char*)fz_to_str_buf(crypt->ctx, crypt->id), fz_to_str_len(crypt->ctx, crypt->id));
+		fz_md5_update(&md5, (unsigned char*)fz_to_str_buf(crypt->id), fz_to_str_len(crypt->id));
 		fz_md5_final(&md5, digest);
 
 		fz_arc4_init(&arc4, crypt->key, n);
@@ -715,10 +716,10 @@ pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, unsigned char
 	if (fz_is_indirect(obj))
 		return;
 
-	if (fz_is_string(ctx, obj))
+	if (fz_is_string(obj))
 	{
-		s = (unsigned char *)fz_to_str_buf(ctx, obj);
-		n = fz_to_str_len(ctx, obj);
+		s = (unsigned char *)fz_to_str_buf(obj);
+		n = fz_to_str_len(obj);
 
 		if (crypt->strf.method == PDF_CRYPT_RC4)
 		{
@@ -742,26 +743,26 @@ pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, unsigned char
 				if (s[n - 17] < 1 || s[n - 17] > 16)
 					fz_warn("aes padding out of range");
 				else
-					fz_set_str_len(ctx, obj, n - 16 - s[n - 17]);
+					fz_set_str_len(obj, n - 16 - s[n - 17]);
 			}
 		}
 	}
 
-	else if (fz_is_array(ctx, obj))
+	else if (fz_is_array(obj))
 	{
-		n = fz_array_len(ctx, obj);
+		n = fz_array_len(obj);
 		for (i = 0; i < n; i++)
 		{
-			pdf_crypt_obj_imp(ctx, crypt, fz_array_get(ctx, obj, i), key, keylen);
+			pdf_crypt_obj_imp(ctx, crypt, fz_array_get(obj, i), key, keylen);
 		}
 	}
 
-	else if (fz_is_dict(ctx, obj))
+	else if (fz_is_dict(obj))
 	{
-		n = fz_dict_len(ctx, obj);
+		n = fz_dict_len(obj);
 		for (i = 0; i < n; i++)
 		{
-			pdf_crypt_obj_imp(ctx, crypt, fz_dict_get_val(ctx, obj, i), key, keylen);
+			pdf_crypt_obj_imp(ctx, crypt, fz_dict_get_val(obj, i), key, keylen);
 		}
 	}
 }