Ticket #12710: 0001-BPackageInfo-Parser-Validate-URL-strings-10jun2016-1855.patch

.gitignore

@@ -12 +12 @@
 # compiled/optimized Python
 *.pyc
 *.pyo
+
+# MacOS-X directory attributes
+.DS_Store

build/jam/BuildSetup

@@ -496 +496 @@
         HOST_LIBROOT += /usr/lib/libgnuregex.so ;
         HOST_STATIC_LIBROOT += /usr/lib/libgnuregex.so ;
     } else if $(HOST_PLATFORM) = darwin {
-        HOST_LIBROOT += libgnuregex_build.a ;
-        HOST_STATIC_LIBROOT += libgnuregex_build.a ;
+        HOST_LIBROOT += libgnuregex_build.so ;
+        HOST_STATIC_LIBROOT += libgnuregex_build.so ;
     }
 
     # The BeOS compilers define __INTEL__ respectively __POWERPC__. On the

new file docs/develop/build/libgnuregex.md

@@ +1 @@
+# libgnuregex
+
+This library exists because some systems don't have a flavor of regex library
+built-in which supports groups.  This variant does include group-support.  An
+example of where this comes into play is with the `BUrl` class where URLs are
+parsed, in part, using regular expressions.
+
+## Use with MacOS-X
+
+In the case of MacOS-X, the dynamic-library build product
+`libgnuregex_build.so` can be configured for use by configuring the
+`DYLD_INSERT_LIBRARIES` environment variable.

headers/os/net/Url.h

@@ -1 +1 @@
 /*
- * Copyright 2010 Haiku Inc. All rights reserved.
+ * Copyright 2010-2016 Haiku Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  */
 #ifndef _B_URL_H_
@@ -33 +33 @@
             BUrl&               SetPath(const BString& path);
             BUrl&               SetRequest(const BString& request);
             BUrl&               SetFragment(const BString& fragment);
-            
+
     // URL fields access
             const BString&      UrlString() const;
             const BString&      Protocol() const;
@@ -46 +46 @@
             const BString&      Path() const;
             const BString&      Request() const;
             const BString&      Fragment() const;
-            
+
     // URL fields tests
             bool                IsValid() const;
             bool                HasProtocol() const;
@@ -64 +64 @@
             void                UrlEncode(bool strict = false);
             void                UrlDecode(bool strict = false);
 
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
             status_t            IDNAToAscii();
             status_t            IDNAToUnicode();
+#endif
 
     // Url encoding/decoding of strings
