More improvements

Author: kocsismate

ext/uri/php_uriparser.c

@@ -42,7 +42,8 @@ static UriUriA *uriparser_copy_uri(UriUriA *uriparser_uri)
 
 static void uriparser_normalize_uri(UriUriA *uriparser_uri)
 {
-	ZEND_ASSERT(uriNormalizeSyntaxExA(uriparser_uri, (unsigned int)-1) == URI_SUCCESS);
+	int result = uriNormalizeSyntaxExA(uriparser_uri, (unsigned int)-1);
+	ZEND_ASSERT(result == URI_SUCCESS);
 }
 
 static UriUriA *uriparser_read_uri(uriparser_uris_t *uriparser_uris, uri_component_read_mode_t read_mode)
@@ -375,12 +376,14 @@ static zend_string *uriparser_uri_to_string(void *uri, uri_recomposition_mode_t
 	}
 
 	int charsRequired = 0;
-	ZEND_ASSERT(uriToStringCharsRequiredA(uriparser_uri, &charsRequired) == URI_SUCCESS);
+	int result = uriToStringCharsRequiredA(uriparser_uri, &charsRequired);
+	ZEND_ASSERT(result == URI_SUCCESS);
 
 	charsRequired++;
 
 	zend_string *uri_string = zend_string_alloc(charsRequired - 1, false);
