|
|
@@ -0,0 +1,1166 @@
|
|
|
+module http.HttpURI;
|
|
|
+
|
|
|
+import hunt.collection.MultiMap;
|
|
|
+
|
|
|
+import hunt.Exceptions;
|
|
|
+import hunt.text.Charset;
|
|
|
+import hunt.text.Common;
|
|
|
+import hunt.text.StringBuilder;
|
|
|
+import hunt.util.TypeUtils;
|
|
|
+import http.UrlEncoded;
|
|
|
+
|
|
|
+import std.array;
|
|
|
+import std.conv;
|
|
|
+import std.string;
|
|
|
+
|
|
|
+import hunt.logging;
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ * Http URI. Parse a HTTP URI from a string or byte array. Given a URI
|
|
|
+ * <code>http://user@host:port/path/info;param?query#fragment</code> this class
|
|
|
+ * will split it into the following undecoded optional elements:
|
|
|
+ * <ul>
|
|
|
+ * <li>{@link #getScheme()} - http:</li>
|
|
|
+ * <li>{@link #getAuthority()} - //name@host:port</li>
|
|
|
+ * <li>{@link #getHost()} - host</li>
|
|
|
+ * <li>{@link #getPort()} - port</li>
|
|
|
+ * <li>{@link #getPath()} - /path/info</li>
|
|
|
+ * <li>{@link #getParam()} - param</li>
|
|
|
+ * <li>{@link #getQuery()} - query</li>
|
|
|
+ * <li>{@link #getFragment()} - fragment</li>
|
|
|
+ * </ul>
|
|
|
+ *
|
|
|
+ https://bob:[email protected]:8080/file;p=1?q=2#third
|
|
|
+ \___/ \_/ \___/ \______________/ \__/\_______/ \_/ \___/
|
|
|
+ | | | | | | \_/ | |
|
|
|
+ Scheme User Password Host Port Path | | Fragment
|
|
|
+ \_____________________________/ | Query
|
|
|
+ | Path parameter
|
|
|
+ Authority
|
|
|
+ * <p>
|
|
|
+ * Any parameters will be returned from {@link #getPath()}, but are excluded
|
|
|
+ * from the return value of {@link #getDecodedPath()}. If there are multiple
|
|
|
+ * parameters, the {@link #getParam()} method returns only the last one.
|
|
|
+ *
|
|
|
+ * See_Also:
|
|
|
+ * https://stackoverflow.com/questions/1634271/url-encoding-the-space-character-or-20
|
|
|
+ * https://web.archive.org/web/20151218094722/http://blog.lunatech.com/2009/02/03/what-every-web-developer-must-know-about-url-encoding
|
|
|
+ */
|
|
|
+class HttpURI {
|
|
|
+ private enum State {
|
|
|
+ START, HOST_OR_PATH, SCHEME_OR_PATH, HOST, IPV6, PORT, PATH, PARAM, QUERY, FRAGMENT, ASTERISK
|
|
|
+ }
|
|
|
+
|
|
|
+ private string _scheme;
|
|
|
+ private string _user;
|
|
|
+ private string _host;
|
|
|
+ private int _port;
|
|
|
+ private string _path;
|
|
|
+ private string _param;
|
|
|
+ private string _query;
|
|
|
+ private string _fragment;
|
|
|
+
|
|
|
+ string _uri;
|
|
|
+ string _decodedPath;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Construct a normalized URI. Port is not set if it is the default port.
|
|
|
+ *
|
|
|
+ * @param scheme
|
|
|
+ * the URI scheme
|
|
|
+ * @param host
|
|
|
+ * the URI hose
|
|
|
+ * @param port
|
|
|
+ * the URI port
|
|
|
+ * @param path
|
|
|
+ * the URI path
|
|
|
+ * @param param
|
|
|
+ * the URI param
|
|
|
+ * @param query
|
|
|
+ * the URI query
|
|
|
+ * @param fragment
|
|
|
+ * the URI fragment
|
|
|
+ * @return the normalized URI
|
|
|
+ */
|
|
|
+ static HttpURI createHttpURI(string scheme, string host, int port, string path, string param, string query,
|
|
|
+ string fragment) {
|
|
|
+ if (port == 80 && (scheme == "http"))
|
|
|
+ port = 0;
|
|
|
+ if (port == 443 && (scheme == "https"))
|
|
|
+ port = 0;
|
|
|
+ return new HttpURI(scheme, host, port, path, param, query, fragment);
|
|
|
+ }
|
|
|
+
|
|
|
+ this() {
|
|
|
+ }
|
|
|
+
|
|
|
+ this(string scheme, string host, int port, string path, string param, string query, string fragment) {
|
|
|
+ _scheme = scheme;
|
|
|
+ _host = host;
|
|
|
+ _port = port;
|
|
|
+ _path = path;
|
|
|
+ _param = param;
|
|
|
+ _query = query;
|
|
|
+ _fragment = fragment;
|
|
|
+ }
|
|
|
+
|
|
|
+ this(HttpURI uri) {
|
|
|
+ this(uri._scheme, uri._host, uri._port, uri._path, uri._param, uri._query, uri._fragment);
|
|
|
+ _uri = uri._uri;
|
|
|
+ }
|
|
|
+
|
|
|
+ this(string uri) {
|
|
|
+ _port = -1;
|
|
|
+ parse(State.START, uri);
|
|
|
+ }
|
|
|
+
|
|
|
+ // this(URI uri) {
|
|
|
+ // _uri = null;
|
|
|
+
|
|
|
+ // _scheme = uri.getScheme();
|
|
|
+ // _host = uri.getHost();
|
|
|
+ // if (_host == null && uri.getRawSchemeSpecificPart().startsWith("//"))
|
|
|
+ // _host = "";
|
|
|
+ // _port = uri.getPort();
|
|
|
+ // _user = uri.getUserInfo();
|
|
|
+ // _path = uri.getRawPath();
|
|
|
+
|
|
|
+ // _decodedPath = uri.getPath();
|
|
|
+ // if (_decodedPath != null) {
|
|
|
+ // int p = _decodedPath.lastIndexOf(';');
|
|
|
+ // if (p >= 0)
|
|
|
+ // _param = _decodedPath.substring(p + 1);
|
|
|
+ // }
|
|
|
+ // _query = uri.getRawQuery();
|
|
|
+ // _fragment = uri.getFragment();
|
|
|
+
|
|
|
+ // _decodedPath = null;
|
|
|
+ // }
|
|
|
+
|
|
|
+ this(string scheme, string host, int port, string pathQuery) {
|
|
|
+ _uri = null;
|
|
|
+
|
|
|
+ _scheme = scheme;
|
|
|
+ _host = host;
|
|
|
+ _port = port;
|
|
|
+
|
|
|
+ parse(State.PATH, pathQuery);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ void parse(string uri) {
|
|
|
+ clear();
|
|
|
+ _uri = uri;
|
|
|
+ parse(State.START, uri);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Parse according to https://tools.ietf.org/html/rfc7230#section-5.3
|
|
|
+ *
|
|
|
+ * @param method
|
|
|
+ * the request method
|
|
|
+ * @param uri
|
|
|
+ * the request uri
|
|
|
+ */
|
|
|
+ void parseRequestTarget(string method, string uri) {
|
|
|
+ clear();
|
|
|
+ _uri = uri;
|
|
|
+
|
|
|
+ if (method == "CONNECT")
|
|
|
+ _path = uri;
|
|
|
+ else
|
|
|
+ parse(uri.startsWith("/") ? State.PATH : State.START, uri);
|
|
|
+ }
|
|
|
+
|
|
|
+ // deprecated("")
|
|
|
+ // void parseConnect(string uri) {
|
|
|
+ // clear();
|
|
|
+ // _uri = uri;
|
|
|
+ // _path = uri;
|
|
|
+ // }
|
|
|
+
|
|
|
+ void parse(string uri, int offset, int length) {
|
|
|
+ clear();
|
|
|
+ int end = offset + length;
|
|
|
+ _uri = uri.substring(offset, end);
|
|
|
+ parse(State.START, uri);
|
|
|
+ }
|
|
|
+
|
|
|
+ private void parse(State state, string uri) {
|
|
|
+ bool encoded = false;
|
|
|
+ int end = cast(int)uri.length;
|
|
|
+ int mark = 0;
|
|
|
+ int path_mark = 0;
|
|
|
+ char last = '/';
|
|
|
+ for (int i = 0; i < end; i++) {
|
|
|
+ char c = uri[i];
|
|
|
+
|
|
|
+ final switch (state) {
|
|
|
+ case State.START: {
|
|
|
+ switch (c) {
|
|
|
+ case '/':
|
|
|
+ mark = i;
|
|
|
+ state = State.HOST_OR_PATH;
|
|
|
+ break;
|
|
|
+ case ';':
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.PARAM;
|
|
|
+ break;
|
|
|
+ case '?':
|
|
|
+ // assume empty path (if seen at start)
|
|
|
+ _path = "";
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.QUERY;
|
|
|
+ break;
|
|
|
+ case '#':
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.FRAGMENT;
|
|
|
+ break;
|
|
|
+ case '*':
|
|
|
+ _path = "*";
|
|
|
+ state = State.ASTERISK;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '.':
|
|
|
+ path_mark = i;
|
|
|
+ state = State.PATH;
|
|
|
+ encoded = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ mark = i;
|
|
|
+ if (_scheme == null)
|
|
|
+ state = State.SCHEME_OR_PATH;
|
|
|
+ else {
|
|
|
+ path_mark = i;
|
|
|
+ state = State.PATH;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.SCHEME_OR_PATH: {
|
|
|
+ switch (c) {
|
|
|
+ case ':':
|
|
|
+ // must have been a scheme
|
|
|
+ _scheme = uri.substring(mark, i);
|
|
|
+ // Start again with scheme set
|
|
|
+ state = State.START;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '/':
|
|
|
+ // must have been in a path and still are
|
|
|
+ state = State.PATH;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ';':
|
|
|
+ // must have been in a path
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.PARAM;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '?':
|
|
|
+ // must have been in a path
|
|
|
+ _path = uri.substring(mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.QUERY;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '%':
|
|
|
+ // must have be in an encoded path
|
|
|
+ encoded = true;
|
|
|
+ state = State.PATH;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '#':
|
|
|
+ // must have been in a path
|
|
|
+ _path = uri.substring(mark, i);
|
|
|
+ state = State.FRAGMENT;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.HOST_OR_PATH: {
|
|
|
+ switch (c) {
|
|
|
+ case '/':
|
|
|
+ _host = "";
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.HOST;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '@':
|
|
|
+ case ';':
|
|
|
+ case '?':
|
|
|
+ case '#':
|
|
|
+ // was a path, look again
|
|
|
+ i--;
|
|
|
+ path_mark = mark;
|
|
|
+ state = State.PATH;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '.':
|
|
|
+ // it is a path
|
|
|
+ encoded = true;
|
|
|
+ path_mark = mark;
|
|
|
+ state = State.PATH;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ // it is a path
|
|
|
+ path_mark = mark;
|
|
|
+ state = State.PATH;
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.HOST: {
|
|
|
+ switch (c) {
|
|
|
+ case '/':
|
|
|
+ _host = uri.substring(mark, i);
|
|
|
+ path_mark = mark = i;
|
|
|
+ state = State.PATH;
|
|
|
+ break;
|
|
|
+ case ':':
|
|
|
+ if (i > mark)
|
|
|
+ _host = uri.substring(mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.PORT;
|
|
|
+ break;
|
|
|
+ case '@':
|
|
|
+ if (_user != null)
|
|
|
+ throw new IllegalArgumentException("Bad authority");
|
|
|
+ _user = uri.substring(mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '[':
|
|
|
+ state = State.IPV6;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.IPV6: {
|
|
|
+ switch (c) {
|
|
|
+ case '/':
|
|
|
+ throw new IllegalArgumentException("No closing ']' for ipv6 in " ~ uri);
|
|
|
+ case ']':
|
|
|
+ c = uri.charAt(++i);
|
|
|
+ _host = uri.substring(mark, i);
|
|
|
+ if (c == ':') {
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.PORT;
|
|
|
+ } else {
|
|
|
+ path_mark = mark = i;
|
|
|
+ state = State.PATH;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.PORT: {
|
|
|
+ if (c == '@') {
|
|
|
+ if (_user != null)
|
|
|
+ throw new IllegalArgumentException("Bad authority");
|
|
|
+ // It wasn't a port, but a password!
|
|
|
+ _user = _host ~ ":" ~ uri.substring(mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.HOST;
|
|
|
+ } else if (c == '/') {
|
|
|
+ // _port = TypeUtils.parseInt(uri, mark, i - mark, 10);
|
|
|
+ _port = to!int(uri[mark .. i], 10);
|
|
|
+ path_mark = mark = i;
|
|
|
+ state = State.PATH;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.PATH: {
|
|
|
+ switch (c) {
|
|
|
+ case ';':
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.PARAM;
|
|
|
+ break;
|
|
|
+ case '?':
|
|
|
+ _path = uri.substring(path_mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.QUERY;
|
|
|
+ break;
|
|
|
+ case '#':
|
|
|
+ _path = uri.substring(path_mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.FRAGMENT;
|
|
|
+ break;
|
|
|
+ case '%':
|
|
|
+ encoded = true;
|
|
|
+ break;
|
|
|
+ case '.':
|
|
|
+ if ('/' == last)
|
|
|
+ encoded = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.PARAM: {
|
|
|
+ switch (c) {
|
|
|
+ case '?':
|
|
|
+ _path = uri.substring(path_mark, i);
|
|
|
+ _param = uri.substring(mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.QUERY;
|
|
|
+ break;
|
|
|
+ case '#':
|
|
|
+ _path = uri.substring(path_mark, i);
|
|
|
+ _param = uri.substring(mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.FRAGMENT;
|
|
|
+ break;
|
|
|
+ case '/':
|
|
|
+ encoded = true;
|
|
|
+ // ignore internal params
|
|
|
+ state = State.PATH;
|
|
|
+ break;
|
|
|
+ case ';':
|
|
|
+ // multiple parameters
|
|
|
+ mark = i + 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.QUERY: {
|
|
|
+ if (c == '#') {
|
|
|
+ _query = uri.substring(mark, i);
|
|
|
+ mark = i + 1;
|
|
|
+ state = State.FRAGMENT;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.ASTERISK: {
|
|
|
+ throw new IllegalArgumentException("Bad character '*'");
|
|
|
+ }
|
|
|
+
|
|
|
+ case State.FRAGMENT: {
|
|
|
+ _fragment = uri.substring(mark, end);
|
|
|
+ i = end;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ last = c;
|
|
|
+ }
|
|
|
+
|
|
|
+ final switch (state) {
|
|
|
+ case State.START:
|
|
|
+ break;
|
|
|
+ case State.SCHEME_OR_PATH:
|
|
|
+ _path = uri.substring(mark, end);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.HOST_OR_PATH:
|
|
|
+ _path = uri.substring(mark, end);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.HOST:
|
|
|
+ if (end > mark)
|
|
|
+ _host = uri.substring(mark, end);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.IPV6:
|
|
|
+ throw new IllegalArgumentException("No closing ']' for ipv6 in " ~ uri);
|
|
|
+
|
|
|
+ case State.PORT:
|
|
|
+ // _port = TypeUtils.parseInt(uri, mark, end - mark, 10);
|
|
|
+ _port = to!int(uri[mark .. end], 10);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.ASTERISK:
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.FRAGMENT:
|
|
|
+ _fragment = uri.substring(mark, end);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.PARAM:
|
|
|
+ _path = uri.substring(path_mark, end);
|
|
|
+ _param = uri.substring(mark, end);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.PATH:
|
|
|
+ _path = uri.substring(path_mark, end);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case State.QUERY:
|
|
|
+ _query = uri.substring(mark, end);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!encoded) {
|
|
|
+ if (_param == null)
|
|
|
+ _decodedPath = _path;
|
|
|
+ else
|
|
|
+ _decodedPath = _path[0 .. _path.length - _param.length - 1];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ string getScheme() {
|
|
|
+ return _scheme;
|
|
|
+ }
|
|
|
+
|
|
|
+ string getHost() {
|
|
|
+ // Return null for empty host to retain compatibility with java.net.URI
|
|
|
+ if (_host != null && _host.length == 0)
|
|
|
+ return null;
|
|
|
+ return _host;
|
|
|
+ }
|
|
|
+
|
|
|
+ int getPort() {
|
|
|
+ return _port;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The parsed Path.
|
|
|
+ *
|
|
|
+ * @return the path as parsed on valid URI. null for invalid URI.
|
|
|
+ */
|
|
|
+ string getPath() {
|
|
|
+ return _path;
|
|
|
+ }
|
|
|
+
|
|
|
+ string getDecodedPath() {
|
|
|
+ if (_decodedPath.empty && !_path.empty)
|
|
|
+ _decodedPath = URIUtils.canonicalPath(URIUtils.decodePath(_path));
|
|
|
+ return _decodedPath;
|
|
|
+ }
|
|
|
+
|
|
|
+ string getParam() {
|
|
|
+ return _param;
|
|
|
+ }
|
|
|
+
|
|
|
+ string getQuery() {
|
|
|
+ return _query;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool hasQuery() {
|
|
|
+ return _query != null && _query.length > 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ string getFragment() {
|
|
|
+ return _fragment;
|
|
|
+ }
|
|
|
+
|
|
|
+ void decodeQueryTo(MultiMap!string parameters, string encoding = StandardCharsets.UTF_8) {
|
|
|
+ if (_query == _fragment)
|
|
|
+ return;
|
|
|
+
|
|
|
+ UrlEncoded.decodeTo(_query, parameters, encoding);
|
|
|
+ }
|
|
|
+
|
|
|
+ void clear() {
|
|
|
+ _uri = null;
|
|
|
+
|
|
|
+ _scheme = null;
|
|
|
+ _host = null;
|
|
|
+ _port = -1;
|
|
|
+ _path = null;
|
|
|
+ _param = null;
|
|
|
+ _query = null;
|
|
|
+ _fragment = null;
|
|
|
+
|
|
|
+ _decodedPath = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool isAbsolute() {
|
|
|
+ return _scheme != null && _scheme.length > 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ override
|
|
|
+ string toString() {
|
|
|
+ if (_uri is null) {
|
|
|
+ StringBuilder ot = new StringBuilder();
|
|
|
+
|
|
|
+ if (_scheme != null)
|
|
|
+ ot.append(_scheme).append(':');
|
|
|
+
|
|
|
+ if (_host != null) {
|
|
|
+ ot.append("//");
|
|
|
+ if (_user != null)
|
|
|
+ ot.append(_user).append('@');
|
|
|
+ ot.append(_host);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_port > 0)
|
|
|
+ ot.append(':').append(_port);
|
|
|
+
|
|
|
+ if (_path != null)
|
|
|
+ ot.append(_path);
|
|
|
+
|
|
|
+ if (_query != null)
|
|
|
+ ot.append('?').append(_query);
|
|
|
+
|
|
|
+ if (_fragment != null)
|
|
|
+ ot.append('#').append(_fragment);
|
|
|
+
|
|
|
+ if (ot.length > 0)
|
|
|
+ _uri = ot.toString();
|
|
|
+ else
|
|
|
+ _uri = "";
|
|
|
+ }
|
|
|
+ return _uri;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool equals(Object o) {
|
|
|
+ if (o is this)
|
|
|
+ return true;
|
|
|
+ if (!(typeid(o) == typeid(HttpURI)))
|
|
|
+ return false;
|
|
|
+ return toString().equals(o.toString());
|
|
|
+ }
|
|
|
+
|
|
|
+ void setScheme(string scheme) {
|
|
|
+ _scheme = scheme;
|
|
|
+ _uri = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param host
|
|
|
+ * the host
|
|
|
+ * @param port
|
|
|
+ * the port
|
|
|
+ */
|
|
|
+ void setAuthority(string host, int port) {
|
|
|
+ _host = host;
|
|
|
+ _port = port;
|
|
|
+ _uri = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param path
|
|
|
+ * the path
|
|
|
+ */
|
|
|
+ void setPath(string path) {
|
|
|
+ _uri = null;
|
|
|
+ _path = path;
|
|
|
+ _decodedPath = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param path
|
|
|
+ * the decoded path
|
|
|
+ */
|
|
|
+ // void setDecodedPath(string path) {
|
|
|
+ // _uri = null;
|
|
|
+ // _path = URIUtils.encodePath(path);
|
|
|
+ // _decodedPath = path;
|
|
|
+ // }
|
|
|
+
|
|
|
+ void setPathQuery(string path) {
|
|
|
+ _uri = null;
|
|
|
+ _path = null;
|
|
|
+ _decodedPath = null;
|
|
|
+ _param = null;
|
|
|
+ _fragment = null;
|
|
|
+ if (path != null)
|
|
|
+ parse(State.PATH, path);
|
|
|
+ }
|
|
|
+
|
|
|
+ void setQuery(string query) {
|
|
|
+ _query = query;
|
|
|
+ _uri = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ // URI toURI() {
|
|
|
+ // return new URI(_scheme, null, _host, _port, _path, _query == null ? null : UrlEncoded.decodestring(_query),
|
|
|
+ // _fragment);
|
|
|
+ // }
|
|
|
+
|
|
|
+ string getPathQuery() {
|
|
|
+ if (_query == null)
|
|
|
+ return _path;
|
|
|
+ return _path ~ "?" ~ _query;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool hasAuthority() {
|
|
|
+ return _host != null;
|
|
|
+ }
|
|
|
+
|
|
|
+ string getAuthority() {
|
|
|
+ if (_port > 0)
|
|
|
+ return _host ~ ":" ~ to!string(_port);
|
|
|
+ return _host;
|
|
|
+ }
|
|
|
+
|
|
|
+ string getUser() {
|
|
|
+ return _user;
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ * Parse an authority string into Host and Port
|
|
|
+ * <p>Parse a string in the form "host:port", handling IPv4 an IPv6 hosts</p>
|
|
|
+ *
|
|
|
+ */
|
|
|
+class URIUtils
|
|
|
+{
|
|
|
+ /* ------------------------------------------------------------ */
|
|
|
+ /* Decode a URI path and strip parameters
|
|
|
+ */
|
|
|
+ static string decodePath(string path) {
|
|
|
+ return decodePath(path, 0, cast(int)path.length);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ */
|
|
|
+ /* Decode a URI path and strip parameters of UTF-8 path
|
|
|
+ */
|
|
|
+ static string decodePath(string path, int offset, int length) {
|
|
|
+ try {
|
|
|
+ StringBuilder builder = null;
|
|
|
+
|
|
|
+ int end = offset + length;
|
|
|
+ for (int i = offset; i < end; i++) {
|
|
|
+ char c = path[i];
|
|
|
+ switch (c) {
|
|
|
+ case '%':
|
|
|
+ if (builder is null) {
|
|
|
+ builder = new StringBuilder(path.length);
|
|
|
+ builder.append(path, offset, i - offset);
|
|
|
+ }
|
|
|
+ if ((i + 2) < end) {
|
|
|
+ char u = path.charAt(i + 1);
|
|
|
+ if (u == 'u') {
|
|
|
+ // TODO this is wrong. This is a codepoint not a char
|
|
|
+ builder.append(cast(char) (0xffff & TypeUtils.parseInt(path, i + 2, 4, 16)));
|
|
|
+ i += 5;
|
|
|
+ } else {
|
|
|
+ builder.append(cast(byte) (0xff & (TypeUtils.convertHexDigit(u) * 16 + TypeUtils.convertHexDigit(path.charAt(i + 2)))));
|
|
|
+ i += 2;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ throw new IllegalArgumentException("Bad URI % encoding");
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ';':
|
|
|
+ if (builder is null) {
|
|
|
+ builder = new StringBuilder(path.length);
|
|
|
+ builder.append(path, offset, i - offset);
|
|
|
+ }
|
|
|
+
|
|
|
+ while (++i < end) {
|
|
|
+ if (path[i] == '/') {
|
|
|
+ builder.append('/');
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ if (builder !is null)
|
|
|
+ builder.append(c);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (builder !is null)
|
|
|
+ return builder.toString();
|
|
|
+ if (offset == 0 && length == path.length)
|
|
|
+ return path;
|
|
|
+ return path.substring(offset, end);
|
|
|
+ } catch (Exception e) {
|
|
|
+ // System.err.println(path.substring(offset, offset + length) + " " + e);
|
|
|
+ error(e.toString);
|
|
|
+ return decodeISO88591Path(path, offset, length);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ */
|
|
|
+ /* Decode a URI path and strip parameters of ISO-8859-1 path
|
|
|
+ */
|
|
|
+ private static string decodeISO88591Path(string path, int offset, int length) {
|
|
|
+ StringBuilder builder = null;
|
|
|
+ int end = offset + length;
|
|
|
+ for (int i = offset; i < end; i++) {
|
|
|
+ char c = path[i];
|
|
|
+ switch (c) {
|
|
|
+ case '%':
|
|
|
+ if (builder is null) {
|
|
|
+ builder = new StringBuilder(path.length);
|
|
|
+ builder.append(path, offset, i - offset);
|
|
|
+ }
|
|
|
+ if ((i + 2) < end) {
|
|
|
+ char u = path.charAt(i + 1);
|
|
|
+ if (u == 'u') {
|
|
|
+ // TODO this is wrong. This is a codepoint not a char
|
|
|
+ builder.append(cast(char) (0xffff & TypeUtils.parseInt(path, i + 2, 4, 16)));
|
|
|
+ i += 5;
|
|
|
+ } else {
|
|
|
+ builder.append(cast(byte) (0xff & (TypeUtils.convertHexDigit(u) * 16 + TypeUtils.convertHexDigit(path.charAt(i + 2)))));
|
|
|
+ i += 2;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ throw new IllegalArgumentException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ';':
|
|
|
+ if (builder is null) {
|
|
|
+ builder = new StringBuilder(path.length);
|
|
|
+ builder.append(path, offset, i - offset);
|
|
|
+ }
|
|
|
+ while (++i < end) {
|
|
|
+ if (path[i] == '/') {
|
|
|
+ builder.append('/');
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+
|
|
|
+ default:
|
|
|
+ if (builder !is null)
|
|
|
+ builder.append(c);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (builder !is null)
|
|
|
+ return builder.toString();
|
|
|
+ if (offset == 0 && length == path.length)
|
|
|
+ return path;
|
|
|
+ return path.substring(offset, end);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Convert a decoded path to a canonical form.
|
|
|
+ * <p>
|
|
|
+ * All instances of "." and ".." are factored out.
|
|
|
+ * </p>
|
|
|
+ * <p>
|
|
|
+ * Null is returned if the path tries to .. above its root.
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param path the path to convert, decoded, with path separators '/' and no queries.
|
|
|
+ * @return the canonical path, or null if path traversal above root.
|
|
|
+ */
|
|
|
+ static string canonicalPath(string path) {
|
|
|
+ if (path.empty)
|
|
|
+ return path;
|
|
|
+
|
|
|
+ bool slash = true;
|
|
|
+ int end = cast(int)path.length;
|
|
|
+ int i = 0;
|
|
|
+
|
|
|
+ loop:
|
|
|
+ while (i < end) {
|
|
|
+ char c = path[i];
|
|
|
+ switch (c) {
|
|
|
+ case '/':
|
|
|
+ slash = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '.':
|
|
|
+ if (slash)
|
|
|
+ break loop;
|
|
|
+ slash = false;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ slash = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (i == end)
|
|
|
+ return path;
|
|
|
+
|
|
|
+ StringBuilder canonical = new StringBuilder(path.length);
|
|
|
+ canonical.append(path, 0, i);
|
|
|
+
|
|
|
+ int dots = 1;
|
|
|
+ i++;
|
|
|
+ while (i <= end) {
|
|
|
+ char c = i < end ? path[i] : '\0';
|
|
|
+ switch (c) {
|
|
|
+ case '\0':
|
|
|
+ case '/':
|
|
|
+ switch (dots) {
|
|
|
+ case 0:
|
|
|
+ if (c != '\0')
|
|
|
+ canonical.append(c);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 1:
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 2:
|
|
|
+ if (canonical.length < 2)
|
|
|
+ return null;
|
|
|
+ canonical.setLength(canonical.length - 1);
|
|
|
+ canonical.setLength(canonical.lastIndexOf("/") + 1);
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ while (dots-- > 0)
|
|
|
+ canonical.append('.');
|
|
|
+ if (c != '\0')
|
|
|
+ canonical.append(c);
|
|
|
+ }
|
|
|
+
|
|
|
+ slash = true;
|
|
|
+ dots = 0;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '.':
|
|
|
+ if (dots > 0)
|
|
|
+ dots++;
|
|
|
+ else if (slash)
|
|
|
+ dots = 1;
|
|
|
+ else
|
|
|
+ canonical.append('.');
|
|
|
+ slash = false;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ while (dots-- > 0)
|
|
|
+ canonical.append('.');
|
|
|
+ canonical.append(c);
|
|
|
+ dots = 0;
|
|
|
+ slash = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ return canonical.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Convert a path to a cananonical form.
|
|
|
+ * <p>
|
|
|
+ * All instances of "." and ".." are factored out.
|
|
|
+ * </p>
|
|
|
+ * <p>
|
|
|
+ * Null is returned if the path tries to .. above its root.
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param path the path to convert (expects URI/URL form, encoded, and with path separators '/')
|
|
|
+ * @return the canonical path, or null if path traversal above root.
|
|
|
+ */
|
|
|
+ static string canonicalEncodedPath(string path) {
|
|
|
+ if (path.empty)
|
|
|
+ return path;
|
|
|
+
|
|
|
+ bool slash = true;
|
|
|
+ int end = cast(int)path.length;
|
|
|
+ int i = 0;
|
|
|
+
|
|
|
+ loop:
|
|
|
+ while (i < end) {
|
|
|
+ char c = path[i];
|
|
|
+ switch (c) {
|
|
|
+ case '/':
|
|
|
+ slash = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '.':
|
|
|
+ if (slash)
|
|
|
+ break loop;
|
|
|
+ slash = false;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '?':
|
|
|
+ return path;
|
|
|
+
|
|
|
+ default:
|
|
|
+ slash = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (i == end)
|
|
|
+ return path;
|
|
|
+
|
|
|
+ StringBuilder canonical = new StringBuilder(path.length);
|
|
|
+ canonical.append(path, 0, i);
|
|
|
+
|
|
|
+ int dots = 1;
|
|
|
+ i++;
|
|
|
+ while (i <= end) {
|
|
|
+ char c = i < end ? path[i] : '\0';
|
|
|
+ switch (c) {
|
|
|
+ case '\0':
|
|
|
+ case '/':
|
|
|
+ case '?':
|
|
|
+ switch (dots) {
|
|
|
+ case 0:
|
|
|
+ if (c != '\0')
|
|
|
+ canonical.append(c);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 1:
|
|
|
+ if (c == '?')
|
|
|
+ canonical.append(c);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 2:
|
|
|
+ if (canonical.length < 2)
|
|
|
+ return null;
|
|
|
+ canonical.setLength(canonical.length - 1);
|
|
|
+ canonical.setLength(canonical.lastIndexOf("/") + 1);
|
|
|
+ if (c == '?')
|
|
|
+ canonical.append(c);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ while (dots-- > 0)
|
|
|
+ canonical.append('.');
|
|
|
+ if (c != '\0')
|
|
|
+ canonical.append(c);
|
|
|
+ }
|
|
|
+
|
|
|
+ slash = true;
|
|
|
+ dots = 0;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case '.':
|
|
|
+ if (dots > 0)
|
|
|
+ dots++;
|
|
|
+ else if (slash)
|
|
|
+ dots = 1;
|
|
|
+ else
|
|
|
+ canonical.append('.');
|
|
|
+ slash = false;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ while (dots-- > 0)
|
|
|
+ canonical.append('.');
|
|
|
+ canonical.append(c);
|
|
|
+ dots = 0;
|
|
|
+ slash = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ return canonical.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Convert a path to a compact form.
|
|
|
+ * All instances of "//" and "///" etc. are factored out to single "/"
|
|
|
+ *
|
|
|
+ * @param path the path to compact
|
|
|
+ * @return the compacted path
|
|
|
+ */
|
|
|
+ static string compactPath(string path) {
|
|
|
+ if (path == null || path.length == 0)
|
|
|
+ return path;
|
|
|
+
|
|
|
+ int state = 0;
|
|
|
+ int end = cast(int)path.length;
|
|
|
+ int i = 0;
|
|
|
+
|
|
|
+ loop:
|
|
|
+ while (i < end) {
|
|
|
+ char c = path[i];
|
|
|
+ switch (c) {
|
|
|
+ case '?':
|
|
|
+ return path;
|
|
|
+ case '/':
|
|
|
+ state++;
|
|
|
+ if (state == 2)
|
|
|
+ break loop;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ state = 0;
|
|
|
+ }
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state < 2)
|
|
|
+ return path;
|
|
|
+
|
|
|
+ StringBuilder buf = new StringBuilder(path.length);
|
|
|
+ buf.append(path, 0, i);
|
|
|
+
|
|
|
+ loop2:
|
|
|
+ while (i < end) {
|
|
|
+ char c = path[i];
|
|
|
+ switch (c) {
|
|
|
+ case '?':
|
|
|
+ buf.append(path, i, end);
|
|
|
+ break loop2;
|
|
|
+ case '/':
|
|
|
+ if (state++ == 0)
|
|
|
+ buf.append(c);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ state = 0;
|
|
|
+ buf.append(c);
|
|
|
+ }
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ return buf.toString();
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param uri URI
|
|
|
+ * @return True if the uri has a scheme
|
|
|
+ */
|
|
|
+ static bool hasScheme(string uri) {
|
|
|
+ for (int i = 0; i < uri.length; i++) {
|
|
|
+ char c = uri[i];
|
|
|
+ if (c == ':')
|
|
|
+ return true;
|
|
|
+ if (!(c >= 'a' && c <= 'z' ||
|
|
|
+ c >= 'A' && c <= 'Z' ||
|
|
|
+ (i > 0 && (c >= '0' && c <= '9' ||
|
|
|
+ c == '.' ||
|
|
|
+ c == '+' ||
|
|
|
+ c == '-'))
|
|
|
+ ))
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
Heromyth