-    static  BString             UrlEncode(const BString& url, 
-                                    bool strict = false, 
+    static  BString             UrlEncode(const BString& url,
+                                    bool strict = false,
                                     bool directory = false);
-    static  BString             UrlDecode(const BString& url, 
+    static  BString             UrlDecode(const BString& url,
                                     bool strict = false);
 
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
     // utility functionality
             bool                HasPreferredApplication() const;
             BString             PreferredApplication() const;
             status_t            OpenWithPreferredApplication(
                                     bool onProblemAskUser = true) const;
+#endif
 
     // BArchivable members
     virtual status_t            Archive(BMessage* into,
@@ -93 +97 @@
             const BUrl&         operator=(const BUrl& other);
             const BUrl&         operator=(const BString& string);
             const BUrl&         operator=(const char* string);
-            
+
     // URL to string conversion
                                 operator const char*() const;
 
 private:
             void                _ResetFields();
+            bool                _ContainsDelimiter(const BString& url);
             void                _ExplodeUrlString(const BString& urlString);
             BString             _MergePath(const BString& relative) const;
             void                _SetPathUnsafe(const BString& path);
 
-    static  BString             _DoUrlEncodeChunk(const BString& chunk, 
+    static  BString             _DoUrlEncodeChunk(const BString& chunk,
                                     bool strict, bool directory = false);
-    static  BString             _DoUrlDecodeChunk(const BString& chunk, 
+    static  BString             _DoUrlDecodeChunk(const BString& chunk,
                                     bool strict);
 
             bool                _IsProtocolValid();
@@ -128 +133 @@
             BString             fPath;
             BString             fRequest;
             BString             fFragment;
-            
+
     mutable bool                fUrlStringValid : 1;
     mutable bool                fAuthorityValid : 1;
     mutable bool                fUserInfoValid : 1;

src/bin/Jamfile

@@ -134 +134 @@
     ramdisk.cpp
     : shared be [ TargetLibsupc++ ] : $(haiku-utils_rsrc) ;
 
-# standard commands that need libbe.so, libbnetapi.solibsupc++.so
+# standard commands that need libbe.so, libbnetapi.so
+StdBinCommands
+    package.cpp
+    : be bnetapi : $(haiku-utils_rsrc) ;
+
+# standard commands that need libbe.so, libbnetapi.so, libsupc++.so
 StdBinCommands
     open.cpp
     urlwrapper.cpp

src/build/libbe/Jamfile

@@ -11 +11 @@
     <libbe_build>app_kit.o
     <libbe_build>icon_kit.o
     <libbe_build>interface_kit.o
+    <libbe_build>network_kit.o
     <libbe_build>storage_kit.o
     <libbe_build>support_kit.o
 
+    libshared_build.a
+
     z $(HOST_LIBSUPC++) $(HOST_LIBSTDC++)
 ;
 
 SubInclude HAIKU_TOP src build libbe app ;
 SubInclude HAIKU_TOP src build libbe icon ;
 SubInclude HAIKU_TOP src build libbe interface ;
+SubInclude HAIKU_TOP src build libbe network ;
 SubInclude HAIKU_TOP src build libbe storage ;
 SubInclude HAIKU_TOP src build libbe support ;

new file src/build/libbe/network/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src build libbe network;
+
+UseHeaders [ FDirName $(HAIKU_TOP) headers build ] : true ;
+UseHeaders [ FDirName $(HAIKU_TOP) headers os net ] : true ;
+UseHeaders [ FDirName $(HAIKU_TOP) headers private shared ] : true ;
+
+UsePrivateBuildHeaders app interface shared network ;
+
+USES_BE_API on <libbe_build>network_kit.o = true ;
+
+SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits network libnetapi ] ;
+
+BuildPlatformMergeObjectPIC <libbe_build>network_kit.o :
+    Url.cpp
+;

src/build/libgnuregex/Jamfile

@@ -1 +1 @@
 SubDir HAIKU_TOP src build libgnuregex ;
 
-BuildPlatformStaticLibrary libgnuregex_build.a : regex.c ;
+BuildPlatformSharedLibrary libgnuregex_build.so :
+    regex.c
+    :
+    # no linked libraries here
+;

src/build/libpackage/Jamfile

@@ -2 +2 @@
 
 UsePrivateBuildHeaders kernel package shared storage support ;
 
+UseHeaders [ FDirName $(HAIKU_TOP) headers os net ] : true ;
+
 SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package ] ;
 SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package hpkg ] ;
 SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package hpkg v1 ] ;

src/build/libshared/Jamfile

@@ -2 +2 @@
 
 USES_BE_API on libshared_build.a = true ;
 
+UseHeaders [ FDirName $(HAIKU_TOP) headers private shared ] : true ;
+
 UsePrivateBuildHeaders shared ;
 
 SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits shared ] ;
@@ -10 +12 @@
     Keymap.cpp
     NaturalCompare.cpp
     SHA256.cpp
+    RegExp.cpp
+    
+    :
+    
+    # no shared libs, but will require 'libgnuregex' dynamic library on Darwin
 ;

src/kits/network/libnetapi/Url.cpp

@@ -1 +1 @@
 /*
- * Copyright 2010 Haiku Inc. All rights reserved.
+ * Copyright 2010-2016 Haiku Inc. All rights reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *      Christophe Huriaux, c.huriaux@gmail.com
+ *      Andrew Lindesay, apl@lindesay.co.nz
  */
 
 
@@ -17 +18 @@
 #include <MimeType.h>
 #include <Roster.h>
 
-#include <ICUWrapper.h>
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
+    #include <ICUWrapper.h>
+#endif
 #include <RegExp.h>
 
-#include <unicode/idna.h>
-#include <unicode/stringpiece.h>
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
+    #include <unicode/idna.h>
+    #include <unicode/stringpiece.h>
+#endif
 
 
 static const char* kArchivedUrl = "be:url string";