-	ZEND_ASSERT(uriToStringA(ZSTR_VAL(uri_string), uriparser_uri, charsRequired, NULL) == URI_SUCCESS);
+	result = uriToStringA(ZSTR_VAL(uri_string), uriparser_uri, charsRequired, NULL);
+	ZEND_ASSERT(result == URI_SUCCESS);
 
 	if (exclude_fragment) {
 		const char *pos = zend_memrchr(ZSTR_VAL(uri_string), '#', ZSTR_LEN(uri_string));

ext/uri/uriparser/src/UriCopy.c

@@ -72,6 +72,7 @@
 # include <uriparser/Uri.h>
 # include "UriCommon.h"
 # include "UriMemory.h"
+# include "UriNormalize.h"
 # include "UriCopy.h"
 #endif
 
@@ -102,14 +103,14 @@ static void URI_FUNC(PreventLeakageAfterCopy)(URI_TYPE(Uri) * uri,
 
 int URI_FUNC(CopyUriMm)(URI_TYPE(Uri) * destUri,
 		 const URI_TYPE(Uri) * sourceUri, UriMemoryManager * memory) {
-	if (sourceUri == NULL) {
+	unsigned int doneMask = URI_NORMALIZED;
+
+	if (sourceUri == NULL || destUri == NULL) {
 		return URI_ERROR_NULL;
 	}
 
 	URI_CHECK_MEMORY_MANAGER(memory); /* may return */
 
-	unsigned int doneMask = URI_NORMALIZED;
-
 	if (URI_FUNC(CopyRangeAsNeeded)(&destUri->scheme, &sourceUri->scheme, URI_FALSE, memory) == URI_FALSE) {
 		return URI_ERROR_MALLOC;
 	}
@@ -141,8 +142,6 @@ int URI_FUNC(CopyUriMm)(URI_TYPE(Uri) * destUri,
 		*(destUri->hostData.ip4) = *(sourceUri->hostData.ip4);
 	}
 
-	doneMask |= URI_NORMALIZE_HOST;
-
 	if (sourceUri->hostData.ip6 == NULL) {
 		destUri->hostData.ip6 = NULL;
 	} else {
@@ -166,47 +165,44 @@ int URI_FUNC(CopyUriMm)(URI_TYPE(Uri) * destUri,
 
 	doneMask |= URI_NORMALIZE_PORT;
 
-	if (sourceUri->pathHead != NULL && sourceUri->pathTail != NULL) {
-		URI_TYPE(PathSegment) *walker;
-		URI_TYPE(PathSegment) *walkerNew;
-
-		destUri->pathHead = memory->malloc(memory, sizeof(URI_TYPE(PathSegment)));
-		if (destUri->pathHead == NULL) {
-			URI_FUNC(PreventLeakageAfterCopy)(destUri, doneMask, memory);
-			return URI_ERROR_MALLOC;
-		}
-
-		if (URI_FUNC(CopyRangeAsNeeded)(&destUri->pathHead->text, &sourceUri->pathHead->text, URI_TRUE, memory) == URI_FALSE) {
-			URI_FUNC(PreventLeakageAfterCopy)(destUri, doneMask, memory);
-			memory->free(memory, destUri->pathHead);
-			return URI_ERROR_MALLOC;
-		}
-		destUri->pathHead->reserved = NULL;
+	destUri->pathHead = NULL;
+	destUri->pathTail = NULL;
 
-		doneMask |= URI_NORMALIZE_PATH;
+	if (sourceUri->pathHead != NULL) {
+		URI_TYPE(PathSegment) * sourceWalker = sourceUri->pathHead;
+		URI_TYPE(PathSegment) * destPrev = NULL;
 
-		walker = sourceUri->pathHead->next;
-		walkerNew = destUri->pathHead;
-		while (walker != NULL && (walker->text.first != walker->text.afterLast || walker->text.first == URI_FUNC(SafeToPointTo))) {
-			walkerNew->next = memory->malloc(memory, sizeof(URI_TYPE(PathSegment)));
-			if (walkerNew->next == NULL) {
+		while (sourceWalker != NULL) {
+			URI_TYPE(PathSegment) * destWalker = memory->malloc(memory, sizeof(URI_TYPE(PathSegment)));
+			if (destWalker == NULL) {
 				URI_FUNC(PreventLeakageAfterCopy)(destUri, doneMask, memory);
 				return URI_ERROR_MALLOC;
 			}
 
-			walkerNew = walkerNew->next;
-			if (URI_FUNC(CopyRangeAsNeeded)(&walkerNew->text, &walker->text, URI_TRUE, memory) == URI_FALSE) {
+			destWalker->text.first = NULL;
+			destWalker->text.afterLast = NULL;
+			destWalker->next = NULL;
+			destWalker->reserved = NULL;
+
+			if (destUri->pathHead == NULL) {
+				destUri->pathHead = destWalker;
+				doneMask |= URI_NORMALIZE_PATH;
+			}
+
+			if (URI_FUNC(CopyRangeAsNeeded)(&destWalker->text, &sourceWalker->text, URI_TRUE, memory) == URI_FALSE) {
 				URI_FUNC(PreventLeakageAfterCopy)(destUri, doneMask, memory);
 				return URI_ERROR_MALLOC;
 			}
-			walkerNew->reserved = NULL;
-			walker = walker->next;
+
+			if (destPrev != NULL) {
+				destPrev->next = destWalker;
+			}
+
+			destPrev = destWalker;
+			sourceWalker = sourceWalker->next;
+
+			destUri->pathTail = destPrev;
 		}
-		walkerNew->next = NULL;
-		destUri->pathTail = walkerNew;
-	} else {
-		destUri->pathHead = NULL;
-		destUri->pathTail = NULL;
 	}
 
 	if (URI_FUNC(CopyRangeAsNeeded)(&destUri->query, &sourceUri->query, URI_FALSE, memory) == URI_FALSE) {

ext/uri/uriparser/src/UriCopy.h

@@ -69,8 +69,6 @@
 
 
 
-void URI_FUNC(PreventLeakage)(URI_TYPE(Uri) * uri,
-		unsigned int revertMask, UriMemoryManager * memory);
 int URI_FUNC(CopyUriMm)(URI_TYPE(Uri) * destUri,
 		const URI_TYPE(Uri) * sourceUri, UriMemoryManager * memory);
 int URI_FUNC(CopyUri)(URI_TYPE(Uri) * destUri,

ext/uri/uriparser/src/UriNormalize.c

@@ -71,7 +71,6 @@
 # include <uriparser/Uri.h>
 # include "UriNormalizeBase.h"
 # include "UriCommon.h"
-# include "UriCopy.h"
 # include "UriMemory.h"
 #endif
 
@@ -547,6 +546,75 @@ int URI_FUNC(NormalizeSyntax)(URI_TYPE(Uri) * uri) {
 }
 
 
+static const URI_CHAR * URI_FUNC(PastLeadingZeros)(const URI_CHAR * first, const URI_CHAR * afterLast) {
+	assert(first != NULL);
+	assert(afterLast != NULL);
+	assert(first != afterLast);
+
+	{
+		/* Find the first non-zero character */
+		const URI_CHAR * remainderFirst = first;
+		while ((remainderFirst < afterLast) && (remainderFirst[0] == _UT('0'))) {
+			remainderFirst++;
+		}
+
+		/* Is the string /all/ zeros? */
+		if (remainderFirst == afterLast) {
+			/* Yes, and length is >=1 because we ruled out the empty string earlier;
+			 * pull back onto rightmost zero */
+			assert(remainderFirst > first);
+			remainderFirst--;
+			assert(remainderFirst[0] == _UT('0'));
+		}
+
+		return remainderFirst;
+	}
+}
+
+
+
+static void URI_FUNC(DropLeadingZerosInplace)(URI_CHAR * first, const URI_CHAR ** afterLast) {
+	assert(first != NULL);
+	assert(afterLast != NULL);
+	assert(*afterLast != NULL);
+
+	if (first == *afterLast) {
+		return;
+	}
+
+	{
+		const URI_CHAR * const remainderFirst = URI_FUNC(PastLeadingZeros)(first, *afterLast);
+
+		if (remainderFirst > first) {
+			const size_t remainderLen = *afterLast - remainderFirst;
+			memmove(first, remainderFirst, remainderLen * sizeof(URI_CHAR));
+			first[remainderLen] = _UT('\0');
+			*afterLast = first + remainderLen;
+		}
+	}
+}
+
+
+
+static void URI_FUNC(AdvancePastLeadingZeros)(
+		const URI_CHAR ** first, const URI_CHAR * afterLast) {
+	assert(first != NULL);
+	assert(*first != NULL);
+	assert(afterLast != NULL);
+
+	if (*first == afterLast) {
+		return;
+	}
+
+	{
+		const URI_CHAR * const remainderFirst = URI_FUNC(PastLeadingZeros)(*first, afterLast);
+
+		/* Cut off leading zeros */
+		*first = remainderFirst;
+	}
+}
+
+
 
 static URI_INLINE int URI_FUNC(NormalizeSyntaxEngine)(URI_TYPE(Uri) * uri,
 		unsigned int inMask, unsigned int * outMask,
@@ -648,6 +716,27 @@ static URI_INLINE int URI_FUNC(NormalizeSyntaxEngine)(URI_TYPE(Uri) * uri,
 		}
 	}
 
+	/* Port */
+	if (outMask != NULL) {
+		/* Is there a port even? */
+		if (uri->portText.first != NULL) {
+			/* Determine whether the port is already normalized, i.e. either "", "0" or no leading zeros */
+			const size_t portLen = uri->portText.afterLast - uri->portText.first;
+			if ((portLen > 1) && (uri->portText.first[0] == _UT('0'))) {
+				*outMask |= URI_NORMALIZE_PORT;
+			}
+		}
+	} else {
+		/* Normalize the port, i.e. drop leading zeros (except for string "0") */
+		if ((inMask & URI_NORMALIZE_PORT) && (uri->portText.first != NULL)) {
+			if (uri->owner) {
+				URI_FUNC(DropLeadingZerosInplace)((URI_CHAR *)uri->portText.first, &(uri->portText.afterLast));
+			} else {
+				URI_FUNC(AdvancePastLeadingZeros)(&(uri->portText.first), uri->portText.afterLast);
+			}
+		}
+	}
+
 	/* User info */
 	if (outMask != NULL) {
 		const UriBool normalizeUserInfo = URI_FUNC(ContainsUglyPercentEncoding)(

ext/uri/uriparser/src/UriNormalize.h

@@ -0,0 +1,76 @@
+/*
+ * uriparser - RFC 3986 URI parsing library
+ *
+ * Copyright (C) 2018, Weijia Song <[email protected]>
+ * Copyright (C) 2018, Sebastian Pipping <[email protected]>
+ * Copyright (C) 2025, Máté Kocsis <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source  and binary forms, with or without
+ * modification, are permitted provided  that the following conditions
+ * are met:
+ *
+ *     1. Redistributions  of  source  code   must  retain  the  above
+ *        copyright notice, this list  of conditions and the following
+ *        disclaimer.
+ *
+ *     2. Redistributions  in binary  form  must  reproduce the  above
+ *        copyright notice, this list  of conditions and the following
+ *        disclaimer  in  the  documentation  and/or  other  materials
+ *        provided with the distribution.
+ *
+ *     3. Neither the  name of the  copyright holder nor the  names of
+ *        its contributors may be used  to endorse or promote products
+ *        derived from  this software  without specific  prior written
+ *        permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND  ANY EXPRESS OR IMPLIED WARRANTIES,  INCLUDING, BUT NOT
+ * LIMITED TO,  THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS
+ * FOR  A  PARTICULAR  PURPOSE  ARE  DISCLAIMED.  IN  NO  EVENT  SHALL
+ * THE  COPYRIGHT HOLDER  OR CONTRIBUTORS  BE LIABLE  FOR ANY  DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA,  OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if (defined(URI_PASS_ANSI) && !defined(URI_COPY_H_ANSI)) \
+	|| (defined(URI_PASS_UNICODE) && !defined(URI_COPY_H_UNICODE)) \
+	|| (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* What encodings are enabled? */
+#include <uriparser/UriDefsConfig.h>
+#if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
+/* Include SELF twice */
+# ifdef URI_ENABLE_ANSI
+#  define URI_PASS_ANSI 1
+#  include "UriNormalize.h"
+#  undef URI_PASS_ANSI
+# endif
+# ifdef URI_ENABLE_UNICODE
+#  define URI_PASS_UNICODE 1
+#  include "UriNormalize.h"
+#  undef URI_PASS_UNICODE
+# endif
+/* Only one pass for each encoding */
+#elif (defined(URI_PASS_ANSI) && !defined(URI_NORMALIZE_H_ANSI) \
+	&& defined(URI_ENABLE_ANSI)) || (defined(URI_PASS_UNICODE) \
+	&& !defined(URI_NORMALIZE_H_UNICODE) && defined(URI_ENABLE_UNICODE))
+# ifdef URI_PASS_ANSI
+#  define URI_NORMALIZE_H_ANSI 1
+#  include <uriparser/UriDefsAnsi.h>
+# else
+#  define URI_NORMALIZE_H_UNICODE 1
+#  include <uriparser/UriDefsUnicode.h>
+# endif
+
+
+
+void URI_FUNC(PreventLeakage)(URI_TYPE(Uri) * uri,
+		unsigned int revertMask, UriMemoryManager * memory);
+
+#endif
+#endif