Btukfyl

Terribly sorry, couldn't help it. :s

url.hh

#ifndef URL_HH_

#define URL_HH_    

#include <string>

struct url {

    url(const std::string& url_s); // omitted copy, ==, accessors, ...

private:

    void parse(const std::string& url_s);

private:

    std::string protocol_, host_, path_, query_;

};

#endif /* URL_HH_ */

url.cc

#include "url.hh"

#include <string>

#include <algorithm>

#include <cctype>

#include <functional>

using namespace std;



// ctors, copy, equality, ...



void url::parse(const string& url_s)

{

    const string prot_end("://");

    string::const_iterator prot_i = search(url_s.begin(), url_s.end(),

                                           prot_end.begin(), prot_end.end());

    protocol_.reserve(distance(url_s.begin(), prot_i));

    transform(url_s.begin(), prot_i,

              back_inserter(protocol_),

              ptr_fun<int,int>(tolower)); // protocol is icase

    if( prot_i == url_s.end() )

        return;

    advance(prot_i, prot_end.length());

    string::const_iterator path_i = find(prot_i, url_s.end(), '/');

    host_.reserve(distance(prot_i, path_i));

    transform(prot_i, path_i,

              back_inserter(host_),

              ptr_fun<int,int>(tolower)); // host is icase

    string::const_iterator query_i = find(path_i, url_s.end(), '?');

    path_.assign(path_i, query_i);

    if( query_i != url_s.end() )

        ++query_i;

    query_.assign(query_i, url_s.end());

}

main.cc

// ...

    url u("HTTP://stackoverflow.com/questions/2616011/parse-a.py?url=1");

    cout << u.protocol() << 't' << u.host() << ...

Wstring version of above, added other fields I needed. Could definitely be refined, but good enough for my purposes.

#include <string>

#include <algorithm>    // find



struct Uri

{

public:

std::wstring QueryString, Path, Protocol, Host, Port;



static Uri Parse(const std::wstring &uri)

{

    Uri result;



    typedef std::wstring::const_iterator iterator_t;



    if (uri.length() == 0)

        return result;



    iterator_t uriEnd = uri.end();



    // get query start

    iterator_t queryStart = std::find(uri.begin(), uriEnd, L'?');



    // protocol

    iterator_t protocolStart = uri.begin();

    iterator_t protocolEnd = std::find(protocolStart, uriEnd, L':');            //"://");



    if (protocolEnd != uriEnd)

    {

        std::wstring prot = &*(protocolEnd);

        if ((prot.length() > 3) && (prot.substr(0, 3) == L"://"))

        {

            result.Protocol = std::wstring(protocolStart, protocolEnd);

            protocolEnd += 3;   //      ://

        }

        else

            protocolEnd = uri.begin();  // no protocol

    }

    else

        protocolEnd = uri.begin();  // no protocol



    // host

    iterator_t hostStart = protocolEnd;

    iterator_t pathStart = std::find(hostStart, uriEnd, L'/');  // get pathStart



    iterator_t hostEnd = std::find(protocolEnd, 

        (pathStart != uriEnd) ? pathStart : queryStart,

        L':');  // check for port



    result.Host = std::wstring(hostStart, hostEnd);



    // port

    if ((hostEnd != uriEnd) && ((&*(hostEnd))[0] == L':'))  // we have a port

    {

        hostEnd++;

        iterator_t portEnd = (pathStart != uriEnd) ? pathStart : queryStart;

        result.Port = std::wstring(hostEnd, portEnd);

    }



    // path

    if (pathStart != uriEnd)

        result.Path = std::wstring(pathStart, queryStart);



    // query

    if (queryStart != uriEnd)

        result.QueryString = std::wstring(queryStart, uri.end());



    return result;



}   // Parse

};  // uri

Tests/Usage

Uri u0 = Uri::Parse(L"http://localhost:80/foo.html?&q=1:2:3");