@@ -498 +503 @@
 bool
 BUrl::IsValid() const
 {
+    if (!fHasProtocol)
+        return false;
+
+    if (fProtocol == "http" || fProtocol == "https" || fProtocol == "ftp")
+        return fHasHost;
+
     // TODO: Implement for real!
-    return fHasProtocol && (fHasHost || fHasPath);
+    return fHasHost || fHasPath;
 }
 
 
@@ -598 +609 @@
 }
 
 
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
 status_t
 BUrl::IDNAToAscii()
 {
@@ -618 +630 @@
     fHost = result;
     return B_OK;
 }
+#endif
 
 
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
 status_t
 BUrl::IDNAToUnicode()
 {
@@ -640 +654 @@
     fHost = result;
     return B_OK;
 }
+#endif
 
 
 // #pragma mark - utility functionality
 
 
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
 bool
 BUrl::HasPreferredApplication() const
 {
@@ -657 +673 @@
 
     return false;
 }
+#endif
 
 
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
 BString
 BUrl::PreferredApplication() const
 {
@@ -669 +687 @@
 
     return BString(appSignature);
 }
+#endif
 
 
+#ifdef HAIKU_TARGET_PLATFORM_HAIKU
 status_t
 BUrl::OpenWithPreferredApplication(bool onProblemAskUser) const
 {
@@ -710 +730 @@
 
     return status;
 }
+#endif
 
 
 // #pragma mark Url encoding/decoding of string
@@ -866 +887 @@
 }
 
 
+bool
+BUrl::_ContainsDelimiter(const BString& url)
+{
+    int32 len = url.Length();
+
+    for (int32 i = 0; i < len; i++) {
+        switch (url[i]) {
+            case ' ':
+            case '\n':
+            case '\t':
+            case '\r':
+            case '<':
+            case '>':
+            case '"':
+                return true;
+        }
+    }
+
+    return false;
+}
+
+
 void
 BUrl::_ExplodeUrlString(const BString& url)
 {
@@ -875 +918 @@
 
     _ResetFields();
 
+    // RFC3986, Appendix C; the URL should not contain whitespace or delimiters
+    // by this point.
+    if (_ContainsDelimiter(url))
+        return; // TODO error handing
+
     RegExp::MatchResult match = urlMatcher.Match(url.String());
 
     if (!match.HasMatched())
@@ -883 +931 @@
     // Scheme/Protocol
     url.CopyInto(fProtocol, match.GroupStartOffsetAt(1),
         match.GroupEndOffsetAt(1) - match.GroupStartOffsetAt(1));
+
     if (!_IsProtocolValid()) {
         fHasProtocol = false;
         fProtocol.Truncate(0);
@@ -981 +1030 @@
         return;
 
     int32 userInfoEnd = fAuthority.FindFirst('@');
+    int16 hostAndPortStart = 0;
 
     // URL contains userinfo field
     if (userInfoEnd != -1) {
@@ -1000 +1050 @@
         } else {
             SetUserName(fUser);
         }
-    }
-
 
-    // Extract the host part
-    int16 hostEnd = fAuthority.FindFirst(':', userInfoEnd);
-    userInfoEnd++;
-
-    if (hostEnd < 0) {
-        // no ':' found, the host extends to the end of the URL
-        hostEnd = fAuthority.Length() + 1;
+        hostAndPortStart = userInfoEnd + 1;
     }
 
-    // The host is likely to be present if an authority is
-    // defined, but in some weird cases, it's not.
-    if (hostEnd != userInfoEnd) {
-        fAuthority.CopyInto(fHost, userInfoEnd, hostEnd - userInfoEnd);
-        SetHost(fHost);
-    }
+    int16 hostEnd = fAuthority.FindFirst(':', hostAndPortStart);
 
-    // Extract the port part
-    fPort = 0;
-    if (fAuthority.ByteAt(hostEnd) == ':') {
-        hostEnd++;
-        int16 portEnd = fAuthority.Length();
-
-        BString portString;
-        fAuthority.CopyInto(portString, hostEnd, portEnd - hostEnd);
-        fPort = atoi(portString.String());
-
-        //  Even if the port is invalid, the URL is considered to
-        // have a port.
-        fHasPort = portString.Length() > 0;
+    if (hostEnd != B_ERROR) {
+        if (hostEnd < fAuthority.Length()-1) {
+             fPort = atoi(&(fAuthority.String())[hostEnd+1]);
+             fHasPort = true;
+        }
     }
+    else
+        hostEnd = fAuthority.Length();
+
+    fAuthority.CopyInto(fHost, hostAndPortStart, hostEnd - hostAndPortStart);
+    SetHost(fHost);
 }
 
 
@@ -1088 +1122 @@
                 result << decoded;
             } else
                 result << chunk[i];
-        } 
+        }
     }
     return result;
 }

src/kits/package/Jamfile

@@ -129 +129 @@
             SolverResult.cpp
             :
             shared
+            bnetapi
             be
             [ BuildFeatureAttribute curl : library ]
             [ TargetLibstdc++ ]
+            $(TARGET_NETWORK_LIBS)
             ;
     }
 }

src/kits/package/PackageInfoParser.cpp

@@ -1 +1 @@
 /*
  * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
+ * Copyright 2016, Andrew Lindesay <apl@lindesay.co.nz>
  * Distributed under the terms of the MIT License.
  */
 
@@ -13 +14 @@
 #include <algorithm>
 #include <string>
 
+#include <Url.h>
 
 namespace BPackageKit {
 
@@ -508 +510 @@
 
 void
 BPackageInfo::Parser::_ParseStringList(BStringList* value,
-    bool requireResolvableName, bool convertToLowerCase)
+    bool requireResolvableName, bool convertToLowerCase,
+    StringValidator* stringValidator)
 {
     struct StringParser : public ListElementParser {
         BStringList* value;
         bool requireResolvableName;
         bool convertToLowerCase;
+        StringValidator* stringValidator;
 
         StringParser(BStringList* value, bool requireResolvableName,
-            bool convertToLowerCase)
+            bool convertToLowerCase, StringValidator* stringValidator)
             :
             value(value),
             requireResolvableName(requireResolvableName),
-            convertToLowerCase(convertToLowerCase)
+            convertToLowerCase(convertToLowerCase),
+            stringValidator(stringValidator)
         {
         }
 
@@ -541 +546 @@
             if (convertToLowerCase)
                 element.ToLower();
 
+            if (stringValidator != NULL)
+                stringValidator->Validate(element, token.pos);
+
             value->Add(element);
         }
-    } stringParser(value, requireResolvableName, convertToLowerCase);
+    } stringParser(value, requireResolvableName, convertToLowerCase,
+        stringValidator);
 
     _ParseList(stringParser, true);
 }
@@ -1008 +1017 @@
                 break;
 
             case B_PACKAGE_INFO_URLS:
-                _ParseStringList(&packageInfo->fURLList);
+            {
+                UrlStringValidator stringValidator;
+                _ParseStringList(&packageInfo->fURLList,
+                    false, false, &stringValidator);
+            }
                 break;
 
             case B_PACKAGE_INFO_SOURCE_URLS:
-                _ParseStringList(&packageInfo->fSourceURLList);
+            {
+                UrlStringValidator stringValidator;
+                _ParseStringList(&packageInfo->fSourceURLList,
+                    false, false, &stringValidator);
+            }
                 break;
 
             case B_PACKAGE_INFO_GLOBAL_WRITABLE_FILES:
@@ -1145 +1162 @@
     return true;
 }
 
+void
+BPackageInfo::Parser::UrlStringValidator::Validate(const BString& urlString,
+    const char* pos)
+{
+    BUrl url(urlString);
+
+    if (!url.IsValid())
+        throw ParseError("invalid url", pos);
+}
+
 
 } // namespace BPackageKit

src/kits/package/PackageInfoParser.h

@@ -1 +1 @@
 /*
  * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
+ * Copyright 2016, Andrew Lindesay <apl@lindesay.co.nz>
  * Distributed under the terms of the MIT License.
  */
 #ifndef PACKAGE_INFO_PARSER_H
@@ -31 +32 @@
                                     BPackageResolvableExpression& _expression);
 
 private:
+            struct UrlStringValidator;
+            struct StringValidator;
             struct ParseError;
             struct Token;
             struct ListElementParser;
@@ -74 +77 @@
                                     bool allowSingleNonListElement);
             void                _ParseStringList(BStringList* value,
                                     bool requireResolvableName = false,
-                                    bool convertToLowerCase = false);
+                                    bool convertToLowerCase = false,
+                                    StringValidator* stringValidator = NULL);
             void                _ParseResolvableList(
                                     BObjectList<BPackageResolvable>* value);
             void                _ParseResolvableExprList(
@@ -152 +156 @@
 };
 
 