Uri u1 = Uri::Parse(L"https://localhost:80/foo.html?&q=1");

Uri u2 = Uri::Parse(L"localhost/foo");

Uri u3 = Uri::Parse(L"https://localhost/foo");

Uri u4 = Uri::Parse(L"localhost:8080");

Uri u5 = Uri::Parse(L"localhost?&foo=1");

Uri u6 = Uri::Parse(L"localhost?&foo=1:2:3");



u0.QueryString, u0.Path, u0.Protocol, u0.Host, u0.Port....

For completeness, there is one written in C that you could use (with a little wrapping, no doubt): http://uriparser.sourceforge.net/

[RFC-compliant and supports Unicode]

Here's a very basic wrapper I've been using for simply grabbing the results of a parse.

#include <string>

#include <uriparser/Uri.h>





namespace uriparser

{

    class Uri //: boost::noncopyable

    {

        public:

            Uri(std::string uri)

                : uri_(uri)

            {

                UriParserStateA state_;

                state_.uri = &uriParse_;

                isValid_   = uriParseUriA(&state_, uri_.c_str()) == URI_SUCCESS;

            }



            ~Uri() { uriFreeUriMembersA(&uriParse_); }



            bool isValid() const { return isValid_; }



            std::string scheme()   const { return fromRange(uriParse_.scheme); }

            std::string host()     const { return fromRange(uriParse_.hostText); }

            std::string port()     const { return fromRange(uriParse_.portText); }

            std::string path()     const { return fromList(uriParse_.pathHead, "/"); }

            std::string query()    const { return fromRange(uriParse_.query); }

            std::string fragment() const { return fromRange(uriParse_.fragment); }



        private:

            std::string uri_;

            UriUriA     uriParse_;

            bool        isValid_;



            std::string fromRange(const UriTextRangeA & rng) const

            {

                return std::string(rng.first, rng.afterLast);

            }



            std::string fromList(UriPathSegmentA * xs, const std::string & delim) const

            {

                UriPathSegmentStructA * head(xs);

                std::string accum;



                while (head)

                {

                    accum += delim + fromRange(head->text);

                    head = head->next;

                }



                return accum;

            }

    };

}

POCO's URI class can parse URLs for you. The following example is shortened version of the one in POCO URI and UUID slides:

#include "Poco/URI.h"

#include <iostream>



int main(int argc, char** argv)

{

    Poco::URI uri1("http://www.appinf.com:88/sample?example-query#frag");



    std::string scheme(uri1.getScheme()); // "http"

    std::string auth(uri1.getAuthority()); // "www.appinf.com:88"

    std::string host(uri1.getHost()); // "www.appinf.com"

    unsigned short port = uri1.getPort(); // 88

    std::string path(uri1.getPath()); // "/sample"

    std::string query(uri1.getQuery()); // "example-query"

    std::string frag(uri1.getFragment()); // "frag"

    std::string pathEtc(uri1.getPathEtc()); // "/sample?example-query#frag"



    return 0;

}

The Poco library now has a class for dissecting URI's and feeding back the host, path segments and query string etc.

https://pocoproject.org/pro/docs/Poco.URI.html

//sudo apt-get install libboost-all-dev; #install boost

//g++ urlregex.cpp -lboost_regex; #compile

#include <string>

#include <iostream>

#include <boost/regex.hpp>



using namespace std;



int main(int argc, char* argv)

{

    string url="https://www.google.com:443/webhp?gws_rd=ssl#q=cpp";

    boost::regex ex("(http|https)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\x3f?([^ #]*)#?([^ ]*)");

    boost::cmatch what;

    if(regex_match(url.c_str(), what, ex)) 

    {

        cout << "protocol: " << string(what[1].first, what[1].second) << endl;

        cout << "domain:   " << string(what[2].first, what[2].second) << endl;

        cout << "port:     " << string(what[3].first, what[3].second) << endl;

        cout << "path:     " << string(what[4].first, what[4].second) << endl;

        cout << "query:    " << string(what[5].first, what[5].second) << endl;

        cout << "fragment: " << string(what[6].first, what[6].second) << endl;

    }

    return 0;

}