+struct BPackageInfo::Parser::StringValidator {
+public:
+    virtual void Validate(const BString &string, const char *pos) = 0;
+};
+
+
+struct BPackageInfo::Parser::UrlStringValidator
+    : public BPackageInfo::Parser::StringValidator {
+public:
+    virtual void                Validate(const BString &string, const char* pos);
+};
+
+
 } // namespace BPackageKit
 
 

src/tests/kits/net/libnetapi/Jamfile

@@ -5 +5 @@
 
     NetworkAddressTest.cpp
     NetworkInterfaceTest.cpp
+    NetworkUrlTest.cpp
 
     : be bnetapi network [ TargetLibstdc++ ] [ TargetLibsupc++ ]
 ;

src/tests/kits/net/libnetapi/NetAPITestAddon.cpp

@@ -9 +9 @@
 
 #include "NetworkAddressTest.h"
 #include "NetworkInterfaceTest.h"
+#include "NetworkUrlTest.h"
 
 
 BTestSuite*
@@ -18 +19 @@
 
     NetworkAddressTest::AddTests(*suite);
     NetworkInterfaceTest::AddTests(*suite);
+    NetworkUrlTest::AddTests(*suite);
 
     return suite;
 }

new file src/tests/kits/net/libnetapi/NetworkUrlTest.cpp

@@ +1 @@
+/*
+ * Copyright 2016, Andrew Lindesay, apl@lindesay.co.nz.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include "NetworkUrlTest.h"
+
+#include <Url.h>
+
+#include <cppunit/TestCaller.h>
+#include <cppunit/TestSuite.h>
+
+
+NetworkUrlTest::NetworkUrlTest()
+{
+}
+
+
+NetworkUrlTest::~NetworkUrlTest()
+{
+}
+
+
+void
+NetworkUrlTest::setUp()
+{
+}
+
+
+void
+NetworkUrlTest::tearDown()
+{
+}
+
+
+// General Tests ---------------------------------------------------------------
+
+/*
+This is the "happy days" tests that checks that a URL featuring all of the
+parsed elements successfully processes and the elements are present.
+*/
+
+void NetworkUrlTest::TestValidFullUrl()
+{
+    BUrl url("http://ewe:pea@www.something.co.nz:8888/some/path?key1=value1#fragment");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "http");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(url.UserName() == "ewe");
+    CPPUNIT_ASSERT(url.HasUserName());
+    CPPUNIT_ASSERT(url.Password() == "pea");
+    CPPUNIT_ASSERT(url.HasPassword());
+    CPPUNIT_ASSERT(url.Host() == "www.something.co.nz");
+    CPPUNIT_ASSERT(url.HasHost());
+    CPPUNIT_ASSERT(url.Port() == 8888);
+    CPPUNIT_ASSERT(url.HasPort());
+    CPPUNIT_ASSERT(url.Path() == "/some/path");
+    CPPUNIT_ASSERT(url.HasPath());
+    CPPUNIT_ASSERT(url.Request() == "key1=value1");
+    CPPUNIT_ASSERT(url.HasRequest());
+    CPPUNIT_ASSERT(url.Fragment() == "fragment");
+    CPPUNIT_ASSERT(url.HasFragment());
+}
+
+
+void NetworkUrlTest::TestFileUrl()
+{
+    BUrl url("file:///northisland/wellington/brooklyn/windturbine");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "file");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(!url.HasUserName());
+    CPPUNIT_ASSERT(!url.HasPassword());
+    CPPUNIT_ASSERT(url.Host() == "");
+    CPPUNIT_ASSERT(url.HasHost());
+    CPPUNIT_ASSERT(!url.HasPort());
+    CPPUNIT_ASSERT(url.Path() == "/northisland/wellington/brooklyn/windturbine");
+    CPPUNIT_ASSERT(url.HasPath());
+    CPPUNIT_ASSERT(!url.HasRequest());
+    CPPUNIT_ASSERT(!url.HasFragment());
+}
+
+
+// Authority Tests (UserName, Password, Host, Port) ----------------------------
+
+
+void NetworkUrlTest::TestWithUserNameAndPasswordNoHostAndPort()
+{
+    BUrl url("wierd://tea:tree@/x");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "wierd");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(url.UserName() == "tea");
+    CPPUNIT_ASSERT(url.HasUserName());
+    CPPUNIT_ASSERT(url.Password() == "tree");
+    CPPUNIT_ASSERT(url.HasPassword());
+    CPPUNIT_ASSERT(url.Host() == "");
+    CPPUNIT_ASSERT(!url.HasHost());
+    CPPUNIT_ASSERT(!url.HasPort());
+    CPPUNIT_ASSERT(url.Path() == "/x");
+    CPPUNIT_ASSERT(url.HasPath());
+    CPPUNIT_ASSERT(!url.HasRequest());
+    CPPUNIT_ASSERT(!url.HasFragment());
+}
+
+
+void NetworkUrlTest::TestHostAndPortWithNoUserNameAndPassword()
+{
+    BUrl url("https://www.something.co.nz:443/z");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "https");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(!url.HasUserName());
+    CPPUNIT_ASSERT(!url.HasPassword());
+    CPPUNIT_ASSERT(url.Port() == 443);
+    CPPUNIT_ASSERT(url.HasPort());
+    CPPUNIT_ASSERT(url.Host() == "www.something.co.nz");
+    CPPUNIT_ASSERT(url.HasHost());
+    CPPUNIT_ASSERT(url.Path() == "/z");
+    CPPUNIT_ASSERT(url.HasPath());
+    CPPUNIT_ASSERT(!url.HasRequest());
+    CPPUNIT_ASSERT(!url.HasFragment());
+}
+
+
+void NetworkUrlTest::TestHostWithNoPortOrUserNameAndPassword()
+{
+    BUrl url("https://www.something.co.nz/z");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "https");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(!url.HasUserName());
+    CPPUNIT_ASSERT(!url.HasPassword());
+    CPPUNIT_ASSERT(url.Host() == "www.something.co.nz");
+    CPPUNIT_ASSERT(url.HasHost());
+    CPPUNIT_ASSERT(!url.HasPort());
+    CPPUNIT_ASSERT(url.Path() == "/z");
+    CPPUNIT_ASSERT(url.HasPath());
+    CPPUNIT_ASSERT(!url.HasRequest());
+    CPPUNIT_ASSERT(!url.HasFragment());
+}
+
+
+void NetworkUrlTest::TestHostWithNoPortNoPath()
+{
+    BUrl url("https://www.something.co.nz");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "https");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(!url.HasUserName());
+    CPPUNIT_ASSERT(!url.HasPassword());
+    CPPUNIT_ASSERT(url.Host() == "www.something.co.nz");
+    CPPUNIT_ASSERT(url.HasHost());
+    CPPUNIT_ASSERT(!url.HasPort());
+    CPPUNIT_ASSERT(!url.HasPath());
+    CPPUNIT_ASSERT(!url.HasRequest());
+    CPPUNIT_ASSERT(!url.HasFragment());
+}
+
+
+void NetworkUrlTest::TestHostWithPortNoPath()
+{
+    BUrl url("https://www.something.co.nz:1234");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "https");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(!url.HasUserName());
+    CPPUNIT_ASSERT(!url.HasPassword());
+    CPPUNIT_ASSERT(url.Host() == "www.something.co.nz");
+    CPPUNIT_ASSERT(url.HasHost());
+    CPPUNIT_ASSERT(url.Port() == 1234);
+    CPPUNIT_ASSERT(url.HasPort());
+    CPPUNIT_ASSERT(!url.HasPath());
+    CPPUNIT_ASSERT(!url.HasRequest());
+    CPPUNIT_ASSERT(!url.HasFragment());
+}
+
+
+void NetworkUrlTest::TestHostWithEmptyPort()
+{
+    BUrl url("https://www.something.co.nz:");
+    CPPUNIT_ASSERT(url.IsValid());
+    CPPUNIT_ASSERT(url.Protocol() == "https");
+    CPPUNIT_ASSERT(url.HasProtocol());
+    CPPUNIT_ASSERT(!url.HasUserName());
+    CPPUNIT_ASSERT(!url.HasPassword());
+    CPPUNIT_ASSERT(url.Host() == "www.something.co.nz");
+    CPPUNIT_ASSERT(url.HasHost());
+    CPPUNIT_ASSERT(!url.HasPort());
+    CPPUNIT_ASSERT(!url.HasPath());
+    CPPUNIT_ASSERT(!url.HasRequest());
+    CPPUNIT_ASSERT(!url.HasFragment());
+}
+
+
+// Invalid Forms ---------------------------------------------------------------
+
+
+void NetworkUrlTest::TestWhitespaceBefore()
+{
+    BUrl url("   https://www.something.co.nz/z");
+    CPPUNIT_ASSERT(!url.IsValid());
+}
+
+
+void NetworkUrlTest::TestWhitespaceAfter()
+{
+    BUrl url("https://www.something.co.nz/z\t\t ");
+    CPPUNIT_ASSERT(!url.IsValid());
+}
+
+
+void NetworkUrlTest::TestWhitespaceMiddle()
+{
+    BUrl url("https://www.  something.co.nz/z");
+    CPPUNIT_ASSERT(!url.IsValid());
+}
+
+
+void NetworkUrlTest::TestHttpNoHost()
+{
+    BUrl url("https:///z");
+    CPPUNIT_ASSERT(!url.IsValid());
+}
+
+
+// Control ---------------------------------------------------------------------
+
+
+/*static*/ void
+NetworkUrlTest::AddTests(BTestSuite& parent)
+{
+    CppUnit::TestSuite& suite = *new CppUnit::TestSuite("NetworkUrlTest");
+
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestHostAndPortWithNoUserNameAndPassword",
+        &NetworkUrlTest::TestHostAndPortWithNoUserNameAndPassword));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestWithUserNameAndPasswordNoHostAndPort",
+        &NetworkUrlTest::TestWithUserNameAndPasswordNoHostAndPort));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestHostWithNoPortOrUserNameAndPassword",
+        &NetworkUrlTest::TestHostWithNoPortOrUserNameAndPassword));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestHostWithNoPortNoPath",
+        &NetworkUrlTest::TestHostWithNoPortNoPath));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestHostWithPortNoPath",
+        &NetworkUrlTest::TestHostWithPortNoPath));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestHostWithEmptyPort",
+        &NetworkUrlTest::TestHostWithEmptyPort));
+
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestWhitespaceBefore",
+        &NetworkUrlTest::TestWhitespaceBefore));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestWhitespaceAfter",
+        &NetworkUrlTest::TestWhitespaceAfter));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestWhitespaceMiddle",
+        &NetworkUrlTest::TestWhitespaceMiddle));
+
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestFileUrl",
+        &NetworkUrlTest::TestFileUrl));
+    suite.addTest(new CppUnit::TestCaller<NetworkUrlTest>(
+        "NetworkUrlTest::TestValidFullUrl", &NetworkUrlTest::TestValidFullUrl));
+
+    parent.addTest("NetworkUrlTest", &suite);
+}