Facebook's Folly library can do the job for you easily. Simply use the Uri class:

#include <folly/Uri.h>



int main() {

    folly::Uri folly("https://code.facebook.com/posts/177011135812493/");



    folly.scheme(); // https

    folly.host();   // code.facebook.com

    folly.path();   // posts/177011135812493/

}

Also of interest could be http://code.google.com/p/uri-grammar/ which like Dean Michael's netlib uses boost spirit to parse a URI. Came across it at Simple expression parser example using Boost::Spirit?

QT has QUrl for this. GNOME has SoupURI in libsoup, which you'll probably find a little more light-weight.

There is the newly released google-url lib:

http://code.google.com/p/google-url/

The library provides a low-level url parsing API as well as a higher-level abstraction called GURL. Here's an example using that:

#include <googleurlsrcgurl.h>



wchar_t url = L"http://www.facebook.com";

GURL parsedUrl (url);

assert(parsedUrl.DomainIs("facebook.com"));

Two small complaints I have with it: (1) it wants to use ICU by default to deal with different string encodings and (2) it makes some assumptions about logging (but I think they can be disabled). In other words, the library is not completely stand-alone as it exists, but I think it's still a good basis to start with, especially if you are already using ICU.

This library is very tiny and lightweight: https://github.com/corporateshark/LUrlParser

However, it is parsing only, no URL normalization/validation.

You could try the open-source library called C++ REST SDK (created by Microsoft, distributed under the Apache License 2.0). It can be built for several platforms including Windows, Linux, OSX, iOS, Android). There is a class called web::uri where you put in a string and can retrieve individual URL components. Here is a code sample (tested on Windows):

#include <cpprest/base_uri.h>

#include <iostream>

#include <ostream>



web::uri sample_uri( L"http://dummyuser@localhost:7777/dummypath?dummyquery#dummyfragment" );

std::wcout << L"scheme: "   << sample_uri.scheme()     << std::endl;

std::wcout << L"user: "     << sample_uri.user_info()  << std::endl;

std::wcout << L"host: "     << sample_uri.host()       << std::endl;

std::wcout << L"port: "     << sample_uri.port()       << std::endl;

std::wcout << L"path: "     << sample_uri.path()       << std::endl;

std::wcout << L"query: "    << sample_uri.query()      << std::endl;

std::wcout << L"fragment: " << sample_uri.fragment()   << std::endl;

The output will be:

scheme: http

user: dummyuser

host: localhost

port: 7777

path: /dummypath

query: dummyquery

fragment: dummyfragment

There are also other easy-to-use methods, e.g. to access individual attribute/value pairs from the query, split the path into components, etc.

May I offer another self-contained solution based on std::regex :

const char* SCHEME_REGEX   = "((http[s]?)://)?";  // match http or https before the ://

const char* USER_REGEX     = "(([^@/:\s]+)@)?";  // match anything other than @ / : or whitespace before the ending @

const char* HOST_REGEX     = "([^@/:\s]+)";      // mandatory. match anything other than @ / : or whitespace

const char* PORT_REGEX     = "(:([0-9]{1,5}))?";  // after the : match 1 to 5 digits

const char* PATH_REGEX     = "(/[^:#?\s]*)?";    // after the / match anything other than : # ? or whitespace

const char* QUERY_REGEX    = "(\?(([^?;&#=]+=[^?;&#=]+)([;|&]([^?;&#=]+=[^?;&#=]+))*))?"; // after the ? match any number of x=y pairs, seperated by & or ;

const char* FRAGMENT_REGEX = "(#([^#\s]*))?";    // after the # match anything other than # or whitespace



bool parseUri(const std::string &i_uri)