new file src/tests/kits/net/libnetapi/NetworkUrlTest.h

@@ +1 @@
+/*
+ * Copyright 2016, Andrew Lindesay, apl@lindesay.co.nz
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef NETWORK_URL_TEST_H
+#define NETWORK_URL_TEST_H
+
+
+#include <TestCase.h>
+#include <TestSuite.h>
+
+
+class NetworkUrlTest : public CppUnit::TestCase {
+public:
+                                NetworkUrlTest();
+    virtual                     ~NetworkUrlTest();
+
+    virtual void                setUp();
+    virtual void                tearDown();
+
+            void                TestValidFullUrl();
+
+            void                TestFileUrl();
+
+            void                TestWithUserNameAndPasswordNoHostAndPort();
+            void                TestHostAndPortWithNoUserNameAndPassword();
+            void                TestHostWithNoPortOrUserNameAndPassword();
+            void                TestHostWithNoPortNoPath();
+            void                TestHostWithPortNoPath();
+            void                TestHostWithEmptyPort();
+
+            void                TestWhitespaceBefore();
+            void                TestWhitespaceAfter();
+            void                TestWhitespaceMiddle();
+            void                TestHttpNoHost();
+
+    static  void                AddTests(BTestSuite& suite);
+
+};
+
+
+#endif  // NETWORK_URL_TEST_H