{

    static const std::regex regExpr(std::string("^")

        + SCHEME_REGEX + USER_REGEX

        + HOST_REGEX + PORT_REGEX

        + PATH_REGEX + QUERY_REGEX

        + FRAGMENT_REGEX + "$");



    std::smatch matchResults;

    if (std::regex_match(i_uri.cbegin(), i_uri.cend(), matchResults, regExpr))

    {

        m_scheme.assign(matchResults[2].first, matchResults[2].second);

        m_user.assign(matchResults[4].first, matchResults[4].second);

        m_host.assign(matchResults[5].first, matchResults[5].second);

        m_port.assign(matchResults[7].first, matchResults[7].second);

        m_path.assign(matchResults[8].first, matchResults[8].second);

        m_query.assign(matchResults[10].first, matchResults[10].second);

        m_fragment.assign(matchResults[15].first, matchResults[15].second);



        return true;

    }



    return false;

}

I added explanations for each part of the regular expression. This way allows you to choose exactly the relevant parts to parse for the URL that you're expecting to get. Just remember to change the desired regular expression group indices accordingly.

There is yet another library https://snapwebsites.org/project/libtld which handles all possible top level domains and URI shema

I have developed an "object oriented" solution, one C++ class, that works with one regex like @Mr.Jones and @velcrow solutions. My Url class performs url/uri 'parsing'.

I think I improved velcrow regex to be more robust and includes also the username part.

Follows the first version of my idea, I have released the same code, improved, in my GPL3 licensed open source project Cpp URL Parser.

Omitted #ifdef/ndef bloat part, follows Url.h

#include <string>

#include <iostream>

#include <boost/regex.hpp>



using namespace std;



class Url {

public:

    boost::regex ex;

    string rawUrl;



    string username;

    string protocol;

    string domain;

    string port;

    string path;

    string query;

    string fragment;



    Url();



    Url(string &rawUrl);



    Url &update(string &rawUrl);

};

This is the code of the Url.cpp implementation file:

#include "Url.h"



Url::Url() {

    this -> ex = boost::regex("(ssh|sftp|ftp|smb|http|https):\/\/(?:([^@ ]*)@)?([^:?# ]+)(?::(\d+))?([^?# ]*)(?:\?([^# ]*))?(?:#([^ ]*))?");

}



Url::Url(string &rawUrl) : Url() {

    this->rawUrl = rawUrl;

    this->update(this->rawUrl);

}



Url &Url::update(string &rawUrl) {

    this->rawUrl = rawUrl;

    boost::cmatch what;

    if (regex_match(rawUrl.c_str(), what, ex)) {

        this -> protocol = string(what[1].first, what[1].second);

        this -> username = string(what[2].first, what[2].second);

        this -> domain = string(what[3].first, what[3].second);

        this -> port = string(what[4].first, what[4].second);

        this -> path = string(what[5].first, what[5].second);

        this -> query = string(what[6].first, what[6].second);

        this -> fragment = string(what[7].first, what[7].second);

    }

    return *this;

}

Usage example:

string urlString = "http://gino@ciao.it:67/ciao?roba=ciao#34";

Url *url = new Url(urlString);

std::cout << " username: " << url->username << " URL domain: " << url->domain;

std::cout << " port: " << url->port << " protocol: " << url->protocol;

You can also update the Url object to represent (and parse) another URL:

url.update("http://gino@nuovociao.it:68/nuovociao?roba=ciaoooo#")

I'm learning C++ just now, so, I'm not sure I followed 100% C++ best-practises.
Any tip is appreciated.

P.s: let's look at Cpp URL Parser, there are refinements there.

Have fun

A small dependency you can use is uriparser, which recently moved to GitHub.

You can find a minimal example in their code: https://github.com/uriparser/uriparser/blob/63384be4fb8197264c55ff53a135110ecd5bd8c4/tool/uriparse.c

This will be more lightweight than Boost or Poco. The only catch is that it is C.

There is also a Buckaroo package:

buckaroo add github.com/buckaroo-pm/uriparser