/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_tools.hxx" #include #include #include #include "com/sun/star/uno/Reference.hxx" #include "com/sun/star/util/XStringWidth.hpp" #include "osl/diagnose.h" #include "osl/file.hxx" #include "rtl/string.h" #include "rtl/textenc.h" #include "rtl/ustring.hxx" #include "sal/types.h" #ifndef INCLUDED_ALGORITHM #include #define INCLUDED_ALGORITHM #endif #ifndef INCLUDED_LIMITS #include #define INCLUDED_LIMITS #endif #include namespace unnamed_tools_urlobj {} using namespace unnamed_tools_urlobj; // unnamed namespaces don't work well yet... using namespace com::sun; //============================================================================ // // INetURLObject // //============================================================================ /* The URI grammar (using RFC 2234 conventions). Constructs of the form {reference using rule2} stand for a rule matching the given rule1 specified in the given reference, encoded to URI syntax using rule2 (as specified in this URI grammar). ; RFC 1738, RFC 2396, RFC 2732, private login = [user [":" password] "@"] hostport user = *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ";" / "=" / "_" / "~") password = *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ";" / "=" / "_" / "~") hostport = host [":" port] host = incomplete-hostname / hostname / IPv4address / IPv6reference incomplete-hostname = *(domainlabel ".") domainlabel hostname = *(domainlabel ".") toplabel ["."] domainlabel = alphanum [*(alphanum / "-") alphanum] toplabel = ALPHA [*(alphanum / "-") alphanum] IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT IPv6reference = "[" hexpart [":" IPv4address] "]" hexpart = (hexseq ["::" [hexseq]]) / ("::" [hexseq]) hexseq = hex4 *(":" hex4) hex4 = 1*4HEXDIG port = *DIGIT escaped = "%" HEXDIG HEXDIG reserved = "$" / "&" / "+" / "," / "/" / ":" / ";" / "=" / "?" / "@" / "[" / "]" mark = "!" / "'" / "(" / ")" / "*" / "-" / "." / "_" / "~" alphanum = ALPHA / DIGIT unreserved = alphanum / mark uric = escaped / reserved / unreserved pchar = escaped / unreserved / "$" / "&" / "+" / "," / ":" / "=" / "@" ; RFC 1738, RFC 2396 ftp-url = "FTP://" login ["/" segment *("/" segment) [";TYPE=" ("A" / "D" / "I")]] segment = *pchar ; RFC 1738, RFC 2396 http-url = "HTTP://" hostport ["/" segment *("/" segment) ["?" *uric]] segment = *(pchar / ";") ; RFC 1738, RFC 2396, file-url = "FILE://" [host / "LOCALHOST" / netbios-name] ["/" segment *("/" segment)] segment = *pchar netbios-name = 1*{ using (escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "-" / "." / "@" / "_" / "~")} ; RFC 2368, RFC 2396 mailto-url = "MAILTO:" [to] [headers] to = {RFC 822 <#mailbox> using *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} headers = "?" header *("&" header) header = hname "=" hvalue hname = {RFC 822 using *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} / "BODY" hvalue = {RFC 822 using *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} ; private (see RFC 1738, RFC 2396) vnd-sun-star-webdav-url = "VND.SUN.STAR.WEBDAV://" hostport ["/" segment *("/" segment) ["?" *uric]] segment = *(pchar / ";") ; RFC 1738, RFC 2396, RFC 2732 news-url = "NEWS:" grouppart grouppart = "*" / group / article group = alpha *(alphanum / "+" / "-" / "." / "_") article = 1*(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "?" / "_" / "~") "@" host ; private private-url = "PRIVATE:" path ["?" *uric] path = *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~") ; private vnd-sun-star-help-url = "VND.SUN.STAR.HELP://" name *("/" segment) ["?" *uric] name = *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "@" / "_" / "~") segment = *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "@" / "_" / "~") ; private https-url = "HTTPS://" hostport ["/" segment *("/" segment) ["?" *uric]] segment = *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "@" / "_" / "~") ; private slot-url = "SLOT:" path ["?" *uric] path = *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~") ; private macro-url = "MACRO:" path ["?" *uric] path = *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~") ; private javascript-url = "JAVASCRIPT:" *uric ; private (see RFC 2192) imap-url = "IMAP://" user [";AUTH=" auth] "@" hostport "/" segment *("/" segment) ["/;UID=" nz_number] user = 1*{RFC 2060 using (escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "=" / "_" / "~")} auth = {RFC 2060 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "+" / "," / "-" / "." / "=" / "_" / "~")} segment = *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / "=" / "@" / "_" / "~") nz_number = {RFC 2060 using *DIGIT} ; private pop3-url = "POP3://" login ["/" ["<" *uric ">"]] ; RFC 2397 data-url = "DATA:" [mediatype] [";BASE64"] "," *uric mediatype = [type "/" subtype] *(";" attribute "=" value) type = {RFC 2045 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} subtype = {RFC 2045 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} attribute = {RFC 2045 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} value = {RFC 2045 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} ; RFC 2392, RFC 2396 cid-url = "CID:" {RFC 822 using *uric} ; private out-url = "OUT:///~" name ["/" *uric] name = *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "?" / "@" / "_" / "~" ; private vnd-sun-star-hier-url = "VND.SUN.STAR.HIER:" ["//"reg_name] *("/" *pchar) reg_name = 1*(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "@" / "_" / "~") ; private vim-url = "VIM://" +vimc [":" *vimc] ["/" [("INBOX" message) / ("NEWSGROUPS" ["/" [+vimc message]])]] message = ["/" [+vimc [":" +DIGIT "." +DIGIT "." +DIGIT]]] vimc = ("=" HEXDIG HEXDIG) / alphanum ; private uno-url = ".UNO:" path ["?" *uric] path = *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~") ; private component-url = ".COMPONENT:" path ["?" *uric] path = *(escaped / alphanum / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~") ; private vnd-sun-star-pkg-url = "VND.SUN.STAR.PKG://" reg_name *("/" *pchar) ["?" *uric] reg_name = 1*(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "@" / "_" / "~") ; RFC 2255 ldap-url = "LDAP://" [hostport] ["/" [dn ["?" [attrdesct *("," attrdesc)] ["?" ["base" / "one" / "sub"] ["?" [filter] ["?" extension *("," extension)]]]]]] dn = {RFC 2253 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} attrdesc = {RFC 2251 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} filter = {RFC 2254 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} extension = ["!"] ["X-"] extoken ["=" exvalue] extoken = {RFC 2252 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} exvalue = {RFC 2251 using *(escaped / alphanum / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} ; private db-url = "DB:" *uric ; private vnd-sun-star-cmd-url = "VND.SUN.STAR.CMD:" opaque_part opaque_part = uric_no_slash *uric uric_no_slash = unreserved / escaped / ";" / "?" / ":" / "@" / "&" / "=" / "+" / "$" / "," ; private vnd-sun-star-url = "VND.SUN.STAR.ODMA:" ["/" *uric_no_slash] uric_no_slash = unreserved / escaped / ";" / "?" / ":" / "@" / "&" / "=" / "+" / "$" / "," ; RFC 1738 telnet-url = "TELNET://" login ["/"] ; private vnd-sun-star-expand-url = "VND.SUN.STAR.EXPAND:" opaque_part opaque_part = uric_no_slash *uric uric_no_slash = unreserved / escaped / ";" / "?" / ":" / "@" / "&" / "=" / "+" / "$" / "," ; private vnd-sun-star-tdoc-url = "VND.SUN.STAR.TDOC:/" segment *("/" segment) segment = *pchar ; private unknown-url = scheme ":" 1*uric scheme = ALPHA *(alphanum / "+" / "-" / ".") ; private (http://ubiqx.org/cifs/Appendix-D.html): smb-url = "SMB://" login ["/" segment *("/" segment) ["?" *uric]] segment = *(pchar / ";") */ //============================================================================ inline sal_Int32 INetURLObject::SubString::clear() { sal_Int32 nDelta = -m_nLength; m_nBegin = -1; m_nLength = 0; return nDelta; } inline sal_Int32 INetURLObject::SubString::set(rtl::OUStringBuffer & rString, rtl::OUString const & rSubString) { rtl::OUString sTemp(rString.makeStringAndClear()); sal_Int32 nDelta = set(sTemp, rSubString); rString.append(sTemp); return nDelta; } inline sal_Int32 INetURLObject::SubString::set(rtl::OUString & rString, rtl::OUString const & rSubString) { sal_Int32 nDelta = rSubString.getLength() - m_nLength; rString = rString.replaceAt(m_nBegin, m_nLength, rSubString); m_nLength = rSubString.getLength(); return nDelta; } inline sal_Int32 INetURLObject::SubString::set(rtl::OUStringBuffer & rString, rtl::OUString const & rSubString, sal_Int32 nTheBegin) { m_nBegin = nTheBegin; return set(rString, rSubString); } //============================================================================ inline void INetURLObject::SubString::operator +=(sal_Int32 nDelta) { if (isPresent()) m_nBegin = m_nBegin + nDelta; } //============================================================================ int INetURLObject::SubString::compare(SubString const & rOther, rtl::OUStringBuffer const & rThisString, rtl::OUStringBuffer const & rOtherString) const { sal_Int32 len = std::min(m_nLength, rOther.m_nLength); sal_Unicode const * p1 = rThisString.getStr() + m_nBegin; sal_Unicode const * end = p1 + len; sal_Unicode const * p2 = rOtherString.getStr() + rOther.m_nBegin; while (p1 != end) { if (*p1 < *p2) { return -1; } else if (*p1 > *p2) { return 1; } ++p1; ++p2; } return m_nLength < rOther.m_nLength ? -1 : m_nLength > rOther.m_nLength ? 1 : 0; } //============================================================================ struct INetURLObject::SchemeInfo { sal_Char const * m_pScheme; sal_Char const * m_pPrefix; sal_uInt16 m_nDefaultPort; bool m_bAuthority; bool m_bUser; bool m_bAuth; bool m_bPassword; bool m_bHost; bool m_bPort; bool m_bHierarchical; bool m_bQuery; }; //============================================================================ struct INetURLObject::PrefixInfo { enum Kind { OFFICIAL, INTERNAL, EXTERNAL, ALIAS }; // order is important! sal_Char const * m_pPrefix; sal_Char const * m_pTranslatedPrefix; INetProtocol m_eScheme; Kind m_eKind; }; //============================================================================ static INetURLObject::SchemeInfo const aSchemeInfoMap[INET_PROT_END] = { { "", "", 0, false, false, false, false, false, false, false, false }, { "ftp", "ftp://", 21, true, true, false, true, true, true, true, false }, { "http", "http://", 80, true, false, false, false, true, true, true, true }, { "file", "file://", 0, true, false, false, false, true, false, true, false }, { "mailto", "mailto:", 0, false, false, false, false, false, false, false, true }, { "vnd.sun.star.webdav", "vnd.sun.star.webdav://", 80, true, false, false, false, true, true, true, true }, { "news", "news:", 0, false, false, false, false, false, false, false, false }, { "private", "private:", 0, false, false, false, false, false, false, false, true }, { "vnd.sun.star.help", "vnd.sun.star.help://", 0, true, false, false, false, false, false, true, true }, { "https", "https://", 443, true, false, false, false, true, true, true, true }, { "slot", "slot:", 0, false, false, false, false, false, false, false, true }, { "macro", "macro:", 0, false, false, false, false, false, false, false, true }, { "javascript", "javascript:", 0, false, false, false, false, false, false, false, false }, { "imap", "imap://", 143, true, true, true, false, true, true, true, false }, { "pop3", "pop3://", 110, true, true, false, true, true, true, false, false }, { "data", "data:", 0, false, false, false, false, false, false, false, false }, { "cid", "cid:", 0, false, false, false, false, false, false, false, false }, { "out", "out://", 0, true, false, false, false, false, false, false, false }, { "vnd.sun.star.hier", "vnd.sun.star.hier:", 0, true, false, false, false, false, false, true, false }, { "vim", "vim://", 0, true, true, false, true, false, false, true, false }, { ".uno", ".uno:", 0, false, false, false, false, false, false, false, true }, { ".component", ".component:", 0, false, false, false, false, false, false, false, true }, { "vnd.sun.star.pkg", "vnd.sun.star.pkg://", 0, true, false, false, false, false, false, true, true }, { "ldap", "ldap://", 389, true, false, false, false, true, true, false, true }, { "db", "db:", 0, false, false, false, false, false, false, false, false }, { "vnd.sun.star.cmd", "vnd.sun.star.cmd:", 0, false, false, false, false, false, false, false, false }, { "vnd.sun.star.odma", "vnd.sun.star.odma:", 0, false, false, false, false, false, false, true, false }, { "telnet", "telnet://", 23, true, true, false, true, true, true, true, false }, { "vnd.sun.star.expand", "vnd.sun.star.expand:", 0, false, false, false, false, false, false, false, false }, { "vnd.sun.star.tdoc", "vnd.sun.star.tdoc:", 0, false, false, false, false, false, false, true, false }, { "", "", 0, false, false, false, false, true, true, true, false }, { "smb", "smb://", 139, true, true, false, true, true, true, true, true }, { "hid", "hid:", 0, false, false, false, false, false, false, false, true } }; // static inline INetURLObject::SchemeInfo const & INetURLObject::getSchemeInfo(INetProtocol eTheScheme) { return aSchemeInfoMap[eTheScheme]; }; //============================================================================ inline INetURLObject::SchemeInfo const & INetURLObject::getSchemeInfo() const { return getSchemeInfo(m_eScheme); } //============================================================================ // static inline void INetURLObject::appendEscape(rtl::OUStringBuffer & rTheText, sal_Char cEscapePrefix, sal_uInt32 nOctet) { rTheText.append(sal_Unicode(cEscapePrefix)); rTheText.append(sal_Unicode(INetMIME::getHexDigit(int(nOctet >> 4)))); rTheText.append(sal_Unicode(INetMIME::getHexDigit(int(nOctet & 15)))); } //============================================================================ namespace unnamed_tools_urlobj { enum { PA = INetURLObject::PART_OBSOLETE_NORMAL, PB = INetURLObject::PART_OBSOLETE_FILE, PC = INetURLObject::PART_OBSOLETE_PARAM, PD = INetURLObject::PART_USER_PASSWORD, PE = INetURLObject::PART_IMAP_ACHAR, PF = INetURLObject::PART_VIM, PG = INetURLObject::PART_HOST_EXTRA, PH = INetURLObject::PART_FPATH, PI = INetURLObject::PART_AUTHORITY, PJ = INetURLObject::PART_PATH_SEGMENTS_EXTRA, PK = INetURLObject::PART_REL_SEGMENT_EXTRA, PL = INetURLObject::PART_URIC, PM = INetURLObject::PART_HTTP_PATH, PN = INetURLObject::PART_FILE_SEGMENT_EXTRA, PO = INetURLObject::PART_MESSAGE_ID, PP = INetURLObject::PART_MESSAGE_ID_PATH, PQ = INetURLObject::PART_MAILTO, PR = INetURLObject::PART_PATH_BEFORE_QUERY, PS = INetURLObject::PART_PCHAR, PT = INetURLObject::PART_FRAGMENT, PU = INetURLObject::PART_VISIBLE, PV = INetURLObject::PART_VISIBLE_NONSPECIAL, PW = INetURLObject::PART_CREATEFRAGMENT, PX = INetURLObject::PART_UNO_PARAM_VALUE, PY = INetURLObject::PART_UNAMBIGUOUS, PZ = INetURLObject::PART_URIC_NO_SLASH, P1 = INetURLObject::PART_HTTP_QUERY, P2 = INetURLObject::PART_NEWS_ARTICLE_LOCALPART }; static sal_uInt32 const aMustEncodeMap[128] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ PY, /* ! */ PC+PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* " */ PU+PV +PY, /* # */ PU, /* $ */ PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* % */ PU, /* & */ PA+PB+PC+PD+PE +PH+PI+PJ+PK+PL+PM+PN+PO+PP +PR+PS+PT+PU+PV+PW+PX +PZ+P1+P2, /* ' */ PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* ( */ PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* ) */ PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* * */ PA+PB+PC+PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* + */ PA+PB+PC+PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX +PZ+P1+P2, /* , */ PA+PB+PC+PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW +PZ+P1+P2, /* - */ PA+PB+PC+PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* . */ PA+PB+PC+PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* / */ PA+PB+PC +PH +PJ +PL+PM +PP+PQ+PR +PT+PU+PV +PX +P2, /* 0 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 1 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 2 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 3 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 4 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 5 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 6 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 7 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 8 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* 9 */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* : */ PB+PC +PH+PI+PJ +PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX +PZ+P1+P2, /* ; */ PC+PD +PI+PJ+PK+PL+PM +PO+PP+PQ+PR +PT+PU +PW +PZ+P1+P2, /* < */ PC +PO+PP +PU+PV +PY, /* = */ PA+PB+PC+PD+PE +PH+PI+PJ+PK+PL+PM+PN +PR+PS+PT+PU+PV+PW +PZ+P1+P2, /* > */ PC +PO+PP +PU+PV +PY, /* ? */ PC +PL +PT+PU +PW+PX +PZ +P2, /* @ */ PC +PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1, /* A */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* B */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* C */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* D */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* E */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* F */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* G */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* H */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* I */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* J */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* K */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* L */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* M */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* N */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* O */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* P */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* Q */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* R */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* S */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* T */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* U */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* V */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* W */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* X */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* Y */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* Z */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* [ */ PL +PU+PV +PX, /* \ */ PB +PU+PV +PY, /* ] */ PL +PU+PV +PX, /* ^ */ PU+PV +PY, /* _ */ PA+PB+PC+PD+PE +PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* ` */ PU+PV +PY, /* a */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* b */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* c */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* d */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* e */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* f */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* g */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* h */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* i */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* j */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* k */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* l */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* m */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* n */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* o */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* p */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* q */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* r */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* s */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* t */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* u */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* v */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* w */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* x */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* y */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* z */ PA+PB+PC+PD+PE+PF+PG+PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ+P1+P2, /* { */ PU+PV +PY, /* | */ PB+PC +PN +PT+PU+PV +PY, /* } */ PU+PV +PY, /* ~ */ PA+PB+PC+PD+PE +PH+PI+PJ+PK+PL+PM+PN+PO+PP+PQ+PR+PS+PT+PU+PV+PW+PX+PY+PZ +P2, 0 }; inline bool mustEncode(sal_uInt32 nUTF32, INetURLObject::Part ePart) { return !INetMIME::isUSASCII(nUTF32) || !(aMustEncodeMap[nUTF32] & ePart); } } //============================================================================ void INetURLObject::setInvalid() { m_aAbsURIRef.setLength(0); m_eScheme = INET_PROT_NOT_VALID; m_aScheme.clear(); m_aUser.clear(); m_aAuth.clear(); m_aHost.clear(); m_aPort.clear(); m_aPath.clear(); m_aQuery.clear(); m_aFragment.clear(); } //============================================================================ namespace unnamed_tools_urlobj { INetURLObject::FSysStyle guessFSysStyleByCounting(sal_Unicode const * pBegin, sal_Unicode const * pEnd, INetURLObject::FSysStyle eStyle) { DBG_ASSERT(eStyle & (INetURLObject::FSYS_UNX | INetURLObject::FSYS_DOS | INetURLObject::FSYS_MAC), "guessFSysStyleByCounting(): Bad style"); DBG_ASSERT(std::numeric_limits< sal_Int32 >::min() < pBegin - pEnd && pEnd - pBegin <= std::numeric_limits< sal_Int32 >::max(), "guessFSysStyleByCounting(): Too big"); sal_Int32 nSlashCount = eStyle & INetURLObject::FSYS_UNX ? 0 : std::numeric_limits< sal_Int32 >::min(); sal_Int32 nBackslashCount = eStyle & INetURLObject::FSYS_DOS ? 0 : std::numeric_limits< sal_Int32 >::min(); sal_Int32 nColonCount = eStyle & INetURLObject::FSYS_MAC ? 0 : std::numeric_limits< sal_Int32 >::min(); while (pBegin != pEnd) switch (*pBegin++) { case '/': ++nSlashCount; break; case '\\': ++nBackslashCount; break; case ':': ++nColonCount; break; } return nSlashCount >= nBackslashCount ? nSlashCount >= nColonCount ? INetURLObject::FSYS_UNX : INetURLObject::FSYS_MAC : nBackslashCount >= nColonCount ? INetURLObject::FSYS_DOS : INetURLObject::FSYS_MAC; } rtl::OUString parseScheme( sal_Unicode const ** begin, sal_Unicode const * end, sal_uInt32 fragmentDelimiter) { sal_Unicode const * p = *begin; if (p != end && INetMIME::isAlpha(*p)) { do { ++p; } while (p != end && (INetMIME::isAlphanumeric(*p) || *p == '+' || *p == '-' || *p == '.')); // #i34835# To avoid problems with Windows file paths like "C:\foo", // do not accept generic schemes that are only one character long: if (end - p > 1 && p[0] == ':' && p[1] != fragmentDelimiter && p - *begin >= 2) { rtl::OUString scheme( rtl::OUString(*begin, p - *begin).toAsciiLowerCase()); *begin = p + 1; return scheme; } } return rtl::OUString(); } } bool INetURLObject::setAbsURIRef(rtl::OUString const & rTheAbsURIRef, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset, bool bSmart, FSysStyle eStyle) { sal_Unicode const * pPos = rTheAbsURIRef.getStr(); sal_Unicode const * pEnd = pPos + rTheAbsURIRef.getLength(); setInvalid(); sal_uInt32 nFragmentDelimiter = '#'; rtl::OUStringBuffer aSynAbsURIRef; // Parse : sal_Unicode const * p = pPos; PrefixInfo const * pPrefix = getPrefix(p, pEnd); if (pPrefix) { pPos = p; m_eScheme = pPrefix->m_eScheme; rtl::OUString sTemp(rtl::OUString::createFromAscii(pPrefix->m_eKind >= PrefixInfo::EXTERNAL ? pPrefix->m_pTranslatedPrefix : pPrefix->m_pPrefix)); aSynAbsURIRef.append(sTemp); m_aScheme = SubString( 0, sTemp.indexOf(static_cast< sal_Unicode >(':')) ); } else { if (bSmart) { // For scheme detection, the first (if any) of the following // productions that matches the input string (and for which the // appropriate style bit is set in eStyle, if applicable) // determines the scheme. The productions use the auxiliary rules // // domain = label *("." label) // label = alphanum [*(alphanum / "-") alphanum] // alphanum = ALPHA / DIGIT // IPv6reference = "[" IPv6address "]" // IPv6address = hexpart [":" IPv4address] // IPv4address = 1*3DIGIT 3("." 1*3DIGIT) // hexpart = (hexseq ["::" [hexseq]]) / ("::" [hexseq]) // hexseq = hex4 *(":" hex4) // hex4 = 1*4HEXDIG // UCS4 = // // 1st Production (known scheme): // ":" *UCS4 // // 2nd Production (mailto): // domain "@" domain // // 3rd Production (ftp): // "FTP" 2*("." label) ["/" *UCS4] // // 4th Production (http): // label 2*("." label) ["/" *UCS4] // // 5th Production (file): // "//" (domain / IPv6reference) ["/" *UCS4] // // 6th Production (Unix file): // "/" *UCS4 // // 7th Production (UNC file; FSYS_DOS only): // "\\" domain ["\" *UCS4] // // 8th Production (Unix-like DOS file; FSYS_DOS only): // ALPHA ":" ["/" *UCS4] // // 9th Production (DOS file; FSYS_DOS only): // ALPHA ":" ["\" *UCS4] // // For the 'non URL' file productions 6--9, the interpretation of // the input as a (degenerate) URI is turned off, i.e., escape // sequences and fragments are never detected as such, but are // taken as literal characters. sal_Unicode const * p1 = pPos; if (eStyle & FSYS_DOS && pEnd - p1 >= 2 && INetMIME::isAlpha(p1[0]) && p1[1] == ':' && (pEnd - p1 == 2 || p1[2] == '/' || p1[2] == '\\')) { m_eScheme = INET_PROT_FILE; // 8th, 9th eMechanism = ENCODE_ALL; nFragmentDelimiter = 0x80000000; } else if (pEnd - p1 >= 2 && p1[0] == '/' && p1[1] == '/') { p1 += 2; if ((scanDomain(p1, pEnd) > 0 || scanIPv6reference(p1, pEnd)) && (p1 == pEnd || *p1 == '/')) m_eScheme = INET_PROT_FILE; // 5th } else if (p1 != pEnd && *p1 == '/') { m_eScheme = INET_PROT_FILE; // 6th eMechanism = ENCODE_ALL; nFragmentDelimiter = 0x80000000; } else if (eStyle & FSYS_DOS && pEnd - p1 >= 2 && p1[0] == '\\' && p1[1] == '\\') { p1 += 2; sal_Int32 n = rtl_ustr_indexOfChar_WithLength( p1, pEnd - p1, '\\'); sal_Unicode const * pe = n == -1 ? pEnd : p1 + n; if ( parseHostOrNetBiosName( p1, pe, bOctets, ENCODE_ALL, RTL_TEXTENCODING_DONTKNOW, true, NULL) || (scanDomain(p1, pe) > 0 && p1 == pe) ) { m_eScheme = INET_PROT_FILE; // 7th eMechanism = ENCODE_ALL; nFragmentDelimiter = 0x80000000; } } else { sal_Unicode const * pDomainEnd = p1; sal_uInt32 nLabels = scanDomain(pDomainEnd, pEnd); if (nLabels > 0 && pDomainEnd != pEnd && *pDomainEnd == '@') { ++pDomainEnd; if (scanDomain(pDomainEnd, pEnd) > 0 && pDomainEnd == pEnd) m_eScheme = INET_PROT_MAILTO; // 2nd } else if (nLabels >= 3 && (pDomainEnd == pEnd || *pDomainEnd == '/')) m_eScheme = pDomainEnd - p1 >= 4 && (p1[0] == 'f' || p1[0] == 'F') && (p1[1] == 't' || p1[1] == 'T') && (p1[2] == 'p' || p1[2] == 'P') && p1[3] == '.' ? INET_PROT_FTP : INET_PROT_HTTP; // 3rd, 4th } } rtl::OUString aSynScheme; if (m_eScheme == INET_PROT_NOT_VALID) { sal_Unicode const * p1 = pPos; aSynScheme = parseScheme(&p1, pEnd, nFragmentDelimiter); if (aSynScheme.getLength() > 0) { m_eScheme = INET_PROT_GENERIC; pPos = p1; } } if (bSmart && m_eScheme == INET_PROT_NOT_VALID && pPos != pEnd && *pPos != nFragmentDelimiter) { m_eScheme = m_eSmartScheme; } if (m_eScheme == INET_PROT_NOT_VALID) { setInvalid(); return false; } if (m_eScheme != INET_PROT_GENERIC) { aSynScheme = rtl::OUString::createFromAscii(getSchemeInfo().m_pScheme); } m_aScheme.set(aSynAbsURIRef, aSynScheme, aSynAbsURIRef.getLength()); aSynAbsURIRef.append(sal_Unicode(':')); } sal_Char cEscapePrefix = getEscapePrefix(); sal_uInt32 nSegmentDelimiter = '/'; sal_uInt32 nAltSegmentDelimiter = 0x80000000; bool bSkippedInitialSlash = false; // Parse //;AUTH=@: or // //:@: or // // if (getSchemeInfo().m_bAuthority) { sal_Unicode const * pUserInfoBegin = 0; sal_Unicode const * pUserInfoEnd = 0; sal_Unicode const * pHostPortBegin = 0; sal_Unicode const * pHostPortEnd = 0; switch (m_eScheme) { case INET_PROT_VND_SUN_STAR_HELP: { if (pEnd - pPos < 2 || *pPos++ != '/' || *pPos++ != '/') { setInvalid(); return false; } aSynAbsURIRef.appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); rtl::OUStringBuffer aSynAuthority; while (pPos < pEnd && *pPos != '/' && *pPos != '?' && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynAuthority, nUTF32, eEscapeType, bOctets, PART_AUTHORITY, cEscapePrefix, eCharset, false); } m_aHost.set(aSynAbsURIRef, aSynAuthority.makeStringAndClear(), aSynAbsURIRef.getLength()); // misusing m_aHost to store the authority break; } case INET_PROT_VND_SUN_STAR_HIER: { if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/') { pPos += 2; aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); rtl::OUStringBuffer aSynAuthority; while (pPos < pEnd && *pPos != '/' && *pPos != '?' && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynAuthority, nUTF32, eEscapeType, bOctets, PART_AUTHORITY, cEscapePrefix, eCharset, false); } if (aSynAuthority.getLength() == 0) { setInvalid(); return false; } m_aHost.set(aSynAbsURIRef, aSynAuthority.makeStringAndClear(), aSynAbsURIRef.getLength()); // misusing m_aHost to store the authority } break; } case INET_PROT_VND_SUN_STAR_PKG: { if (pEnd - pPos < 2 || *pPos++ != '/' || *pPos++ != '/') { setInvalid(); return false; } aSynAbsURIRef.appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); rtl::OUStringBuffer aSynAuthority; while (pPos < pEnd && *pPos != '/' && *pPos != '?' && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynAuthority, nUTF32, eEscapeType, bOctets, PART_AUTHORITY, cEscapePrefix, eCharset, false); } if (aSynAuthority.getLength() == 0) { setInvalid(); return false; } m_aHost.set(aSynAbsURIRef, aSynAuthority.makeStringAndClear(), aSynAbsURIRef.getLength()); // misusing m_aHost to store the authority break; } case INET_PROT_FILE: if (bSmart) { // The first of the following seven productions that // matches the rest of the input string (and for which the // appropriate style bit is set in eStyle, if applicable) // determines the used notation. The productions use the // auxiliary rules // // domain = label *("." label) // label = alphanum [*(alphanum / "-") alphanum] // alphanum = ALPHA / DIGIT // IPv6reference = "[" IPv6address "]" // IPv6address = hexpart [":" IPv4address] // IPv4address = 1*3DIGIT 3("." 1*3DIGIT) // hexpart = (hexseq ["::" [hexseq]]) / ("::" [hexseq]) // hexseq = hex4 *(":" hex4) // hex4 = 1*4HEXDIG // path = // UCS4 = // 1st Production (URL): // "//" [domain / IPv6reference] ["/" *path] // ["#" *UCS4] // becomes // "file://" domain "/" *path ["#" *UCS4] if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/') { sal_Unicode const * p1 = pPos + 2; while (p1 != pEnd && *p1 != '/' && *p1 != nFragmentDelimiter) { ++p1; } if (parseHostOrNetBiosName( pPos + 2, p1, bOctets, ENCODE_ALL, RTL_TEXTENCODING_DONTKNOW, true, NULL)) { aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); pHostPortBegin = pPos + 2; pHostPortEnd = p1; pPos = p1; break; } } // 2nd Production (MS IE generated 1; FSYS_DOS only): // "//" ALPHA ":" ["/" *path] ["#" *UCS4] // becomes // "file:///" ALPHA ":" ["/" *path] ["#" *UCS4] // replacing "\" by "/" within <*path> // // 3rd Production (MS IE generated 2; FSYS_DOS only): // "//" ALPHA ":" ["\" *path] ["#" *UCS4] // becomes // "file:///" ALPHA ":" ["/" *path] ["#" *UCS4] // replacing "\" by "/" within <*path> // // 4th Production (misscounted slashes): // "//" *path ["#" *UCS4] // becomes // "file:///" *path ["#" *UCS4] if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/') { aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); pPos += 2; bSkippedInitialSlash = true; if ((eStyle & FSYS_DOS) != 0 && pEnd - pPos >= 2 && INetMIME::isAlpha(pPos[0]) && pPos[1] == ':' && (pEnd - pPos == 2 || pPos[2] == '/' || pPos[2] == '\\')) nAltSegmentDelimiter = '\\'; break; } // 5th Production (Unix): // "/" *path ["#" *UCS4] // becomes // "file:///" *path ["#" *UCS4] if (pPos < pEnd && *pPos == '/') { aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); break; } // 6th Production (UNC; FSYS_DOS only): // "\\" domain ["\" *path] ["#" *UCS4] // becomes // "file://" domain "/" *path ["#" *UCS4] // replacing "\" by "/" within <*path> if (eStyle & FSYS_DOS && pEnd - pPos >= 2 && pPos[0] == '\\' && pPos[1] == '\\') { sal_Unicode const * p1 = pPos + 2; sal_Unicode const * pe = p1; while (pe < pEnd && *pe != '\\' && *pe != nFragmentDelimiter) { ++pe; } if ( parseHostOrNetBiosName( p1, pe, bOctets, ENCODE_ALL, RTL_TEXTENCODING_DONTKNOW, true, NULL) || (scanDomain(p1, pe) > 0 && p1 == pe) ) { aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); pHostPortBegin = pPos + 2; pHostPortEnd = pe; pPos = pe; nSegmentDelimiter = '\\'; break; } } // 7th Production (Unix-like DOS; FSYS_DOS only): // ALPHA ":" ["/" *path] ["#" *UCS4] // becomes // "file:///" ALPHA ":" ["/" *path] ["#" *UCS4] // replacing "\" by "/" within <*path> // // 8th Production (DOS; FSYS_DOS only): // ALPHA ":" ["\" *path] ["#" *UCS4] // becomes // "file:///" ALPHA ":" ["/" *path] ["#" *UCS4] // replacing "\" by "/" within <*path> if (eStyle & FSYS_DOS && pEnd - pPos >= 2 && INetMIME::isAlpha(pPos[0]) && pPos[1] == ':' && (pEnd - pPos == 2 || pPos[2] == '/' || pPos[2] == '\\')) { aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); nAltSegmentDelimiter = '\\'; bSkippedInitialSlash = true; break; } // 9th Production (any): // *path ["#" *UCS4] // becomes // "file:///" *path ["#" *UCS4] // replacing the delimiter by "/" within <*path>. The // delimiter is that character from the set { "/", "\", // ":" } which appears most often in <*path> (if FSYS_UNX // is not among the style bits, "/" is removed from the // set; if FSYS_DOS is not among the style bits, "\" is // removed from the set; if FSYS_MAC is not among the // style bits, ":" is removed from the set). If two or // more characters appear the same number of times, the // character mentioned first in that set is chosen. If // the first character of <*path> is the delimiter, that // character is not copied. if (eStyle & (FSYS_UNX | FSYS_DOS | FSYS_MAC)) { aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); switch (guessFSysStyleByCounting(pPos, pEnd, eStyle)) { case FSYS_UNX: nSegmentDelimiter = '/'; break; case FSYS_DOS: nSegmentDelimiter = '\\'; break; case FSYS_MAC: nSegmentDelimiter = ':'; break; default: DBG_ERROR( "INetURLObject::setAbsURIRef():" " Bad guessFSysStyleByCounting"); break; } bSkippedInitialSlash = pPos != pEnd && *pPos != nSegmentDelimiter; break; } } default: { // For INET_PROT_FILE, allow an empty authority ("//") to be // missing if the following path starts with an explicit "/" // (Java is notorious in generating such file URLs, so be // liberal here): if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/') pPos += 2; else if (!bSmart && !(m_eScheme == INET_PROT_FILE && pPos != pEnd && *pPos == '/')) { setInvalid(); return false; } aSynAbsURIRef.appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); sal_Unicode const * pAuthority = pPos; sal_uInt32 c = getSchemeInfo().m_bQuery ? '?' : 0x80000000; while (pPos < pEnd && *pPos != '/' && *pPos != c && *pPos != nFragmentDelimiter) ++pPos; if (getSchemeInfo().m_bUser) if (getSchemeInfo().m_bHost) { sal_Unicode const * p1 = pAuthority; while (p1 < pPos && *p1 != '@') ++p1; if (p1 == pPos) { pHostPortBegin = pAuthority; pHostPortEnd = pPos; } else { pUserInfoBegin = pAuthority; pUserInfoEnd = p1; pHostPortBegin = p1 + 1; pHostPortEnd = pPos; } } else { pUserInfoBegin = pAuthority; pUserInfoEnd = pPos; } else if (getSchemeInfo().m_bHost) { pHostPortBegin = pAuthority; pHostPortEnd = pPos; } else if (pPos != pAuthority) { setInvalid(); return false; } break; } } if (pUserInfoBegin) { Part ePart = m_eScheme == INET_PROT_IMAP ? PART_IMAP_ACHAR : m_eScheme == INET_PROT_VIM ? PART_VIM : PART_USER_PASSWORD; bool bSupportsPassword = getSchemeInfo().m_bPassword; bool bSupportsAuth = !bSupportsPassword && getSchemeInfo().m_bAuth; bool bHasAuth = false; rtl::OUStringBuffer aSynUser; sal_Unicode const * p1 = pUserInfoBegin; while (p1 < pUserInfoEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p1, pUserInfoEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); if (eEscapeType == ESCAPE_NO) { if (nUTF32 == ':' && bSupportsPassword) { bHasAuth = true; break; } else if (nUTF32 == ';' && bSupportsAuth && pUserInfoEnd - p1 > RTL_CONSTASCII_LENGTH("auth=") && INetMIME::equalIgnoreCase( p1, p1 + RTL_CONSTASCII_LENGTH("auth="), "auth=")) { p1 += RTL_CONSTASCII_LENGTH("auth="); bHasAuth = true; break; } } appendUCS4(aSynUser, nUTF32, eEscapeType, bOctets, ePart, cEscapePrefix, eCharset, false); } m_aUser.set(aSynAbsURIRef, aSynUser.makeStringAndClear(), aSynAbsURIRef.getLength()); if (bHasAuth) { if (bSupportsPassword) { aSynAbsURIRef.append(sal_Unicode(':')); rtl::OUStringBuffer aSynAuth; while (p1 < pUserInfoEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p1, pUserInfoEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynAuth, nUTF32, eEscapeType, bOctets, ePart, cEscapePrefix, eCharset, false); } m_aAuth.set(aSynAbsURIRef, aSynAuth.makeStringAndClear(), aSynAbsURIRef.getLength()); } else { aSynAbsURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM(";AUTH=")); rtl::OUStringBuffer aSynAuth; while (p1 < pUserInfoEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p1, pUserInfoEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); if (!INetMIME::isIMAPAtomChar(nUTF32)) { setInvalid(); return false; } appendUCS4(aSynAuth, nUTF32, eEscapeType, bOctets, ePart, cEscapePrefix, eCharset, false); } m_aAuth.set(aSynAbsURIRef, aSynAuth.makeStringAndClear(), aSynAbsURIRef.getLength()); } } if (pHostPortBegin) aSynAbsURIRef.append(sal_Unicode('@')); } if (pHostPortBegin) { sal_Unicode const * pPort = pHostPortEnd; if ( getSchemeInfo().m_bPort && pHostPortBegin < pHostPortEnd ) { sal_Unicode const * p1 = pHostPortEnd - 1; while (p1 > pHostPortBegin && INetMIME::isDigit(*p1)) --p1; if (*p1 == ':') pPort = p1; } bool bNetBiosName = false; switch (m_eScheme) { case INET_PROT_FILE: // If the host equals "LOCALHOST" (unencoded and ignoring // case), turn it into an empty host: if (INetMIME::equalIgnoreCase(pHostPortBegin, pPort, "localhost")) pHostPortBegin = pPort; bNetBiosName = true; break; case INET_PROT_LDAP: case INET_PROT_SMB: if (pHostPortBegin == pPort && pPort != pHostPortEnd) { setInvalid(); return false; } break; default: if (pHostPortBegin == pPort) { setInvalid(); return false; } break; } rtl::OUStringBuffer aSynHost; if (!parseHostOrNetBiosName( pHostPortBegin, pPort, bOctets, eMechanism, eCharset, bNetBiosName, &aSynHost)) { setInvalid(); return false; } m_aHost.set(aSynAbsURIRef, aSynHost.makeStringAndClear(), aSynAbsURIRef.getLength()); if (pPort != pHostPortEnd) { aSynAbsURIRef.append(sal_Unicode(':')); m_aPort.set(aSynAbsURIRef, rtl::OUString(pPort + 1, pHostPortEnd - (pPort + 1)), aSynAbsURIRef.getLength()); } } } // Parse rtl::OUStringBuffer aSynPath; if (!parsePath(m_eScheme, &pPos, pEnd, bOctets, eMechanism, eCharset, bSkippedInitialSlash, nSegmentDelimiter, nAltSegmentDelimiter, getSchemeInfo().m_bQuery ? '?' : 0x80000000, nFragmentDelimiter, aSynPath)) { setInvalid(); return false; } m_aPath.set(aSynAbsURIRef, aSynPath.makeStringAndClear(), aSynAbsURIRef.getLength()); // Parse ? if (getSchemeInfo().m_bQuery && pPos < pEnd && *pPos == '?') { aSynAbsURIRef.append(sal_Unicode('?')); rtl::OUStringBuffer aSynQuery; for (++pPos; pPos < pEnd && *pPos != nFragmentDelimiter;) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynQuery, nUTF32, eEscapeType, bOctets, PART_URIC, cEscapePrefix, eCharset, true); } m_aQuery.set(aSynAbsURIRef, aSynQuery.makeStringAndClear(), aSynAbsURIRef.getLength()); } // Parse # if (pPos < pEnd && *pPos == nFragmentDelimiter) { aSynAbsURIRef.append(sal_Unicode(nFragmentDelimiter)); rtl::OUStringBuffer aSynFragment; for (++pPos; pPos < pEnd;) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynFragment, nUTF32, eEscapeType, bOctets, PART_URIC, cEscapePrefix, eCharset, true); } m_aFragment.set(aSynAbsURIRef, aSynFragment.makeStringAndClear(), aSynAbsURIRef.getLength()); } if (pPos != pEnd) { setInvalid(); return false; } m_aAbsURIRef = aSynAbsURIRef; return true; } //============================================================================ bool INetURLObject::convertRelToAbs(rtl::OUString const & rTheRelURIRef, bool bOctets, INetURLObject & rTheAbsURIRef, bool & rWasAbsolute, EncodeMechanism eMechanism, rtl_TextEncoding eCharset, bool bIgnoreFragment, bool bSmart, bool bRelativeNonURIs, FSysStyle eStyle) const { sal_Unicode const * p = rTheRelURIRef.getStr(); sal_Unicode const * pEnd = p + rTheRelURIRef.getLength(); sal_Unicode const * pPrefixBegin = p; PrefixInfo const * pPrefix = getPrefix(pPrefixBegin, pEnd); bool hasScheme = pPrefix != 0; if (!hasScheme) { pPrefixBegin = p; hasScheme = parseScheme(&pPrefixBegin, pEnd, '#').getLength() > 0; } sal_uInt32 nSegmentDelimiter = '/'; sal_uInt32 nQueryDelimiter = !bSmart || getSchemeInfo().m_bQuery ? '?' : 0x80000000; sal_uInt32 nFragmentDelimiter = '#'; Part ePart = PART_VISIBLE; if (!hasScheme && bSmart) { // If the input matches any of the following productions (for which // the appropriate style bit is set in eStyle), it is assumed to be an // absolute file system path, rather than a relative URI reference. // (This is only a subset of the productions used for scheme detection // in INetURLObject::setAbsURIRef(), because most of those productions // interfere with the syntax of relative URI references.) The // productions use the auxiliary rules // // domain = label *("." label) // label = alphanum [*(alphanum / "-") alphanum] // alphanum = ALPHA / DIGIT // UCS4 = // // 1st Production (UNC file; FSYS_DOS only): // "\\" domain ["\" *UCS4] // // 2nd Production (Unix-like DOS file; FSYS_DOS only): // ALPHA ":" ["/" *UCS4] // // 3rd Production (DOS file; FSYS_DOS only): // ALPHA ":" ["\" *UCS4] if (eStyle & FSYS_DOS) { bool bFSys = false; sal_Unicode const * q = p; if (pEnd - q >= 2 && INetMIME::isAlpha(q[0]) && q[1] == ':' && (pEnd - q == 2 || q[2] == '/' || q[2] == '\\')) bFSys = true; // 2nd, 3rd else if (pEnd - q >= 2 && q[0] == '\\' && q[1] == '\\') { q += 2; sal_Int32 n = rtl_ustr_indexOfChar_WithLength( q, pEnd - q, '\\'); sal_Unicode const * qe = n == -1 ? pEnd : q + n; if (parseHostOrNetBiosName( q, qe, bOctets, ENCODE_ALL, RTL_TEXTENCODING_DONTKNOW, true, NULL)) { bFSys = true; // 1st } } if (bFSys) { INetURLObject aNewURI; aNewURI.setAbsURIRef(rTheRelURIRef, bOctets, eMechanism, eCharset, true, eStyle); if (!aNewURI.HasError()) { rTheAbsURIRef = aNewURI; rWasAbsolute = true; return true; } } } // When the base URL is a file URL, accept relative file system paths // using "\" or ":" as delimiter (and ignoring URI conventions for "%" // and "#"), as well as relative URIs using "/" as delimiter: if (m_eScheme == INET_PROT_FILE) switch (guessFSysStyleByCounting(p, pEnd, eStyle)) { case FSYS_UNX: nSegmentDelimiter = '/'; break; case FSYS_DOS: nSegmentDelimiter = '\\'; bRelativeNonURIs = true; break; case FSYS_MAC: nSegmentDelimiter = ':'; bRelativeNonURIs = true; break; default: DBG_ERROR("INetURLObject::convertRelToAbs():" " Bad guessFSysStyleByCounting"); break; } if (bRelativeNonURIs) { eMechanism = ENCODE_ALL; nQueryDelimiter = 0x80000000; nFragmentDelimiter = 0x80000000; ePart = PART_VISIBLE_NONSPECIAL; } } // If the relative URI has the same scheme as the base URI, and that // scheme is hierarchical, then ignore its presence in the relative // URI in order to be backward compatible (cf. RFC 2396 section 5.2 // step 3): if (pPrefix && pPrefix->m_eScheme == m_eScheme && getSchemeInfo().m_bHierarchical) { hasScheme = false; while (p != pEnd && *p++ != ':') ; } rWasAbsolute = hasScheme; // Fast solution for non-relative URIs: if (hasScheme) { INetURLObject aNewURI(rTheRelURIRef, eMechanism, eCharset); if (aNewURI.HasError()) { rWasAbsolute = false; return false; } if (bIgnoreFragment) aNewURI.clearFragment(); rTheAbsURIRef = aNewURI; return true; } enum State { STATE_AUTH, STATE_ABS_PATH, STATE_REL_PATH, STATE_FRAGMENT, STATE_DONE }; rtl::OUStringBuffer aSynAbsURIRef; // make sure that the scheme is copied for generic schemes: getSchemeInfo().m_pScheme // is empty ("") in that case, so take the scheme from m_aAbsURIRef if (m_eScheme != INET_PROT_GENERIC) { aSynAbsURIRef.appendAscii(getSchemeInfo().m_pScheme); } else { sal_Unicode const * pSchemeBegin = m_aAbsURIRef.getStr(); sal_Unicode const * pSchemeEnd = pSchemeBegin; while (pSchemeEnd[0] != ':') { ++pSchemeEnd; } aSynAbsURIRef.append(pSchemeBegin, pSchemeEnd - pSchemeBegin); } aSynAbsURIRef.append(sal_Unicode(':')); sal_Char cEscapePrefix = getEscapePrefix(); State eState = STATE_AUTH; bool bSameDoc = true; if (getSchemeInfo().m_bAuthority) { if (pEnd - p >= 2 && p[0] == '/' && p[1] == '/') { aSynAbsURIRef.appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); p += 2; eState = STATE_ABS_PATH; bSameDoc = false; while (p != pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); if (eEscapeType == ESCAPE_NO) { if (nUTF32 == nSegmentDelimiter) break; else if (nUTF32 == nFragmentDelimiter) { eState = STATE_FRAGMENT; break; } } appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, PART_VISIBLE, cEscapePrefix, eCharset, true); } } else { SubString aAuthority(getAuthority()); aSynAbsURIRef.append(m_aAbsURIRef.getStr() + aAuthority.getBegin(), aAuthority.getLength()); } } if (eState == STATE_AUTH) { if (p == pEnd) eState = STATE_DONE; else if (*p == nFragmentDelimiter) { ++p; eState = STATE_FRAGMENT; } else if (*p == nSegmentDelimiter) { ++p; eState = STATE_ABS_PATH; bSameDoc = false; } else { eState = STATE_REL_PATH; bSameDoc = false; } } if (eState == STATE_ABS_PATH) { aSynAbsURIRef.append(sal_Unicode('/')); eState = STATE_DONE; while (p != pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); if (eEscapeType == ESCAPE_NO) { if (nUTF32 == nFragmentDelimiter) { eState = STATE_FRAGMENT; break; } else if (nUTF32 == nSegmentDelimiter) nUTF32 = '/'; } appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, ePart, cEscapePrefix, eCharset, true); } } else if (eState == STATE_REL_PATH) { if (!getSchemeInfo().m_bHierarchical) { // Detect cases where a relative input could not be made absolute // because the given base URL is broken (most probably because it is // empty): OSL_ASSERT(!HasError()); rWasAbsolute = false; return false; } sal_Unicode const * pBasePathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pBasePathEnd = pBasePathBegin + m_aPath.getLength(); while (pBasePathEnd != pBasePathBegin) if (*(--pBasePathEnd) == '/') { ++pBasePathEnd; break; } sal_Int32 nPathBegin = aSynAbsURIRef.getLength(); aSynAbsURIRef.append(pBasePathBegin, pBasePathEnd - pBasePathBegin); DBG_ASSERT(aSynAbsURIRef.getLength() > nPathBegin && aSynAbsURIRef.charAt(aSynAbsURIRef.getLength() - 1) == '/', "INetURLObject::convertRelToAbs(): Bad base path"); while (p != pEnd && *p != nQueryDelimiter && *p != nFragmentDelimiter) { if (*p == '.') { if (pEnd - p == 1 || p[1] == nSegmentDelimiter || p[1] == nQueryDelimiter || p[1] == nFragmentDelimiter) { ++p; if (p != pEnd && *p == nSegmentDelimiter) ++p; continue; } else if (pEnd - p >= 2 && p[1] == '.' && (pEnd - p == 2 || p[2] == nSegmentDelimiter || p[2] == nQueryDelimiter || p[2] == nFragmentDelimiter) && aSynAbsURIRef.getLength() - nPathBegin > 1) { p += 2; if (p != pEnd && *p == nSegmentDelimiter) ++p; sal_Int32 i = aSynAbsURIRef.getLength() - 2; while (i > nPathBegin && aSynAbsURIRef.charAt(i) != '/') --i; aSynAbsURIRef.setLength(i + 1); DBG_ASSERT( aSynAbsURIRef.getLength() > nPathBegin && aSynAbsURIRef.charAt(aSynAbsURIRef.getLength() - 1) == '/', "INetURLObject::convertRelToAbs(): Bad base path"); continue; } } while (p != pEnd && *p != nSegmentDelimiter && *p != nQueryDelimiter && *p != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, ePart, cEscapePrefix, eCharset, true); } if (p != pEnd && *p == nSegmentDelimiter) { aSynAbsURIRef.append(sal_Unicode('/')); ++p; } } while (p != pEnd && *p != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, ePart, cEscapePrefix, eCharset, true); } if (p == pEnd) eState = STATE_DONE; else { ++p; eState = STATE_FRAGMENT; } } else if (bSameDoc) { aSynAbsURIRef.append(m_aAbsURIRef.getStr() + m_aPath.getBegin(), m_aPath.getLength()); if (m_aQuery.isPresent()) aSynAbsURIRef.append(m_aAbsURIRef.getStr() + m_aQuery.getBegin() - 1, m_aQuery.getLength() + 1); } if (eState == STATE_FRAGMENT && !bIgnoreFragment) { aSynAbsURIRef.append(sal_Unicode('#')); while (p != pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, PART_VISIBLE, cEscapePrefix, eCharset, true); } } INetURLObject aNewURI(aSynAbsURIRef.makeStringAndClear()); if (aNewURI.HasError()) { // Detect cases where a relative input could not be made absolute // because the given base URL is broken (most probably because it is // empty): OSL_ASSERT(!HasError()); rWasAbsolute = false; return false; } rTheAbsURIRef = aNewURI; return true; } //============================================================================ bool INetURLObject::convertAbsToRel(rtl::OUString const & rTheAbsURIRef, bool bOctets, rtl::OUString & rTheRelURIRef, EncodeMechanism eEncodeMechanism, DecodeMechanism eDecodeMechanism, rtl_TextEncoding eCharset, FSysStyle eStyle) const { // Check for hierarchical base URL: if (!getSchemeInfo().m_bHierarchical) { rTheRelURIRef = decode(rTheAbsURIRef, getEscapePrefix(CompareProtocolScheme(rTheAbsURIRef)), eDecodeMechanism, eCharset); return false; } // Convert the input (absolute or relative URI ref) to an absolute URI // ref: INetURLObject aSubject; bool bWasAbsolute; if (!convertRelToAbs(rTheAbsURIRef, bOctets, aSubject, bWasAbsolute, eEncodeMechanism, eCharset, false, false, false, eStyle)) { rTheRelURIRef = decode(rTheAbsURIRef, getEscapePrefix(CompareProtocolScheme(rTheAbsURIRef)), eDecodeMechanism, eCharset); return false; } // Check for differing scheme or authority parts: if ((m_aScheme.compare( aSubject.m_aScheme, m_aAbsURIRef, aSubject.m_aAbsURIRef) != 0) || (m_aUser.compare( aSubject.m_aUser, m_aAbsURIRef, aSubject.m_aAbsURIRef) != 0) || (m_aAuth.compare( aSubject.m_aAuth, m_aAbsURIRef, aSubject.m_aAbsURIRef) != 0) || (m_aHost.compare( aSubject.m_aHost, m_aAbsURIRef, aSubject.m_aAbsURIRef) != 0) || (m_aPort.compare( aSubject.m_aPort, m_aAbsURIRef, aSubject.m_aAbsURIRef) != 0)) { rTheRelURIRef = aSubject.GetMainURL(eDecodeMechanism, eCharset); return false; } sal_Unicode const * pBasePathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pBasePathEnd = pBasePathBegin + m_aPath.getLength(); sal_Unicode const * pSubjectPathBegin = aSubject.m_aAbsURIRef.getStr() + aSubject.m_aPath.getBegin(); sal_Unicode const * pSubjectPathEnd = pSubjectPathBegin + aSubject.m_aPath.getLength(); // Make nMatch point past the last matching slash, or past the end of the // paths, in case they are equal: sal_Unicode const * pSlash = 0; sal_Unicode const * p1 = pBasePathBegin; sal_Unicode const * p2 = pSubjectPathBegin; for (;;) { if (p1 == pBasePathEnd || p2 == pSubjectPathEnd) { if (p1 == pBasePathEnd && p2 == pSubjectPathEnd) pSlash = p1; break; } sal_Unicode c = *p1++; if (c != *p2++) break; if (c == '/') pSlash = p1; } if (!pSlash) { // One of the paths does not start with '/': rTheRelURIRef = aSubject.GetMainURL(eDecodeMechanism, eCharset); return false; } sal_Int32 nMatch = pSlash - pBasePathBegin; // If the two URLs are DOS file URLs starting with different volumes // (e.g., file:///a:/... and file:///b:/...), the subject is not made // relative (it could be, but some people do not like that): if (m_eScheme == INET_PROT_FILE && nMatch <= 1 && hasDosVolume(eStyle) && aSubject.hasDosVolume(eStyle)) //TODO! ok to use eStyle for these? { rTheRelURIRef = aSubject.GetMainURL(eDecodeMechanism, eCharset); return false; } // For every slash in the base path after nMatch, a prefix of "../" is // added to the new relative URL (if the common prefix of the two paths is // only "/"---but see handling of file URLs above---, the complete subject // path could go into the new relative URL instead, but some people don't // like that): rtl::OUStringBuffer aSynRelURIRef; // if (nMatch <= 1) nMatch = 0; else // see comment above for (sal_Unicode const * p = pBasePathBegin + nMatch; p != pBasePathEnd; ++p) { if (*p == '/') aSynRelURIRef.appendAscii(RTL_CONSTASCII_STRINGPARAM("../")); } // If the new relative URL would start with "//" (i.e., it would be // mistaken for a relative URL starting with an authority part), or if the // new relative URL would neither be empty nor start with <"/"> nor start // with <1*rseg> (i.e., it could be mistaken for an absolute URL starting // with a scheme part), then the new relative URL is prefixed with "./": if (aSynRelURIRef.getLength() == 0) { if (pSubjectPathEnd - pSubjectPathBegin >= nMatch + 2 && pSubjectPathBegin[nMatch] == '/' && pSubjectPathBegin[nMatch + 1] == '/') { aSynRelURIRef.appendAscii(RTL_CONSTASCII_STRINGPARAM("./")); } else { for (sal_Unicode const * p = pSubjectPathBegin + nMatch; p != pSubjectPathEnd && *p != '/'; ++p) { if (mustEncode(*p, PART_REL_SEGMENT_EXTRA)) { aSynRelURIRef. appendAscii(RTL_CONSTASCII_STRINGPARAM("./")); break; } } } } // The remainder of the subject path, starting at nMatch, is appended to // the new relative URL: sal_Char cEscapePrefix = getEscapePrefix(); aSynRelURIRef.append(decode(pSubjectPathBegin + nMatch, pSubjectPathEnd, cEscapePrefix, eDecodeMechanism, eCharset)); // If the subject has defined query or fragment parts, they are appended // to the new relative URL: if (aSubject.m_aQuery.isPresent()) { aSynRelURIRef.append(sal_Unicode('?')); aSynRelURIRef.append(aSubject.decode(aSubject.m_aQuery, cEscapePrefix, eDecodeMechanism, eCharset)); } if (aSubject.m_aFragment.isPresent()) { aSynRelURIRef.append(sal_Unicode('#')); aSynRelURIRef.append(aSubject.decode(aSubject.m_aFragment, cEscapePrefix, eDecodeMechanism, eCharset)); } rTheRelURIRef = aSynRelURIRef.makeStringAndClear(); return true; } //============================================================================ // static bool INetURLObject::convertIntToExt(rtl::OUString const & rTheIntURIRef, bool bOctets, rtl::OUString & rTheExtURIRef, DecodeMechanism eDecodeMechanism, rtl_TextEncoding eCharset) { sal_Char cEscapePrefix = getEscapePrefix(CompareProtocolScheme(rTheIntURIRef)); rtl::OUString aSynExtURIRef(encodeText(rTheIntURIRef, bOctets, PART_VISIBLE, cEscapePrefix, NOT_CANONIC, eCharset, true)); sal_Unicode const * pBegin = aSynExtURIRef.getStr(); sal_Unicode const * pEnd = pBegin + aSynExtURIRef.getLength(); sal_Unicode const * p = pBegin; PrefixInfo const * pPrefix = getPrefix(p, pEnd); bool bConvert = pPrefix && pPrefix->m_eKind == PrefixInfo::INTERNAL; if (bConvert) { aSynExtURIRef = aSynExtURIRef.replaceAt(0, p - pBegin, rtl::OUString::createFromAscii(pPrefix->m_pTranslatedPrefix)); } rTheExtURIRef = decode(aSynExtURIRef, cEscapePrefix, eDecodeMechanism, eCharset); return bConvert; } //============================================================================ // static bool INetURLObject::convertExtToInt(rtl::OUString const & rTheExtURIRef, bool bOctets, rtl::OUString & rTheIntURIRef, DecodeMechanism eDecodeMechanism, rtl_TextEncoding eCharset) { sal_Char cEscapePrefix = getEscapePrefix(CompareProtocolScheme(rTheExtURIRef)); rtl::OUString aSynIntURIRef(encodeText(rTheExtURIRef, bOctets, PART_VISIBLE, cEscapePrefix, NOT_CANONIC, eCharset, true)); sal_Unicode const * pBegin = aSynIntURIRef.getStr(); sal_Unicode const * pEnd = pBegin + aSynIntURIRef.getLength(); sal_Unicode const * p = pBegin; PrefixInfo const * pPrefix = getPrefix(p, pEnd); bool bConvert = pPrefix && pPrefix->m_eKind == PrefixInfo::EXTERNAL; if (bConvert) { aSynIntURIRef = aSynIntURIRef.replaceAt(0, p - pBegin, rtl::OUString::createFromAscii(pPrefix->m_pTranslatedPrefix)); } rTheIntURIRef = decode(aSynIntURIRef, cEscapePrefix, eDecodeMechanism, eCharset); return bConvert; } //============================================================================ // static INetURLObject::PrefixInfo const * INetURLObject::getPrefix(sal_Unicode const *& rBegin, sal_Unicode const * pEnd) { static PrefixInfo const aMap[] = { // dummy entry at front needed, because pLast may point here: { 0, 0, INET_PROT_NOT_VALID, PrefixInfo::INTERNAL }, { ".component:", "staroffice.component:", INET_PROT_COMPONENT, PrefixInfo::INTERNAL }, { ".uno:", "staroffice.uno:", INET_PROT_UNO, PrefixInfo::INTERNAL }, { "cid:", 0, INET_PROT_CID, PrefixInfo::OFFICIAL }, { "data:", 0, INET_PROT_DATA, PrefixInfo::OFFICIAL }, { "db:", "staroffice.db:", INET_PROT_DB, PrefixInfo::INTERNAL }, { "file:", 0, INET_PROT_FILE, PrefixInfo::OFFICIAL }, { "ftp:", 0, INET_PROT_FTP, PrefixInfo::OFFICIAL }, { "hid:", "staroffice.hid:", INET_PROT_HID, PrefixInfo::INTERNAL }, { "http:", 0, INET_PROT_HTTP, PrefixInfo::OFFICIAL }, { "https:", 0, INET_PROT_HTTPS, PrefixInfo::OFFICIAL }, { "imap:", 0, INET_PROT_IMAP, PrefixInfo::OFFICIAL }, { "javascript:", 0, INET_PROT_JAVASCRIPT, PrefixInfo::OFFICIAL }, { "ldap:", 0, INET_PROT_LDAP, PrefixInfo::OFFICIAL }, { "macro:", "staroffice.macro:", INET_PROT_MACRO, PrefixInfo::INTERNAL }, { "mailto:", 0, INET_PROT_MAILTO, PrefixInfo::OFFICIAL }, { "news:", 0, INET_PROT_NEWS, PrefixInfo::OFFICIAL }, { "out:", "staroffice.out:", INET_PROT_OUT, PrefixInfo::INTERNAL }, { "pop3:", "staroffice.pop3:", INET_PROT_POP3, PrefixInfo::INTERNAL }, { "private:", "staroffice.private:", INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, { "private:factory/", "staroffice.factory:", INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, { "private:helpid/", "staroffice.helpid:", INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, { "private:java/", "staroffice.java:", INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, { "private:searchfolder:", "staroffice.searchfolder:", INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, { "private:trashcan:", "staroffice.trashcan:", INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, { "slot:", "staroffice.slot:", INET_PROT_SLOT, PrefixInfo::INTERNAL }, { "smb:", 0, INET_PROT_SMB, PrefixInfo::OFFICIAL }, { "staroffice.component:", ".component:", INET_PROT_COMPONENT, PrefixInfo::EXTERNAL }, { "staroffice.db:", "db:", INET_PROT_DB, PrefixInfo::EXTERNAL }, { "staroffice.factory:", "private:factory/", INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, { "staroffice.helpid:", "private:helpid/", INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, { "staroffice.hid:", "hid:", INET_PROT_HID, PrefixInfo::EXTERNAL }, { "staroffice.java:", "private:java/", INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, { "staroffice.macro:", "macro:", INET_PROT_MACRO, PrefixInfo::EXTERNAL }, { "staroffice.out:", "out:", INET_PROT_OUT, PrefixInfo::EXTERNAL }, { "staroffice.pop3:", "pop3:", INET_PROT_POP3, PrefixInfo::EXTERNAL }, { "staroffice.private:", "private:", INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, { "staroffice.searchfolder:", "private:searchfolder:", INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, { "staroffice.slot:", "slot:", INET_PROT_SLOT, PrefixInfo::EXTERNAL }, { "staroffice.trashcan:", "private:trashcan:", INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, { "staroffice.uno:", ".uno:", INET_PROT_UNO, PrefixInfo::EXTERNAL }, { "staroffice.vim:", "vim:", INET_PROT_VIM, PrefixInfo::EXTERNAL }, { "staroffice:", "private:", INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, { "telnet:", 0, INET_PROT_TELNET, PrefixInfo::OFFICIAL }, { "vim:", "staroffice.vim:", INET_PROT_VIM, PrefixInfo::INTERNAL }, { "vnd.sun.star.cmd:", 0, INET_PROT_VND_SUN_STAR_CMD, PrefixInfo::OFFICIAL }, { "vnd.sun.star.expand:", 0, INET_PROT_VND_SUN_STAR_EXPAND, PrefixInfo::OFFICIAL }, { "vnd.sun.star.help:", 0, INET_PROT_VND_SUN_STAR_HELP, PrefixInfo::OFFICIAL }, { "vnd.sun.star.hier:", 0, INET_PROT_VND_SUN_STAR_HIER, PrefixInfo::OFFICIAL }, { "vnd.sun.star.odma:", 0, INET_PROT_VND_SUN_STAR_ODMA, PrefixInfo::OFFICIAL }, { "vnd.sun.star.pkg:", 0, INET_PROT_VND_SUN_STAR_PKG, PrefixInfo::OFFICIAL }, { "vnd.sun.star.tdoc:", 0, INET_PROT_VND_SUN_STAR_TDOC, PrefixInfo::OFFICIAL }, { "vnd.sun.star.webdav:", 0, INET_PROT_VND_SUN_STAR_WEBDAV, PrefixInfo::OFFICIAL } }; PrefixInfo const * pFirst = aMap + 1; PrefixInfo const * pLast = aMap + sizeof aMap / sizeof (PrefixInfo) - 1; PrefixInfo const * pMatch = 0; sal_Unicode const * pMatched = rBegin; sal_Unicode const * p = rBegin; sal_Int32 i = 0; for (; pFirst < pLast; ++i) { if (pFirst->m_pPrefix[i] == '\0') { pMatch = pFirst++; pMatched = p; } if (p >= pEnd) break; sal_uInt32 nChar = INetMIME::toLowerCase(*p++); while (pFirst <= pLast && sal_uChar(pFirst->m_pPrefix[i]) < nChar) ++pFirst; while (pFirst <= pLast && sal_uChar(pLast->m_pPrefix[i]) > nChar) --pLast; } if (pFirst == pLast) { sal_Char const * q = pFirst->m_pPrefix + i; while (p < pEnd && *q != '\0' && INetMIME::toLowerCase(*p) == sal_uChar(*q)) { ++p; ++q; } if (*q == '\0') { rBegin = p; return pFirst; } } rBegin = pMatched; return pMatch; } //============================================================================ sal_Int32 INetURLObject::getAuthorityBegin() const { DBG_ASSERT(getSchemeInfo().m_bAuthority, "INetURLObject::getAuthority(): Bad scheme"); sal_Int32 nBegin; if (m_aUser.isPresent()) nBegin = m_aUser.getBegin(); else if (m_aHost.isPresent()) nBegin = m_aHost.getBegin(); else nBegin = m_aPath.getBegin(); nBegin -= RTL_CONSTASCII_LENGTH("//"); DBG_ASSERT(m_aAbsURIRef.charAt(nBegin) == '/' && m_aAbsURIRef.charAt(nBegin + 1) == '/', "INetURLObject::getAuthority(): Bad authority"); return nBegin; } //============================================================================ INetURLObject::SubString INetURLObject::getAuthority() const { sal_Int32 nBegin = getAuthorityBegin(); sal_Int32 nEnd = m_aPort.isPresent() ? m_aPort.getEnd() : m_aHost.isPresent() ? m_aHost.getEnd() : m_aAuth.isPresent() ? m_aAuth.getEnd() : m_aUser.isPresent() ? m_aUser.getEnd() : nBegin + RTL_CONSTASCII_LENGTH("//"); return SubString(nBegin, nEnd - nBegin); } //============================================================================ bool INetURLObject::setUser(rtl::OUString const & rTheUser, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { if ( !getSchemeInfo().m_bUser || (m_eScheme == INET_PROT_IMAP && rTheUser.getLength() == 0) ) { return false; } rtl::OUString aNewUser(encodeText(rTheUser, bOctets, m_eScheme == INET_PROT_IMAP ? PART_IMAP_ACHAR : m_eScheme == INET_PROT_VIM ? PART_VIM : PART_USER_PASSWORD, getEscapePrefix(), eMechanism, eCharset, false)); sal_Int32 nDelta; if (m_aUser.isPresent()) nDelta = m_aUser.set(m_aAbsURIRef, aNewUser); else if (m_aHost.isPresent()) { m_aAbsURIRef.insert(m_aHost.getBegin(), sal_Unicode('@')); nDelta = m_aUser.set(m_aAbsURIRef, aNewUser, m_aHost.getBegin()) + 1; } else if (getSchemeInfo().m_bHost) return false; else nDelta = m_aUser.set(m_aAbsURIRef, aNewUser, m_aPath.getBegin()); m_aAuth += nDelta; m_aHost += nDelta; m_aPort += nDelta; m_aPath += nDelta; m_aQuery += nDelta; m_aFragment += nDelta; return true; } namespace { void lcl_Erase(rtl::OUStringBuffer &rBuf, sal_Int32 index, sal_Int32 count) { rtl::OUString sTemp(rBuf.makeStringAndClear()); rBuf.append(sTemp.replaceAt(index, count, rtl::OUString())); } } //============================================================================ bool INetURLObject::clearPassword() { if (!getSchemeInfo().m_bPassword) return false; if (m_aAuth.isPresent()) { lcl_Erase(m_aAbsURIRef, m_aAuth.getBegin() - 1, m_aAuth.getLength() + 1); sal_Int32 nDelta = m_aAuth.clear() - 1; m_aHost += nDelta; m_aPort += nDelta; m_aPath += nDelta; m_aQuery += nDelta; m_aFragment += nDelta; } return true; } //============================================================================ bool INetURLObject::setPassword(rtl::OUString const & rThePassword, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { if (!getSchemeInfo().m_bPassword) return false; rtl::OUString aNewAuth(encodeText(rThePassword, bOctets, m_eScheme == INET_PROT_VIM ? PART_VIM : PART_USER_PASSWORD, getEscapePrefix(), eMechanism, eCharset, false)); sal_Int32 nDelta; if (m_aAuth.isPresent()) nDelta = m_aAuth.set(m_aAbsURIRef, aNewAuth); else if (m_aUser.isPresent()) { m_aAbsURIRef.insert(m_aUser.getEnd(), sal_Unicode(':')); nDelta = m_aAuth.set(m_aAbsURIRef, aNewAuth, m_aUser.getEnd() + 1) + 1; } else if (m_aHost.isPresent()) { m_aAbsURIRef.insert(m_aHost.getBegin(), rtl::OUString::createFromAscii(":@")); m_aUser.set(m_aAbsURIRef, rtl::OUString(), m_aHost.getBegin()); nDelta = m_aAuth.set(m_aAbsURIRef, aNewAuth, m_aHost.getBegin() + 1) + 2; } else if (getSchemeInfo().m_bHost) return false; else { m_aAbsURIRef.insert(m_aPath.getBegin(), sal_Unicode(':')); m_aUser.set(m_aAbsURIRef, rtl::OUString(), m_aPath.getBegin()); nDelta = m_aAuth.set(m_aAbsURIRef, aNewAuth, m_aPath.getBegin() + 1) + 1; } m_aHost += nDelta; m_aPort += nDelta; m_aPath += nDelta; m_aQuery += nDelta; m_aFragment += nDelta; return true; } //============================================================================ // static bool INetURLObject::parseHost( sal_Unicode const *& rBegin, sal_Unicode const * pEnd, rtl::OUString & rCanonic) { // RFC 2373 is inconsistent about how to write an IPv6 address in which an // IPv4 address directly follows the abbreviating "::". The ABNF in // Appendix B suggests ":::13.1.68.3", while an example in 2.2/3 explicitly // mentions "::13:1.68.3". This algorithm accepts both variants: enum State { STATE_INITIAL, STATE_LABEL, STATE_LABEL_HYPHEN, STATE_LABEL_DOT, STATE_TOPLABEL, STATE_TOPLABEL_HYPHEN, STATE_TOPLABEL_DOT, STATE_IP4, STATE_IP4_DOT, STATE_IP6, STATE_IP6_COLON, STATE_IP6_2COLON, STATE_IP6_3COLON, STATE_IP6_HEXSEQ1, STATE_IP6_HEXSEQ1_COLON, STATE_IP6_HEXSEQ1_MAYBE_IP4, STATE_IP6_HEXSEQ2, STATE_IP6_HEXSEQ2_COLON, STATE_IP6_HEXSEQ2_MAYBE_IP4, STATE_IP6_IP4, STATE_IP6_IP4_DOT, STATE_IP6_DONE }; rtl::OUStringBuffer aTheCanonic; sal_uInt32 nNumber = 0; int nDigits = 0; int nOctets = 0; State eState = STATE_INITIAL; sal_Unicode const * p = rBegin; for (; p != pEnd; ++p) switch (eState) { case STATE_INITIAL: if (*p == '[') { aTheCanonic.append(sal_Unicode('[')); eState = STATE_IP6; } else if (INetMIME::isAlpha(*p)) eState = STATE_TOPLABEL; else if (INetMIME::isDigit(*p)) { nNumber = INetMIME::getWeight(*p); nDigits = 1; nOctets = 1; eState = STATE_IP4; } else goto done; break; case STATE_LABEL: if (*p == '.') eState = STATE_LABEL_DOT; else if (*p == '-') eState = STATE_LABEL_HYPHEN; else if (!INetMIME::isAlphanumeric(*p)) goto done; break; case STATE_LABEL_HYPHEN: if (INetMIME::isAlphanumeric(*p)) eState = STATE_LABEL; else if (*p != '-') goto done; break; case STATE_LABEL_DOT: if (INetMIME::isAlpha(*p)) eState = STATE_TOPLABEL; else if (INetMIME::isDigit(*p)) eState = STATE_LABEL; else goto done; break; case STATE_TOPLABEL: if (*p == '.') eState = STATE_TOPLABEL_DOT; else if (*p == '-') eState = STATE_TOPLABEL_HYPHEN; else if (!INetMIME::isAlphanumeric(*p)) goto done; break; case STATE_TOPLABEL_HYPHEN: if (INetMIME::isAlphanumeric(*p)) eState = STATE_TOPLABEL; else if (*p != '-') goto done; break; case STATE_TOPLABEL_DOT: if (INetMIME::isAlpha(*p)) eState = STATE_TOPLABEL; else if (INetMIME::isDigit(*p)) eState = STATE_LABEL; else goto done; break; case STATE_IP4: if (*p == '.') if (nOctets < 4) { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber))); aTheCanonic.append(sal_Unicode('.')); ++nOctets; eState = STATE_IP4_DOT; } else eState = STATE_LABEL_DOT; else if (*p == '-') eState = STATE_LABEL_HYPHEN; else if (INetMIME::isAlpha(*p)) eState = STATE_LABEL; else if (INetMIME::isDigit(*p)) if (nDigits < 3) { nNumber = 10 * nNumber + INetMIME::getWeight(*p); ++nDigits; } else eState = STATE_LABEL; else goto done; break; case STATE_IP4_DOT: if (INetMIME::isAlpha(*p)) eState = STATE_TOPLABEL; else if (INetMIME::isDigit(*p)) { nNumber = INetMIME::getWeight(*p); nDigits = 1; eState = STATE_IP4; } else goto done; break; case STATE_IP6: if (*p == ':') eState = STATE_IP6_COLON; else if (INetMIME::isHexDigit(*p)) { nNumber = INetMIME::getHexWeight(*p); nDigits = 1; eState = STATE_IP6_HEXSEQ1; } else goto done; break; case STATE_IP6_COLON: if (*p == ':') { aTheCanonic.appendAscii(RTL_CONSTASCII_STRINGPARAM("::")); eState = STATE_IP6_2COLON; } else goto done; break; case STATE_IP6_2COLON: if (*p == ']') eState = STATE_IP6_DONE; else if (*p == ':') { aTheCanonic.append(sal_Unicode(':')); eState = STATE_IP6_3COLON; } else if (INetMIME::isDigit(*p)) { nNumber = INetMIME::getWeight(*p); nDigits = 1; eState = STATE_IP6_HEXSEQ2_MAYBE_IP4; } else if (INetMIME::isHexDigit(*p)) { nNumber = INetMIME::getHexWeight(*p); nDigits = 1; eState = STATE_IP6_HEXSEQ2; } else goto done; break; case STATE_IP6_3COLON: if (INetMIME::isDigit(*p)) { nNumber = INetMIME::getWeight(*p); nDigits = 1; nOctets = 1; eState = STATE_IP6_IP4; } else goto done; break; case STATE_IP6_HEXSEQ1: if (*p == ']') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); eState = STATE_IP6_DONE; } else if (*p == ':') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); aTheCanonic.append(sal_Unicode(':')); eState = STATE_IP6_HEXSEQ1_COLON; } else if (INetMIME::isHexDigit(*p) && nDigits < 4) { nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); ++nDigits; } else goto done; break; case STATE_IP6_HEXSEQ1_COLON: if (*p == ':') { aTheCanonic.append(sal_Unicode(':')); eState = STATE_IP6_2COLON; } else if (INetMIME::isDigit(*p)) { nNumber = INetMIME::getWeight(*p); nDigits = 1; eState = STATE_IP6_HEXSEQ1_MAYBE_IP4; } else if (INetMIME::isHexDigit(*p)) { nNumber = INetMIME::getHexWeight(*p); nDigits = 1; eState = STATE_IP6_HEXSEQ1; } else goto done; break; case STATE_IP6_HEXSEQ1_MAYBE_IP4: if (*p == ']') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); eState = STATE_IP6_DONE; } else if (*p == ':') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); aTheCanonic.append(sal_Unicode(':')); eState = STATE_IP6_HEXSEQ1_COLON; } else if (*p == '.') { nNumber = 100 * (nNumber >> 8) + 10 * (nNumber >> 4 & 15) + (nNumber & 15); aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber))); aTheCanonic.append(sal_Unicode('.')); nOctets = 2; eState = STATE_IP6_IP4_DOT; } else if (INetMIME::isDigit(*p) && nDigits < 3) { nNumber = 16 * nNumber + INetMIME::getWeight(*p); ++nDigits; } else if (INetMIME::isHexDigit(*p) && nDigits < 4) { nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); ++nDigits; eState = STATE_IP6_HEXSEQ1; } else goto done; break; case STATE_IP6_HEXSEQ2: if (*p == ']') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); eState = STATE_IP6_DONE; } else if (*p == ':') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); aTheCanonic.append(sal_Unicode(':')); eState = STATE_IP6_HEXSEQ2_COLON; } else if (INetMIME::isHexDigit(*p) && nDigits < 4) { nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); ++nDigits; } else goto done; break; case STATE_IP6_HEXSEQ2_COLON: if (INetMIME::isDigit(*p)) { nNumber = INetMIME::getWeight(*p); nDigits = 1; eState = STATE_IP6_HEXSEQ2_MAYBE_IP4; } else if (INetMIME::isHexDigit(*p)) { nNumber = INetMIME::getHexWeight(*p); nDigits = 1; eState = STATE_IP6_HEXSEQ2; } else goto done; break; case STATE_IP6_HEXSEQ2_MAYBE_IP4: if (*p == ']') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); eState = STATE_IP6_DONE; } else if (*p == ':') { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber), 16)); aTheCanonic.append(sal_Unicode(':')); eState = STATE_IP6_HEXSEQ2_COLON; } else if (*p == '.') { nNumber = 100 * (nNumber >> 8) + 10 * (nNumber >> 4 & 15) + (nNumber & 15); aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber))); aTheCanonic.append(sal_Unicode('.')); nOctets = 2; eState = STATE_IP6_IP4_DOT; } else if (INetMIME::isDigit(*p) && nDigits < 3) { nNumber = 16 * nNumber + INetMIME::getWeight(*p); ++nDigits; } else if (INetMIME::isHexDigit(*p) && nDigits < 4) { nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); ++nDigits; eState = STATE_IP6_HEXSEQ2; } else goto done; break; case STATE_IP6_IP4: if (*p == ']') if (nOctets == 4) { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber))); eState = STATE_IP6_DONE; } else goto done; else if (*p == '.') if (nOctets < 4) { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber))); aTheCanonic.append(sal_Unicode('.')); ++nOctets; eState = STATE_IP6_IP4_DOT; } else goto done; else if (INetMIME::isDigit(*p) && nDigits < 3) { nNumber = 10 * nNumber + INetMIME::getWeight(*p); ++nDigits; } else goto done; break; case STATE_IP6_IP4_DOT: if (INetMIME::isDigit(*p)) { nNumber = INetMIME::getWeight(*p); nDigits = 1; eState = STATE_IP6_IP4; } else goto done; break; case STATE_IP6_DONE: goto done; } done: switch (eState) { case STATE_LABEL: case STATE_TOPLABEL: case STATE_TOPLABEL_DOT: aTheCanonic.setLength(0); aTheCanonic.append(rBegin, p - rBegin); rBegin = p; rCanonic = aTheCanonic.makeStringAndClear(); return true; case STATE_IP4: if (nOctets == 4) { aTheCanonic.append( rtl::OUString::valueOf(sal_Int32(nNumber))); rBegin = p; rCanonic = aTheCanonic.makeStringAndClear(); return true; } return false; case STATE_IP6_DONE: aTheCanonic.append(sal_Unicode(']')); rBegin = p; rCanonic = aTheCanonic.makeStringAndClear(); return true; default: return false; } } //============================================================================ // static bool INetURLObject::parseHostOrNetBiosName( sal_Unicode const * pBegin, sal_Unicode const * pEnd, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset, bool bNetBiosName, rtl::OUStringBuffer* pCanonic) { rtl::OUString aTheCanonic; if (pBegin < pEnd) { sal_Unicode const * p = pBegin; if (!parseHost(p, pEnd, aTheCanonic) || p != pEnd) { if (bNetBiosName) { rtl::OUStringBuffer buf; while (pBegin < pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pBegin, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); if (!INetMIME::isVisible(nUTF32)) return false; if (!INetMIME::isAlphanumeric(nUTF32)) switch (nUTF32) { case '"': case '*': case '+': case ',': case '/': case ':': case ';': case '<': case '=': case '>': case '?': case '[': case '\\': case ']': case '`': case '|': return false;; } if (pCanonic != NULL) { appendUCS4( buf, nUTF32, eEscapeType, bOctets, PART_URIC, '%', eCharset, true); } } aTheCanonic = buf.makeStringAndClear(); } else return false; } } if (pCanonic != NULL) { *pCanonic = aTheCanonic; } return true; } //============================================================================ // static rtl::OUString INetURLObject::encodeHostPort(rtl::OUString const & rTheHostPort, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { sal_Int32 nPort = rTheHostPort.getLength(); if (nPort != 0) { sal_Int32 i = nPort - 1; while (i != 0 && INetMIME::isDigit(rTheHostPort.getStr()[i])) --i; if (rTheHostPort.getStr()[i] == ':') nPort = i; } rtl::OUString aResult(encodeText(rTheHostPort.copy(0, nPort), bOctets, PART_HOST_EXTRA, '%', eMechanism, eCharset, true)); aResult += rTheHostPort.copy(nPort); return aResult; } //============================================================================ bool INetURLObject::setHost(rtl::OUString const & rTheHost, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { if (!getSchemeInfo().m_bHost) return false; rtl::OUStringBuffer aSynHost(rTheHost); bool bNetBiosName = false; switch (m_eScheme) { case INET_PROT_FILE: { rtl::OUString sTemp(aSynHost); if (sTemp.equalsIgnoreAsciiCaseAsciiL( RTL_CONSTASCII_STRINGPARAM("localhost"))) { aSynHost.setLength(0); } bNetBiosName = true; } break; case INET_PROT_LDAP: if (aSynHost.getLength() == 0 && m_aPort.isPresent()) return false; break; default: if (aSynHost.getLength() == 0) return false; break; } if (!parseHostOrNetBiosName( aSynHost.getStr(), aSynHost.getStr() + aSynHost.getLength(), bOctets, eMechanism, eCharset, bNetBiosName, &aSynHost)) return false; sal_Int32 nDelta = m_aHost.set(m_aAbsURIRef, aSynHost.makeStringAndClear()); m_aPort += nDelta; m_aPath += nDelta; m_aQuery += nDelta; m_aFragment += nDelta; return true; } //============================================================================ // static bool INetURLObject::parsePath(INetProtocol eScheme, sal_Unicode const ** pBegin, sal_Unicode const * pEnd, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset, bool bSkippedInitialSlash, sal_uInt32 nSegmentDelimiter, sal_uInt32 nAltSegmentDelimiter, sal_uInt32 nQueryDelimiter, sal_uInt32 nFragmentDelimiter, rtl::OUStringBuffer &rSynPath) { DBG_ASSERT(pBegin, "INetURLObject::parsePath(): Null output param"); sal_Unicode const * pPos = *pBegin; rtl::OUStringBuffer aTheSynPath; switch (eScheme) { case INET_PROT_NOT_VALID: return false; case INET_PROT_FTP: case INET_PROT_IMAP: if (pPos < pEnd && *pPos != '/') return false; while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_HTTP_PATH, '%', eCharset, true); } if (aTheSynPath.getLength() == 0) aTheSynPath.append(sal_Unicode('/')); break; case INET_PROT_HTTP: case INET_PROT_VND_SUN_STAR_WEBDAV: case INET_PROT_HTTPS: case INET_PROT_SMB: if (pPos < pEnd && *pPos != '/') return false; while (pPos < pEnd && *pPos != nQueryDelimiter && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_HTTP_PATH, '%', eCharset, true); } if (aTheSynPath.getLength() == 0) aTheSynPath.append(sal_Unicode('/')); break; case INET_PROT_FILE: { if (bSkippedInitialSlash) aTheSynPath.append(sal_Unicode('/')); else if (pPos < pEnd && *pPos != nSegmentDelimiter && *pPos != nAltSegmentDelimiter) return false; while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); if (eEscapeType == ESCAPE_NO) { if (nUTF32 == nSegmentDelimiter || nUTF32 == nAltSegmentDelimiter) { aTheSynPath.append(sal_Unicode('/')); continue; } else if (nUTF32 == '|' && (pPos == pEnd || *pPos == nFragmentDelimiter || *pPos == nSegmentDelimiter || *pPos == nAltSegmentDelimiter) && aTheSynPath.getLength() == 2 && INetMIME::isAlpha(aTheSynPath.charAt(1))) { // A first segment of is translated to // : aTheSynPath.append(sal_Unicode(':')); continue; } } appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_PCHAR, '%', eCharset, true); } if (aTheSynPath.getLength() == 0) aTheSynPath.append(sal_Unicode('/')); break; } case INET_PROT_MAILTO: while (pPos < pEnd && *pPos != nQueryDelimiter && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_MAILTO, '%', eCharset, true); } break; case INET_PROT_NEWS: if (pPos == pEnd || *pPos == nQueryDelimiter || *pPos == nFragmentDelimiter) return false; // Match <"*">: if (*pPos == '*' && (pEnd - pPos == 1 || pPos[1] == nQueryDelimiter || pPos[1] == nFragmentDelimiter)) { ++pPos; aTheSynPath.append(sal_Unicode('*')); break; } // Match : if (INetMIME::isAlpha(*pPos)) for (sal_Unicode const * p = pPos + 1;; ++p) if (p == pEnd || *p == nQueryDelimiter || *p == nFragmentDelimiter) { aTheSynPath.setLength(0); aTheSynPath.append(pPos, p - pPos); pPos = p; goto done; } else if (!INetMIME::isAlphanumeric(*p) && *p != '+' && *p != '-' && *p != '.' && *p != '_') break; // Match
: for (;;) { if (pPos == pEnd || *pPos == nQueryDelimiter || *pPos == nFragmentDelimiter) return false; if (*pPos == '@') break; EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_NEWS_ARTICLE_LOCALPART, '%', eCharset, true); } if (aTheSynPath.getLength() == 0) return false; ++pPos; aTheSynPath.append(sal_Unicode('@')); { sal_Unicode const * p = pPos; while (p < pEnd && *pPos != nQueryDelimiter && *pPos != nFragmentDelimiter) ++p; rtl::OUString aCanonic; if (!parseHost(pPos, p, aCanonic)) return false; aTheSynPath.append(aCanonic); } done: break; case INET_PROT_POP3: while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_MESSAGE_ID_PATH, '%', eCharset, true); } break; case INET_PROT_PRIV_SOFFICE: case INET_PROT_SLOT: case INET_PROT_HID: case INET_PROT_MACRO: case INET_PROT_UNO: case INET_PROT_COMPONENT: case INET_PROT_LDAP: while (pPos < pEnd && *pPos != nQueryDelimiter && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_PATH_BEFORE_QUERY, '%', eCharset, true); } break; case INET_PROT_VND_SUN_STAR_HELP: if (pPos == pEnd || *pPos == nQueryDelimiter || *pPos == nFragmentDelimiter) aTheSynPath.append(sal_Unicode('/')); else { if (*pPos != '/') return false; while (pPos < pEnd && *pPos != nQueryDelimiter && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_HTTP_PATH, '%', eCharset, true); } } break; case INET_PROT_JAVASCRIPT: case INET_PROT_DATA: case INET_PROT_CID: case INET_PROT_DB: while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_URIC, '%', eCharset, true); } break; case INET_PROT_OUT: if (pEnd - pPos < 2 || *pPos++ != '/' || *pPos++ != '~') return false; aTheSynPath.appendAscii(RTL_CONSTASCII_STRINGPARAM("/~")); while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_URIC, '%', eCharset, true); } break; case INET_PROT_VND_SUN_STAR_HIER: case INET_PROT_VND_SUN_STAR_PKG: if (pPos < pEnd && *pPos != '/' && *pPos != nQueryDelimiter && *pPos != nFragmentDelimiter) return false; while (pPos < pEnd && *pPos != nQueryDelimiter && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); if (eEscapeType == ESCAPE_NO && nUTF32 == '/') aTheSynPath.append(sal_Unicode('/')); else appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_PCHAR, '%', eCharset, false); } if (aTheSynPath.getLength() == 0) aTheSynPath.append(sal_Unicode('/')); break; case INET_PROT_VIM: { /* test had to be taken out to make parsePath static; ok since INET_PROT_VIM is obsolete, anyway if (m_aUser.isEmpty()) return false; */ sal_Unicode const * pPathEnd = pPos; while (pPathEnd < pEnd && *pPathEnd != nFragmentDelimiter) ++pPathEnd; aTheSynPath.append(sal_Unicode('/')); if (pPos == pPathEnd) break; else if (*pPos++ != '/') return false; if (pPos == pPathEnd) break; while (pPos < pPathEnd && *pPos != '/') { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, '=', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, eEscapeType == ESCAPE_NO ? INetMIME::toLowerCase(nUTF32) : nUTF32, eEscapeType, bOctets, PART_VIM, '=', eCharset, false); } bool bInbox; rtl::OUString sCompare(aTheSynPath); if (sCompare.equalsAscii("/inbox")) bInbox = true; else if (sCompare.equalsAscii("/newsgroups")) bInbox = false; else return false; aTheSynPath.append(sal_Unicode('/')); if (pPos == pPathEnd) break; else if (*pPos++ != '/') return false; if (!bInbox) { bool bEmpty = true; while (pPos < pPathEnd && *pPos != '/') { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, '=', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_VIM, '=', eCharset, false); bEmpty = false; } if (bEmpty) return false; aTheSynPath.append(sal_Unicode('/')); if (pPos == pPathEnd) break; else if (*pPos++ != '/') return false; } bool bEmpty = true; while (pPos < pPathEnd && *pPos != ':') { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, '=', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_VIM, '=', eCharset, false); bEmpty = false; } if (bEmpty) return false; if (pPos == pPathEnd) break; else if (*pPos++ != ':') return false; aTheSynPath.append(sal_Unicode(':')); for (int i = 0; i < 3; ++i) { if (i != 0) { if (pPos == pPathEnd || *pPos++ != '.') return false; aTheSynPath.append(sal_Unicode('.')); } bEmpty = true; while (pPos < pPathEnd && *pPos != '.') { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, '=', eMechanism, eCharset, eEscapeType); if (!INetMIME::isDigit(nUTF32)) return false; aTheSynPath.append(sal_Unicode(nUTF32)); bEmpty = false; } if (bEmpty) return false; } if (pPos != pPathEnd) return false; break; } case INET_PROT_VND_SUN_STAR_CMD: case INET_PROT_VND_SUN_STAR_EXPAND: { if (pPos == pEnd || *pPos == nFragmentDelimiter) return false; Part ePart = PART_URIC_NO_SLASH; while (pPos != pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, ePart, '%', eCharset, true); ePart = PART_URIC; } break; } case INET_PROT_VND_SUN_STAR_ODMA: if (pPos < pEnd) { if (*pPos == '/') ++pPos; else return false; } aTheSynPath.append(sal_Unicode('/')); while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_URIC_NO_SLASH, '%', eCharset, true); } break; case INET_PROT_TELNET: if (pPos < pEnd) { if (*pPos != '/' || pEnd - pPos > 1) return false; ++pPos; } aTheSynPath.append(sal_Unicode('/')); break; case INET_PROT_VND_SUN_STAR_TDOC: if (pPos == pEnd || *pPos != '/') return false; while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); if (eEscapeType == ESCAPE_NO && nUTF32 == '/') aTheSynPath.append(sal_Unicode('/')); else appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_PCHAR, '%', eCharset, false); } break; case INET_PROT_GENERIC: while (pPos < pEnd && *pPos != nFragmentDelimiter) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, '%', eMechanism, eCharset, eEscapeType); appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, PART_URIC, '%', eCharset, true); } if (aTheSynPath.getLength() == 0) return false; break; default: OSL_ASSERT(false); break; } *pBegin = pPos; rSynPath = aTheSynPath; return true; } //============================================================================ bool INetURLObject::setPath(rtl::OUString const & rThePath, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { rtl::OUStringBuffer aSynPath; sal_Unicode const * p = rThePath.getStr(); sal_Unicode const * pEnd = p + rThePath.getLength(); if (!parsePath(m_eScheme, &p, pEnd, bOctets, eMechanism, eCharset, false, '/', 0x80000000, 0x80000000, 0x80000000, aSynPath) || p != pEnd) return false; sal_Int32 nDelta = m_aPath.set(m_aAbsURIRef, aSynPath.makeStringAndClear()); m_aQuery += nDelta; m_aFragment += nDelta; return true; } //============================================================================ bool INetURLObject::checkHierarchical() const { if (m_eScheme == INET_PROT_VND_SUN_STAR_EXPAND) { OSL_ENSURE( false, "INetURLObject::checkHierarchical vnd.sun.star.expand"); return true; } else { return getSchemeInfo().m_bHierarchical; } } //============================================================================ bool INetURLObject::appendSegment(rtl::OUString const & rTheSegment, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { return insertName(rTheSegment, bOctets, false, LAST_SEGMENT, true, eMechanism, eCharset); } //============================================================================ INetURLObject::SubString INetURLObject::getSegment(sal_Int32 nIndex, bool bIgnoreFinalSlash) const { DBG_ASSERT(nIndex >= 0 || nIndex == LAST_SEGMENT, "INetURLObject::getSegment(): Bad index"); if (!checkHierarchical()) return SubString(); sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); sal_Unicode const * pSegBegin; sal_Unicode const * pSegEnd; if (nIndex == LAST_SEGMENT) { pSegEnd = pPathEnd; if (bIgnoreFinalSlash && pSegEnd > pPathBegin && pSegEnd[-1] == '/') --pSegEnd; if (pSegEnd <= pPathBegin) return SubString(); pSegBegin = pSegEnd - 1; while (pSegBegin > pPathBegin && *pSegBegin != '/') --pSegBegin; } else { pSegBegin = pPathBegin; while (nIndex-- > 0) do { ++pSegBegin; if (pSegBegin >= pPathEnd) return SubString(); } while (*pSegBegin != '/'); pSegEnd = pSegBegin + 1; while (pSegEnd < pPathEnd && *pSegEnd != '/') ++pSegEnd; } return SubString(pSegBegin - m_aAbsURIRef.getStr(), pSegEnd - pSegBegin); } //============================================================================ bool INetURLObject::insertName(rtl::OUString const & rTheName, bool bOctets, bool bAppendFinalSlash, sal_Int32 nIndex, bool bIgnoreFinalSlash, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { DBG_ASSERT(nIndex >= 0 || nIndex == LAST_SEGMENT, "INetURLObject::insertName(): Bad index"); if (!checkHierarchical()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); sal_Unicode const * pPrefixEnd; bool bInsertSlash; sal_Unicode const * pSuffixBegin; if (nIndex == LAST_SEGMENT) { pPrefixEnd = pPathEnd; if (bIgnoreFinalSlash && pPrefixEnd > pPathBegin && pPrefixEnd[-1] == '/') { --pPrefixEnd; } bInsertSlash = bAppendFinalSlash; pSuffixBegin = pPathEnd; } else if (nIndex == 0) { pPrefixEnd = pPathBegin; bInsertSlash = (pPathBegin < pPathEnd && *pPathBegin != '/') || (pPathBegin == pPathEnd && bAppendFinalSlash); pSuffixBegin = (pPathEnd - pPathBegin == 1 && *pPathBegin == '/' && !bAppendFinalSlash && bIgnoreFinalSlash) ? pPathEnd : pPathBegin; } else { pPrefixEnd = pPathBegin; sal_Unicode const * pEnd = pPathEnd; if (bIgnoreFinalSlash && pEnd > pPathBegin && pEnd[-1] == '/') --pEnd; bool bSkip = pPrefixEnd < pEnd && *pPrefixEnd == '/'; bInsertSlash = false; pSuffixBegin = pPathEnd; while (nIndex-- > 0) for (;;) { if (bSkip) ++pPrefixEnd; bSkip = true; if (pPrefixEnd >= pEnd) { if (nIndex == 0) { bInsertSlash = bAppendFinalSlash; break; } else return false; } if (*pPrefixEnd == '/') { pSuffixBegin = pPrefixEnd; break; } } } rtl::OUStringBuffer aNewPath; aNewPath.append(pPathBegin, pPrefixEnd - pPathBegin); aNewPath.append(sal_Unicode('/')); aNewPath.append(encodeText(rTheName, bOctets, PART_PCHAR, getEscapePrefix(), eMechanism, eCharset, true)); if (bInsertSlash) { aNewPath.append(sal_Unicode('/')); } aNewPath.append(pSuffixBegin, pPathEnd - pSuffixBegin); return setPath(aNewPath.makeStringAndClear(), false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ bool INetURLObject::clearQuery() { if (HasError()) return false; if (m_aQuery.isPresent()) { lcl_Erase(m_aAbsURIRef, m_aQuery.getBegin() - 1, m_aQuery.getLength() + 1); m_aFragment += m_aQuery.clear() - 1; } return false; } //============================================================================ bool INetURLObject::setQuery(rtl::OUString const & rTheQuery, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { if (!getSchemeInfo().m_bQuery) return false; rtl::OUString aNewQuery(encodeText(rTheQuery, bOctets, PART_URIC, getEscapePrefix(), eMechanism, eCharset, true)); sal_Int32 nDelta; if (m_aQuery.isPresent()) nDelta = m_aQuery.set(m_aAbsURIRef, aNewQuery); else { m_aAbsURIRef.insert(m_aPath.getEnd(), sal_Unicode('?')); nDelta = m_aQuery.set(m_aAbsURIRef, aNewQuery, m_aPath.getEnd() + 1) + 1; } m_aFragment += nDelta; return true; } //============================================================================ bool INetURLObject::clearFragment() { if (HasError()) return false; if (m_aFragment.isPresent()) { m_aAbsURIRef.setLength(m_aFragment.getBegin() - 1); m_aFragment.clear(); } return true; } //============================================================================ bool INetURLObject::setFragment(rtl::OUString const & rTheFragment, bool bOctets, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { if (HasError()) return false; rtl::OUString aNewFragment(encodeText(rTheFragment, bOctets, PART_URIC, getEscapePrefix(), eMechanism, eCharset, true)); if (m_aFragment.isPresent()) m_aFragment.set(m_aAbsURIRef, aNewFragment); else { m_aAbsURIRef.append(sal_Unicode('#')); m_aFragment.set(m_aAbsURIRef, aNewFragment, m_aAbsURIRef.getLength()); } return true; } //============================================================================ INetURLObject::FTPType INetURLObject::getFTPType() const { if (m_eScheme == INET_PROT_FTP && m_aPath.getLength() >= RTL_CONSTASCII_LENGTH(";type=") + 1 && rtl::OUString(m_aAbsURIRef).copy( m_aPath.getEnd() - (RTL_CONSTASCII_LENGTH(";type=") + 1), RTL_CONSTASCII_LENGTH(";type=")).equalsIgnoreAsciiCaseAscii(";type=")) switch (m_aAbsURIRef.charAt(m_aPath.getEnd())) { case 'A': case 'a': return FTP_TYPE_A; case 'D': case 'd': return FTP_TYPE_D; case 'I': case 'i': return FTP_TYPE_I; } return FTP_TYPE_NONE; } //============================================================================ bool INetURLObject::hasDosVolume(FSysStyle eStyle) const { sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPath.getBegin(); return (eStyle & FSYS_DOS) != 0 && m_aPath.getLength() >= 3 && p[0] == '/' && INetMIME::isAlpha(p[1]) && p[2] == ':' && (m_aPath.getLength() == 3 || p[3] == '/'); } //============================================================================ sal_uInt32 INetURLObject::getIMAPUID() const { if (m_eScheme == INET_PROT_IMAP && m_aPath.getLength() >= RTL_CONSTASCII_LENGTH("/;uid=") + 1) { sal_Unicode const * pBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin() + RTL_CONSTASCII_LENGTH("/;uid="); sal_Unicode const * pEnd = pBegin + m_aPath.getLength(); sal_Unicode const * p = pEnd; while (p > pBegin && INetMIME::isDigit(p[-1])) --p; if (p < pEnd && *--p != '0' && rtl::OUString(m_aAbsURIRef).copy( p - RTL_CONSTASCII_LENGTH("/;uid=") - m_aAbsURIRef.getStr(), RTL_CONSTASCII_LENGTH("/;uid=")).equalsIgnoreAsciiCaseAscii("/;uid=") ) { sal_uInt32 nUID; if (INetMIME::scanUnsigned(p, pEnd, false, nUID)) return nUID; } } return 0; } //============================================================================ // static rtl::OUString INetURLObject::encodeText(sal_Unicode const * pBegin, sal_Unicode const * pEnd, bool bOctets, Part ePart, sal_Char cEscapePrefix, EncodeMechanism eMechanism, rtl_TextEncoding eCharset, bool bKeepVisibleEscapes) { rtl::OUStringBuffer aResult; while (pBegin < pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pBegin, pEnd, bOctets, cEscapePrefix, eMechanism, eCharset, eEscapeType); appendUCS4(aResult, nUTF32, eEscapeType, bOctets, ePart, cEscapePrefix, eCharset, bKeepVisibleEscapes); } return aResult.makeStringAndClear(); } //============================================================================ // static rtl::OUString INetURLObject::decode(sal_Unicode const * pBegin, sal_Unicode const * pEnd, sal_Char cEscapePrefix, DecodeMechanism eMechanism, rtl_TextEncoding eCharset) { switch (eMechanism) { case NO_DECODE: return rtl::OUString(pBegin, pEnd - pBegin); case DECODE_TO_IURI: eCharset = RTL_TEXTENCODING_UTF8; break; default: break; } rtl::OUStringBuffer aResult; while (pBegin < pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(pBegin, pEnd, false, cEscapePrefix, WAS_ENCODED, eCharset, eEscapeType); switch (eEscapeType) { case ESCAPE_NO: aResult.append(sal_Unicode(nUTF32)); break; case ESCAPE_OCTET: appendEscape(aResult, cEscapePrefix, nUTF32); break; case ESCAPE_UTF32: if ( INetMIME::isUSASCII(nUTF32) && ( eMechanism == DECODE_TO_IURI || ( eMechanism == DECODE_UNAMBIGUOUS && mustEncode(nUTF32, PART_UNAMBIGUOUS) ) ) ) { appendEscape(aResult, cEscapePrefix, nUTF32); } else aResult.append(sal_Unicode(nUTF32)); break; } } return aResult.makeStringAndClear(); } //============================================================================ rtl::OUString INetURLObject::GetURLNoPass(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { INetURLObject aTemp(*this); aTemp.clearPassword(); return aTemp.GetMainURL(eMechanism, eCharset); } //============================================================================ rtl::OUString INetURLObject::GetURLNoMark(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { INetURLObject aTemp(*this); aTemp.clearFragment(); return aTemp.GetMainURL(eMechanism, eCharset); } //============================================================================ rtl::OUString INetURLObject::getAbbreviated( star::uno::Reference< star::util::XStringWidth > const & rStringWidth, sal_Int32 nWidth, DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { OSL_ENSURE(rStringWidth.is(), "specification violation"); sal_Char cEscapePrefix = getEscapePrefix(); rtl::OUStringBuffer aBuffer; // make sure that the scheme is copied for generic schemes: getSchemeInfo().m_pScheme // is empty ("") in that case, so take the scheme from m_aAbsURIRef if (m_eScheme != INET_PROT_GENERIC) { aBuffer.appendAscii(getSchemeInfo().m_pScheme); } else { if (m_aAbsURIRef) { sal_Unicode const * pSchemeBegin = m_aAbsURIRef.getStr(); sal_Unicode const * pSchemeEnd = pSchemeBegin; while (pSchemeEnd[0] != ':') { ++pSchemeEnd; } aBuffer.append(pSchemeBegin, pSchemeEnd - pSchemeBegin); } } aBuffer.append(static_cast< sal_Unicode >(':')); bool bAuthority = getSchemeInfo().m_bAuthority; sal_Unicode const * pCoreBegin = m_aAbsURIRef.getStr() + (bAuthority ? getAuthorityBegin() : m_aPath.getBegin()); sal_Unicode const * pCoreEnd = m_aAbsURIRef.getStr() + m_aPath.getBegin() + m_aPath.getLength(); bool bSegment = false; if (getSchemeInfo().m_bHierarchical) { rtl::OUString aRest; if (m_aQuery.isPresent()) aRest = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("?...")); else if (m_aFragment.isPresent()) aRest = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("#...")); rtl::OUStringBuffer aTrailer; sal_Unicode const * pBegin = pCoreBegin; sal_Unicode const * pEnd = pCoreEnd; sal_Unicode const * pPrefixBegin = pBegin; sal_Unicode const * pSuffixEnd = pEnd; bool bPrefix = true; bool bSuffix = true; do { if (bSuffix) { sal_Unicode const * p = pSuffixEnd - 1; if (pSuffixEnd == pCoreEnd && *p == '/') --p; while (*p != '/') --p; if (bAuthority && p == pCoreBegin + 1) --p; rtl::OUString aSegment(decode(p + (p == pBegin && pBegin != pCoreBegin ? 1 : 0), pSuffixEnd, cEscapePrefix, eMechanism, eCharset)); pSuffixEnd = p; rtl::OUStringBuffer aResult(aBuffer); if (pSuffixEnd != pBegin) aResult.appendAscii(RTL_CONSTASCII_STRINGPARAM("...")); aResult.append(aSegment); aResult.append(aTrailer); aResult.append(aRest); if (rStringWidth-> queryStringWidth(aResult.makeStringAndClear()) <= nWidth) { aTrailer.insert(0, aSegment); bSegment = true; pEnd = pSuffixEnd; } else bSuffix = false; if (pPrefixBegin > pSuffixEnd) pPrefixBegin = pSuffixEnd; if (pBegin == pEnd) break; } if (bPrefix) { sal_Unicode const * p = pPrefixBegin + (bAuthority && pPrefixBegin == pCoreBegin ? 2 : 1); OSL_ASSERT(p <= pEnd); while (p < pEnd && *p != '/') ++p; if (p == pCoreEnd - 1 && *p == '/') ++p; rtl::OUString aSegment(decode(pPrefixBegin + (pPrefixBegin == pCoreBegin ? 0 : 1), p == pEnd ? p : p + 1, cEscapePrefix, eMechanism, eCharset)); pPrefixBegin = p; rtl::OUStringBuffer aResult(aBuffer); aResult.append(aSegment); if (pPrefixBegin != pEnd) aResult.appendAscii(RTL_CONSTASCII_STRINGPARAM("...")); aResult.append(aTrailer); aResult.append(aRest); if (rStringWidth-> queryStringWidth(aResult.makeStringAndClear()) <= nWidth) { aBuffer.append(aSegment); bSegment = true; pBegin = pPrefixBegin; } else bPrefix = false; if (pPrefixBegin > pSuffixEnd) pSuffixEnd = pPrefixBegin; if (pBegin == pEnd) break; } } while (bPrefix || bSuffix); if (bSegment) { if (pPrefixBegin != pBegin || pSuffixEnd != pEnd) aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("...")); aBuffer.append(aTrailer); } } if (!bSegment) aBuffer.append(decode(pCoreBegin, pCoreEnd, cEscapePrefix, eMechanism, eCharset)); if (m_aQuery.isPresent()) { aBuffer.append(static_cast< sal_Unicode >('?')); aBuffer.append(decode(m_aQuery, cEscapePrefix, eMechanism, eCharset)); } if (m_aFragment.isPresent()) { aBuffer.append(static_cast< sal_Unicode >('#')); aBuffer. append(decode(m_aFragment, cEscapePrefix, eMechanism, eCharset)); } if (aBuffer.getLength() != 0) { rtl::OUStringBuffer aResult(aBuffer); if (rStringWidth->queryStringWidth(aResult.makeStringAndClear()) > nWidth) for (sal_Int32 i = aBuffer.getLength();;) { if (i == 0) { aBuffer.setLength(aBuffer.getLength() - 1); if (aBuffer.getLength() == 0) break; } else { aBuffer.setLength(--i); aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("...")); } aResult = aBuffer; if (rStringWidth-> queryStringWidth(aResult.makeStringAndClear()) <= nWidth) break; } } return aBuffer.makeStringAndClear(); } //============================================================================ bool INetURLObject::operator ==(INetURLObject const & rObject) const { if (m_eScheme != rObject.m_eScheme) return false; if (m_eScheme == INET_PROT_NOT_VALID) return (m_aAbsURIRef == rObject.m_aAbsURIRef) != false; if ((m_aScheme.compare( rObject.m_aScheme, m_aAbsURIRef, rObject.m_aAbsURIRef) != 0) || GetUser(NO_DECODE) != rObject.GetUser(NO_DECODE) || GetPass(NO_DECODE) != rObject.GetPass(NO_DECODE) || !GetHost(NO_DECODE).equalsIgnoreAsciiCase( rObject.GetHost(NO_DECODE)) || GetPort() != rObject.GetPort() || HasParam() != rObject.HasParam() || GetParam(NO_DECODE) != rObject.GetParam(NO_DECODE) || GetMsgId(NO_DECODE) != rObject.GetMsgId(NO_DECODE)) return false; rtl::OUString aPath1(GetURLPath(NO_DECODE)); rtl::OUString aPath2(rObject.GetURLPath(NO_DECODE)); switch (m_eScheme) { case INET_PROT_FILE: { // If the URL paths of two file URLs only differ in that one has a // final '/' and the other has not, take the two paths as // equivalent (this could be usefull for other schemes, too): sal_Int32 nLength = aPath1.getLength(); switch (nLength - aPath2.getLength()) { case -1: if (aPath2.getStr()[nLength] != '/') return false; break; case 0: break; case 1: if (aPath1.getStr()[--nLength] != '/') return false; break; default: return false; } return aPath1.compareTo(aPath2, nLength) == 0; } default: return (aPath1 == aPath2) != false; } } //============================================================================ bool INetURLObject::operator <(INetURLObject const & rObject) const { sal_Int32 nCompare = m_aScheme.compare( rObject.m_aScheme, m_aAbsURIRef, rObject.m_aAbsURIRef); if (nCompare < 0) { return true; } else if (nCompare > 0) { return false; } sal_uInt32 nPort1 = GetPort(); sal_uInt32 nPort2 = rObject.GetPort(); if (nPort1 < nPort2) return true; else if (nPort1 > nPort2) return false; nCompare = GetUser(NO_DECODE).compareTo(rObject.GetUser(NO_DECODE)); if (nCompare < 0) return true; else if (nCompare > 0) return false; nCompare = GetPass(NO_DECODE).compareTo(rObject.GetPass(NO_DECODE)); if (nCompare < 0) return true; else if (nCompare > 0) return false; nCompare = GetHost(NO_DECODE).compareTo(rObject.GetHost(NO_DECODE)); if (nCompare < 0) return true; else if (nCompare > 0) return false; const rtl::OUString &rPath1(GetURLPath(NO_DECODE)); const rtl::OUString &rPath2(rObject.GetURLPath(NO_DECODE)); nCompare = rPath1.compareTo(rPath2); if (nCompare < 0) return true; else if (nCompare > 0) return false; nCompare = GetParam(NO_DECODE).compareTo(rObject.GetParam(NO_DECODE)); if (nCompare < 0) return true; else if (nCompare > 0) return false; return GetMsgId(NO_DECODE).compareTo(rObject.GetMsgId(NO_DECODE)) < 0; } //============================================================================ bool INetURLObject::ConcatData(INetProtocol eTheScheme, rtl::OUString const & rTheUser, rtl::OUString const & rThePassword, rtl::OUString const & rTheHost, sal_uInt32 nThePort, rtl::OUString const & rThePath, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { setInvalid(); m_eScheme = eTheScheme; if (HasError() || m_eScheme == INET_PROT_GENERIC) return false; m_aAbsURIRef.setLength(0); m_aAbsURIRef.appendAscii(getSchemeInfo().m_pScheme); m_aAbsURIRef.append(sal_Unicode(':')); if (getSchemeInfo().m_bAuthority) { m_aAbsURIRef.appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); bool bUserInfo = false; if (getSchemeInfo().m_bUser) { if (m_eScheme == INET_PROT_IMAP && rTheUser.getLength() == 0) { setInvalid(); return false; } if (rTheUser.getLength() != 0) { m_aUser.set(m_aAbsURIRef, encodeText(rTheUser, false, m_eScheme == INET_PROT_IMAP ? PART_IMAP_ACHAR : m_eScheme == INET_PROT_VIM ? PART_VIM : PART_USER_PASSWORD, getEscapePrefix(), eMechanism, eCharset, false), m_aAbsURIRef.getLength()); bUserInfo = true; } } else if (rTheUser.getLength() != 0) { setInvalid(); return false; } if (rThePassword.getLength() != 0) { if (getSchemeInfo().m_bPassword) { m_aAbsURIRef.append(sal_Unicode(':')); m_aAuth.set(m_aAbsURIRef, encodeText(rThePassword, false, m_eScheme == INET_PROT_VIM ? PART_VIM : PART_USER_PASSWORD, getEscapePrefix(), eMechanism, eCharset, false), m_aAbsURIRef.getLength()); bUserInfo = true; } else { setInvalid(); return false; } } if (bUserInfo && getSchemeInfo().m_bHost) m_aAbsURIRef.append(sal_Unicode('@')); if (getSchemeInfo().m_bHost) { rtl::OUStringBuffer aSynHost(rTheHost); bool bNetBiosName = false; switch (m_eScheme) { case INET_PROT_FILE: { rtl::OUString sTemp(aSynHost); if (sTemp.equalsIgnoreAsciiCaseAsciiL( RTL_CONSTASCII_STRINGPARAM("localhost"))) { aSynHost.setLength(0); } bNetBiosName = true; } break; case INET_PROT_LDAP: if (aSynHost.getLength() == 0 && nThePort != 0) { setInvalid(); return false; } break; default: if (aSynHost.getLength() == 0) { setInvalid(); return false; } break; } if (!parseHostOrNetBiosName( aSynHost.getStr(), aSynHost.getStr() + aSynHost.getLength(), false, eMechanism, eCharset, bNetBiosName, &aSynHost)) { setInvalid(); return false; } m_aHost.set(m_aAbsURIRef, aSynHost.makeStringAndClear(), m_aAbsURIRef.getLength()); if (nThePort != 0) { if (getSchemeInfo().m_bPort) { m_aAbsURIRef.append(sal_Unicode(':')); m_aPort.set(m_aAbsURIRef, rtl::OUString::valueOf(sal_Int64(nThePort)), m_aAbsURIRef.getLength()); } else { setInvalid(); return false; } } } else if (rTheHost.getLength() != 0 || nThePort != 0) { setInvalid(); return false; } } rtl::OUStringBuffer aSynPath; sal_Unicode const * p = rThePath.getStr(); sal_Unicode const * pEnd = p + rThePath.getLength(); if (!parsePath(m_eScheme, &p, pEnd, false, eMechanism, eCharset, false, '/', 0x80000000, 0x80000000, 0x80000000, aSynPath) || p != pEnd) { setInvalid(); return false; } m_aPath.set(m_aAbsURIRef, aSynPath.makeStringAndClear(), m_aAbsURIRef.getLength()); return true; } //============================================================================ // static rtl::OUString INetURLObject::GetAbsURL(rtl::OUString const & rTheBaseURIRef, rtl::OUString const & rTheRelURIRef, bool bIgnoreFragment, EncodeMechanism eEncodeMechanism, DecodeMechanism eDecodeMechanism, rtl_TextEncoding eCharset, FSysStyle eStyle) { // Backwards compatibility: if (rTheRelURIRef.getLength() == 0 || rTheRelURIRef[0] == '#') return rTheRelURIRef; INetURLObject aTheAbsURIRef; bool bWasAbsolute; return INetURLObject(rTheBaseURIRef, eEncodeMechanism, eCharset). convertRelToAbs(rTheRelURIRef, false, aTheAbsURIRef, bWasAbsolute, eEncodeMechanism, eCharset, bIgnoreFragment, false, false, eStyle) || eEncodeMechanism != WAS_ENCODED || eDecodeMechanism != DECODE_TO_IURI || eCharset != RTL_TEXTENCODING_UTF8 ? aTheAbsURIRef.GetMainURL(eDecodeMechanism, eCharset) : rTheRelURIRef; } //============================================================================ rtl::OUString INetURLObject::getExternalURL(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { rtl::OUString aTheExtURIRef; translateToExternal( rtl::OUString(m_aAbsURIRef), aTheExtURIRef, eMechanism, eCharset); return aTheExtURIRef; } //============================================================================ // static rtl::OUString INetURLObject::GetScheme(INetProtocol eTheScheme) { return rtl::OUString::createFromAscii(getSchemeInfo(eTheScheme).m_pPrefix); } //============================================================================ // static INetProtocol INetURLObject::CompareProtocolScheme(rtl::OUString const & rTheAbsURIRef) { sal_Unicode const * p = rTheAbsURIRef.getStr(); PrefixInfo const * pPrefix = getPrefix(p, p + rTheAbsURIRef.getLength()); return pPrefix ? pPrefix->m_eScheme : INET_PROT_NOT_VALID; } //============================================================================ bool INetURLObject::hasPassword() const { return m_aAuth.isPresent() && getSchemeInfo().m_bPassword; } //============================================================================ void INetURLObject::makeAuthCanonic() { if (m_eScheme == INET_PROT_IMAP && m_aAuth.getLength() == 1 && m_aAbsURIRef.charAt(m_aAuth.getBegin()) == '*') { lcl_Erase(m_aAbsURIRef, m_aAuth.getBegin() - RTL_CONSTASCII_LENGTH(";AUTH="), RTL_CONSTASCII_LENGTH(";AUTH=*")); sal_Int32 nDelta = m_aAuth.clear() - RTL_CONSTASCII_LENGTH(";AUTH="); m_aPath += nDelta; m_aQuery += nDelta; m_aFragment += nDelta; } } //============================================================================ rtl::OUString INetURLObject::GetHostPort(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) { // Check because PROT_VND_SUN_STAR_HELP, PROT_VND_SUN_STAR_HIER, and // PROT_VND_SUN_STAR_PKG misuse m_aHost: if (!getSchemeInfo().m_bHost) return rtl::OUString(); rtl::OUStringBuffer aHostPort(decode(m_aHost, getEscapePrefix(), eMechanism, eCharset)); if (m_aPort.isPresent()) { aHostPort.append(sal_Unicode(':')); aHostPort.append(decode(m_aPort, getEscapePrefix(), eMechanism, eCharset)); } return aHostPort.makeStringAndClear(); } //============================================================================ sal_uInt32 INetURLObject::GetPort() const { if (m_aPort.isPresent()) { sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPort.getBegin(); sal_Unicode const * pEnd = p + m_aPort.getLength(); sal_uInt32 nThePort; if (INetMIME::scanUnsigned(p, pEnd, true, nThePort) && p == pEnd) return nThePort; } return 0; } //============================================================================ bool INetURLObject::SetPort(sal_uInt32 nThePort) { if (getSchemeInfo().m_bPort && m_aHost.isPresent()) { rtl::OUString aNewPort(rtl::OUString::valueOf(sal_Int64(nThePort))); sal_Int32 nDelta; if (m_aPort.isPresent()) nDelta = m_aPort.set(m_aAbsURIRef, aNewPort); else { m_aAbsURIRef.insert(m_aHost.getEnd(), sal_Unicode(':')); nDelta = m_aPort.set(m_aAbsURIRef, aNewPort, m_aHost.getEnd() + 1) + 1; } m_aPath += nDelta; m_aQuery += nDelta; m_aFragment += nDelta; return true; } return false; } //============================================================================ void INetURLObject::makePortCanonic() { if (m_aPort.isPresent()) { sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPort.getBegin(); sal_Unicode const * pEnd = p + m_aPort.getLength(); sal_uInt32 nThePort; if (INetMIME::scanUnsigned(p, pEnd, true, nThePort) && p == pEnd) { sal_Int32 nDelta; if (nThePort != 0 && nThePort == getSchemeInfo().m_nDefaultPort) { lcl_Erase(m_aAbsURIRef, m_aPort.getBegin() - 1, m_aPort.getLength() + 1); nDelta = m_aPort.clear() - 1; } else nDelta = m_aPort.set(m_aAbsURIRef, rtl::OUString::valueOf(sal_Int64(nThePort))); m_aPath += nDelta; m_aQuery += nDelta; m_aFragment += nDelta; } } } //============================================================================ sal_Int32 INetURLObject::getSegmentCount(bool bIgnoreFinalSlash) const { if (!checkHierarchical()) return 0; sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pEnd = p + m_aPath.getLength(); if (bIgnoreFinalSlash && pEnd > p && pEnd[-1] == '/') --pEnd; sal_Int32 n = p == pEnd || *p == '/' ? 0 : 1; while (p != pEnd) if (*p++ == '/') ++n; return n; } //============================================================================ bool INetURLObject::removeSegment(sal_Int32 nIndex, bool bIgnoreFinalSlash) { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return false; rtl::OUStringBuffer aNewPath; aNewPath.append(m_aAbsURIRef.getStr() + m_aPath.getBegin(), aSegment.getBegin() - m_aPath.getBegin()); if (bIgnoreFinalSlash && aSegment.getEnd() == m_aPath.getEnd()) aNewPath.append(sal_Unicode('/')); else aNewPath.append(m_aAbsURIRef.getStr() + aSegment.getEnd(), m_aPath.getEnd() - aSegment.getEnd()); if (aNewPath.getLength() == 0 && !aSegment.isEmpty() && m_aAbsURIRef[aSegment.getBegin()] == '/') { aNewPath.append(sal_Unicode('/')); } return setPath(aNewPath.makeStringAndClear(), false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ rtl::OUString INetURLObject::getName(sal_Int32 nIndex, bool bIgnoreFinalSlash, DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return rtl::OUString(); sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; sal_Unicode const * p = pSegBegin; while (p != pSegEnd && *p != ';') ++p; return decode(pSegBegin, p, getEscapePrefix(), eMechanism, eCharset); } //============================================================================ bool INetURLObject::setName(rtl::OUString const & rTheName, sal_Int32 nIndex, bool bIgnoreFinalSlash, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; sal_Unicode const * p = pSegBegin; while (p != pSegEnd && *p != ';') ++p; rtl::OUStringBuffer aNewPath; aNewPath.append(pPathBegin, pSegBegin - pPathBegin); aNewPath.append(encodeText(rTheName, false, PART_PCHAR, getEscapePrefix(), eMechanism, eCharset, true)); aNewPath.append(p, pPathEnd - p); return setPath(aNewPath.makeStringAndClear(), false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ bool INetURLObject::hasExtension(sal_Int32 nIndex, bool bIgnoreFinalSlash) const { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return false; sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; for (sal_Unicode const * p = pSegBegin; p != pSegEnd && *p != ';'; ++p) if (*p == '.' && p != pSegBegin) return true; return false; } //============================================================================ rtl::OUString INetURLObject::getBase(sal_Int32 nIndex, bool bIgnoreFinalSlash, DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return rtl::OUString(); sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; sal_Unicode const * pExtension = 0; sal_Unicode const * p = pSegBegin; for (; p != pSegEnd && *p != ';'; ++p) if (*p == '.' && p != pSegBegin) pExtension = p; if (!pExtension) pExtension = p; return decode(pSegBegin, pExtension, getEscapePrefix(), eMechanism, eCharset); } //============================================================================ bool INetURLObject::setBase(rtl::OUString const & rTheBase, sal_Int32 nIndex, bool bIgnoreFinalSlash, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; sal_Unicode const * pExtension = 0; sal_Unicode const * p = pSegBegin; for (; p != pSegEnd && *p != ';'; ++p) if (*p == '.' && p != pSegBegin) pExtension = p; if (!pExtension) pExtension = p; rtl::OUStringBuffer aNewPath; aNewPath.append(pPathBegin, pSegBegin - pPathBegin); aNewPath.append(encodeText(rTheBase, false, PART_PCHAR, getEscapePrefix(), eMechanism, eCharset, true)); aNewPath.append(pExtension, pPathEnd - pExtension); return setPath(aNewPath.makeStringAndClear(), false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ rtl::OUString INetURLObject::getExtension(sal_Int32 nIndex, bool bIgnoreFinalSlash, DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return rtl::OUString(); sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; sal_Unicode const * pExtension = 0; sal_Unicode const * p = pSegBegin; for (; p != pSegEnd && *p != ';'; ++p) if (*p == '.' && p != pSegBegin) pExtension = p; if (!pExtension) return rtl::OUString(); return decode(pExtension + 1, p, getEscapePrefix(), eMechanism, eCharset); } //============================================================================ bool INetURLObject::setExtension(rtl::OUString const & rTheExtension, sal_Int32 nIndex, bool bIgnoreFinalSlash, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; sal_Unicode const * pExtension = 0; sal_Unicode const * p = pSegBegin; for (; p != pSegEnd && *p != ';'; ++p) if (*p == '.' && p != pSegBegin) pExtension = p; if (!pExtension) pExtension = p; rtl::OUStringBuffer aNewPath; aNewPath.append(pPathBegin, pExtension - pPathBegin); aNewPath.append(sal_Unicode('.')); aNewPath.append(encodeText(rTheExtension, false, PART_PCHAR, getEscapePrefix(), eMechanism, eCharset, true)); aNewPath.append(p, pPathEnd - p); return setPath(aNewPath.makeStringAndClear(), false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ bool INetURLObject::removeExtension(sal_Int32 nIndex, bool bIgnoreFinalSlash) { SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); if (!aSegment.isPresent()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); sal_Unicode const * pSegBegin = m_aAbsURIRef.getStr() + aSegment.getBegin(); sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); if (pSegBegin < pSegEnd && *pSegBegin == '/') ++pSegBegin; sal_Unicode const * pExtension = 0; sal_Unicode const * p = pSegBegin; for (; p != pSegEnd && *p != ';'; ++p) if (*p == '.' && p != pSegBegin) pExtension = p; if (!pExtension) return true; rtl::OUStringBuffer aNewPath; aNewPath.append(pPathBegin, pExtension - pPathBegin); aNewPath.append(p, pPathEnd - p); return setPath(aNewPath.makeStringAndClear(), false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ bool INetURLObject::hasFinalSlash() const { if (!checkHierarchical()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); return pPathEnd > pPathBegin && pPathEnd[-1] == '/'; } //============================================================================ bool INetURLObject::setFinalSlash() { if (!checkHierarchical()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); if (pPathEnd > pPathBegin && pPathEnd[-1] == '/') return true; rtl::OUStringBuffer aNewPath; aNewPath.append(pPathBegin, pPathEnd - pPathBegin); aNewPath.append(sal_Unicode('/')); return setPath(aNewPath.makeStringAndClear(), false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ bool INetURLObject::removeFinalSlash() { if (!checkHierarchical()) return false; sal_Unicode const * pPathBegin = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); if (pPathEnd <= pPathBegin || pPathEnd[-1] != '/') return true; --pPathEnd; if (pPathEnd == pPathBegin && *pPathBegin == '/') return false; rtl::OUString aNewPath(pPathBegin, pPathEnd - pPathBegin); return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); } //============================================================================ // static rtl::OUString INetURLObject::createFragment(rtl::OUString const & rText) { rtl::OUString aFragment(rText); for (sal_Int32 i = 0; i < aFragment.getLength();) { sal_Unicode c = aFragment.getStr()[i]; if (mustEncode(c, PART_CREATEFRAGMENT)) aFragment = aFragment.replaceAt(i, 1, rtl::OUString()); else ++i; } return aFragment; } //============================================================================ bool INetURLObject::setFSysPath(rtl::OUString const & rFSysPath, FSysStyle eStyle) { sal_Unicode const * pFSysBegin = rFSysPath.getStr(); sal_Unicode const * pFSysEnd = pFSysBegin + rFSysPath.getLength(); switch ((eStyle & FSYS_VOS ? 1 : 0) + (eStyle & FSYS_UNX ? 1 : 0) + (eStyle & FSYS_DOS ? 1 : 0) + (eStyle & FSYS_MAC ? 1 : 0)) { case 0: return false; case 1: break; default: if (eStyle & FSYS_VOS && pFSysEnd - pFSysBegin >= 2 && pFSysBegin[0] == '/' && pFSysBegin[1] == '/') { if (pFSysEnd - pFSysBegin >= 3 && pFSysBegin[2] == '.' && (pFSysEnd - pFSysBegin == 3 || pFSysBegin[3] == '/')) { eStyle = FSYS_VOS; // Production T1 break; } sal_Unicode const * p = pFSysBegin + 2; rtl::OUString aHost; if (parseHost(p, pFSysEnd, aHost) && (p == pFSysEnd || *p == '/')) { eStyle = FSYS_VOS; // Production T2 break; } } if (eStyle & FSYS_DOS && pFSysEnd - pFSysBegin >= 2 && pFSysBegin[0] == '\\' && pFSysBegin[1] == '\\') { sal_Unicode const * p = pFSysBegin + 2; rtl::OUString aHost; if (parseHost(p, pFSysEnd, aHost) && (p == pFSysEnd || *p == '\\')) { eStyle = FSYS_DOS; // Production T3 break; } } if (eStyle & FSYS_DOS && pFSysEnd - pFSysBegin >= 2 && INetMIME::isAlpha(pFSysBegin[0]) && pFSysBegin[1] == ':' && (pFSysEnd - pFSysBegin == 2 || pFSysBegin[2] == '/' || pFSysBegin[2] == '\\')) { eStyle = FSYS_DOS; // Productions T4, T5 break; } if (!(eStyle & (FSYS_UNX | FSYS_DOS | FSYS_MAC))) return false; eStyle = guessFSysStyleByCounting(pFSysBegin, pFSysEnd, eStyle); // Production T6 break; } rtl::OUStringBuffer aSynAbsURIRef(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("file://"))); switch (eStyle) { case FSYS_VOS: { sal_Unicode const * p = pFSysBegin; if (pFSysEnd - p < 2 || *p++ != '/' || *p++ != '/') return false; if (p != pFSysEnd && *p == '.' && (pFSysEnd - p == 1 || p[1] == '/')) ++p; for (; p != pFSysEnd; ++p) switch (*p) { case '#': case '%': appendEscape(aSynAbsURIRef, '%', *p); break; default: aSynAbsURIRef.append(*p); break; } break; } case FSYS_UNX: { sal_Unicode const * p = pFSysBegin; if (p != pFSysEnd && *p != '/') return false; for (; p != pFSysEnd; ++p) switch (*p) { case '|': case '#': case '%': appendEscape(aSynAbsURIRef, '%', *p); break; default: aSynAbsURIRef.append(*p); break; } break; } case FSYS_DOS: { sal_uInt32 nAltDelimiter = 0x80000000; sal_Unicode const * p = pFSysBegin; if (pFSysEnd - p >= 3 && p[0] == '\\' && p[1] == '\\') p += 2; else { aSynAbsURIRef.append(sal_Unicode('/')); if (pFSysEnd - p >= 2 && INetMIME::isAlpha(p[0]) && p[1] == ':' && (pFSysEnd - p == 2 || p[2] == '\\' || p[2] == '/')) nAltDelimiter = '/'; } for (; p != pFSysEnd; ++p) if (*p == '\\' || *p == nAltDelimiter) aSynAbsURIRef.append(sal_Unicode('/')); else switch (*p) { case '/': case '#': case '%': appendEscape(aSynAbsURIRef, '%', *p); break; default: aSynAbsURIRef.append(*p); break; } break; } case FSYS_MAC: aSynAbsURIRef.append(sal_Unicode('/')); {for (sal_Unicode const * p = pFSysBegin; p != pFSysEnd; ++p) switch (*p) { case ':': aSynAbsURIRef.append(sal_Unicode('/')); break; case '/': case '|': case '#': case '%': appendEscape(aSynAbsURIRef, '%', *p); break; default: aSynAbsURIRef.append(*p); break; } } break; default: OSL_ASSERT(false); break; } INetURLObject aTemp(aSynAbsURIRef.makeStringAndClear(), WAS_ENCODED, RTL_TEXTENCODING_UTF8); if (aTemp.HasError()) return false; *this = aTemp; return true; } //============================================================================ rtl::OUString INetURLObject::getFSysPath(FSysStyle eStyle, sal_Unicode * pDelimiter) const { if (m_eScheme != INET_PROT_FILE) return rtl::OUString(); if ((eStyle & FSYS_VOS ? 1 : 0) + (eStyle & FSYS_UNX ? 1 : 0) + (eStyle & FSYS_DOS ? 1 : 0) + (eStyle & FSYS_MAC ? 1 : 0) > 1) { eStyle = eStyle & FSYS_VOS && m_aHost.isPresent() && m_aHost.getLength() > 0 ? FSYS_VOS : hasDosVolume(eStyle) || ((eStyle & FSYS_DOS) != 0 && m_aHost.isPresent() && m_aHost.getLength() > 0) ? FSYS_DOS : eStyle & FSYS_UNX && (!m_aHost.isPresent() || m_aHost.getLength() == 0) ? FSYS_UNX : FSysStyle(0); } switch (eStyle) { case FSYS_VOS: { if (pDelimiter) *pDelimiter = '/'; rtl::OUStringBuffer aSynFSysPath; aSynFSysPath.appendAscii(RTL_CONSTASCII_STRINGPARAM("//")); if (m_aHost.isPresent() && m_aHost.getLength() > 0) aSynFSysPath.append(decode(m_aHost, '%', DECODE_WITH_CHARSET, RTL_TEXTENCODING_UTF8)); else aSynFSysPath.append(sal_Unicode('.')); aSynFSysPath.append(decode(m_aPath, '%', DECODE_WITH_CHARSET, RTL_TEXTENCODING_UTF8)); return aSynFSysPath.makeStringAndClear(); } case FSYS_UNX: { if (m_aHost.isPresent() && m_aHost.getLength() > 0) return rtl::OUString(); if (pDelimiter) *pDelimiter = '/'; return decode(m_aPath, '%', DECODE_WITH_CHARSET, RTL_TEXTENCODING_UTF8); } case FSYS_DOS: { if (pDelimiter) *pDelimiter = '\\'; rtl::OUStringBuffer aSynFSysPath; if (m_aHost.isPresent() && m_aHost.getLength() > 0) { aSynFSysPath.appendAscii(RTL_CONSTASCII_STRINGPARAM("\\\\")); aSynFSysPath.append(decode(m_aHost, '%', DECODE_WITH_CHARSET, RTL_TEXTENCODING_UTF8)); aSynFSysPath.append(sal_Unicode('\\')); } sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pEnd = p + m_aPath.getLength(); DBG_ASSERT(p < pEnd && *p == '/', "INetURLObject::getFSysPath(): Bad path"); ++p; while (p < pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p, pEnd, false, '%', WAS_ENCODED, RTL_TEXTENCODING_UTF8, eEscapeType); if (eEscapeType == ESCAPE_NO && nUTF32 == '/') aSynFSysPath.append(sal_Unicode('\\')); else aSynFSysPath.appendUtf32(nUTF32); } return aSynFSysPath.makeStringAndClear(); } case FSYS_MAC: { if (m_aHost.isPresent() && m_aHost.getLength() > 0) return rtl::OUString(); if (pDelimiter) *pDelimiter = ':'; rtl::OUStringBuffer aSynFSysPath; sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pEnd = p + m_aPath.getLength(); DBG_ASSERT(p < pEnd && *p == '/', "INetURLObject::getFSysPath(): Bad path"); ++p; while (p < pEnd) { EscapeType eEscapeType; sal_uInt32 nUTF32 = getUTF32(p, pEnd, false, '%', WAS_ENCODED, RTL_TEXTENCODING_UTF8, eEscapeType); if (eEscapeType == ESCAPE_NO && nUTF32 == '/') aSynFSysPath.append(sal_Unicode(':')); else aSynFSysPath.appendUtf32(nUTF32); } return aSynFSysPath.makeStringAndClear(); } default: return rtl::OUString(); } } //============================================================================ bool INetURLObject::HasMsgId() const { if (m_eScheme != INET_PROT_POP3) return false; sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pEnd = p + m_aPath.getLength(); for (; p < pEnd; ++p) if (*p == '<') return true; return false; } //============================================================================ rtl::OUString INetURLObject::GetMsgId(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { if (m_eScheme != INET_PROT_POP3) return rtl::OUString(); sal_Unicode const * p = m_aAbsURIRef.getStr() + m_aPath.getBegin(); sal_Unicode const * pEnd = p + m_aPath.getLength(); for (; p < pEnd; ++p) if (*p == '<') return decode(p, pEnd, getEscapePrefix(), eMechanism, eCharset); return rtl::OUString(); } //============================================================================ // static void INetURLObject::appendUCS4Escape(rtl::OUStringBuffer & rTheText, sal_Char cEscapePrefix, sal_uInt32 nUCS4) { DBG_ASSERT(nUCS4 < 0x80000000, "INetURLObject::appendUCS4Escape(): Bad char"); if (nUCS4 < 0x80) appendEscape(rTheText, cEscapePrefix, nUCS4); else if (nUCS4 < 0x800) { appendEscape(rTheText, cEscapePrefix, nUCS4 >> 6 | 0xC0); appendEscape(rTheText, cEscapePrefix, (nUCS4 & 0x3F) | 0x80); } else if (nUCS4 < 0x10000) { appendEscape(rTheText, cEscapePrefix, nUCS4 >> 12 | 0xE0); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 6 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 & 0x3F) | 0x80); } else if (nUCS4 < 0x200000) { appendEscape(rTheText, cEscapePrefix, nUCS4 >> 18 | 0xF0); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 12 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 6 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 & 0x3F) | 0x80); } else if (nUCS4 < 0x4000000) { appendEscape(rTheText, cEscapePrefix, nUCS4 >> 24 | 0xF8); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 18 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 12 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 6 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 & 0x3F) | 0x80); } else { appendEscape(rTheText, cEscapePrefix, nUCS4 >> 30 | 0xFC); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 24 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 18 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 12 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 >> 6 & 0x3F) | 0x80); appendEscape(rTheText, cEscapePrefix, (nUCS4 & 0x3F) | 0x80); } } //============================================================================ // static void INetURLObject::appendUCS4(rtl::OUStringBuffer& rTheText, sal_uInt32 nUCS4, EscapeType eEscapeType, bool bOctets, Part ePart, sal_Char cEscapePrefix, rtl_TextEncoding eCharset, bool bKeepVisibleEscapes) { bool bEscape; rtl_TextEncoding eTargetCharset = RTL_TEXTENCODING_DONTKNOW; switch (eEscapeType) { case ESCAPE_NO: if (mustEncode(nUCS4, ePart)) { bEscape = true; eTargetCharset = bOctets ? RTL_TEXTENCODING_ISO_8859_1 : RTL_TEXTENCODING_UTF8; } else bEscape = false; break; case ESCAPE_OCTET: bEscape = true; eTargetCharset = RTL_TEXTENCODING_ISO_8859_1; break; case ESCAPE_UTF32: if (mustEncode(nUCS4, ePart)) { bEscape = true; eTargetCharset = eCharset; } else if (bKeepVisibleEscapes && INetMIME::isVisible(nUCS4)) { bEscape = true; eTargetCharset = RTL_TEXTENCODING_ASCII_US; } else bEscape = false; break; default: bEscape = false; } if (bEscape) { switch (eTargetCharset) { default: DBG_ERROR("INetURLObject::appendUCS4(): Unsupported charset"); case RTL_TEXTENCODING_ASCII_US: case RTL_TEXTENCODING_ISO_8859_1: appendEscape(rTheText, cEscapePrefix, nUCS4); break; case RTL_TEXTENCODING_UTF8: appendUCS4Escape(rTheText, cEscapePrefix, nUCS4); break; } } else rTheText.append(sal_Unicode(nUCS4)); } //============================================================================ // static sal_uInt32 INetURLObject::getUTF32(sal_Unicode const *& rBegin, sal_Unicode const * pEnd, bool bOctets, sal_Char cEscapePrefix, EncodeMechanism eMechanism, rtl_TextEncoding eCharset, EscapeType & rEscapeType) { DBG_ASSERT(rBegin < pEnd, "INetURLObject::getUTF32(): Bad sequence"); sal_uInt32 nUTF32 = bOctets ? *rBegin++ : INetMIME::getUTF32Character(rBegin, pEnd); switch (eMechanism) { case ENCODE_ALL: rEscapeType = ESCAPE_NO; break; case WAS_ENCODED: { int nWeight1; int nWeight2; if (nUTF32 == sal_uChar(cEscapePrefix) && rBegin + 1 < pEnd && (nWeight1 = INetMIME::getHexWeight(rBegin[0])) >= 0 && (nWeight2 = INetMIME::getHexWeight(rBegin[1])) >= 0) { rBegin += 2; nUTF32 = nWeight1 << 4 | nWeight2; switch (eCharset) { default: DBG_ERROR( "INetURLObject::getUTF32(): Unsupported charset"); case RTL_TEXTENCODING_ASCII_US: rEscapeType = INetMIME::isUSASCII(nUTF32) ? ESCAPE_UTF32 : ESCAPE_OCTET; break; case RTL_TEXTENCODING_ISO_8859_1: rEscapeType = ESCAPE_UTF32; break; case RTL_TEXTENCODING_UTF8: if (INetMIME::isUSASCII(nUTF32)) rEscapeType = ESCAPE_UTF32; else { if (nUTF32 >= 0xC0 && nUTF32 <= 0xF4) { sal_uInt32 nEncoded; int nShift; sal_uInt32 nMin; if (nUTF32 <= 0xDF) { nEncoded = (nUTF32 & 0x1F) << 6; nShift = 0; nMin = 0x80; } else if (nUTF32 <= 0xEF) { nEncoded = (nUTF32 & 0x0F) << 12; nShift = 6; nMin = 0x800; } else { nEncoded = (nUTF32 & 0x07) << 18; nShift = 12; nMin = 0x10000; } sal_Unicode const * p = rBegin; bool bUTF8 = true; for (;;) { if (pEnd - p < 3 || p[0] != cEscapePrefix || (nWeight1 = INetMIME::getHexWeight(p[1])) < 8 || nWeight1 > 11 || (nWeight2 = INetMIME::getHexWeight(p[2])) < 0) { bUTF8 = false; break; } p += 3; nEncoded |= ((nWeight1 & 3) << 4 | nWeight2) << nShift; if (nShift == 0) break; nShift -= 6; } if (bUTF8 && nEncoded >= nMin && !INetMIME::isHighSurrogate(nEncoded) && !INetMIME::isLowSurrogate(nEncoded) && nEncoded <= 0x10FFFF) { rBegin = p; nUTF32 = nEncoded; rEscapeType = ESCAPE_UTF32; break; } } rEscapeType = ESCAPE_OCTET; } break; } } else rEscapeType = ESCAPE_NO; break; } case NOT_CANONIC: { int nWeight1; int nWeight2; if (nUTF32 == sal_uChar(cEscapePrefix) && rBegin + 1 < pEnd && ((nWeight1 = INetMIME::getHexWeight(rBegin[0])) >= 0) && ((nWeight2 = INetMIME::getHexWeight(rBegin[1])) >= 0)) { rBegin += 2; nUTF32 = nWeight1 << 4 | nWeight2; rEscapeType = ESCAPE_OCTET; } else rEscapeType = ESCAPE_NO; break; } } return nUTF32; } //============================================================================ // static sal_uInt32 INetURLObject::scanDomain(sal_Unicode const *& rBegin, sal_Unicode const * pEnd, bool bEager) { enum State { STATE_DOT, STATE_LABEL, STATE_HYPHEN }; State eState = STATE_DOT; sal_Int32 nLabels = 0; sal_Unicode const * pLastAlphanumeric = 0; for (sal_Unicode const * p = rBegin;; ++p) switch (eState) { case STATE_DOT: if (p != pEnd && INetMIME::isAlphanumeric(*p)) { ++nLabels; eState = STATE_LABEL; break; } if (bEager || nLabels == 0) return 0; rBegin = p - 1; return nLabels; case STATE_LABEL: if (p != pEnd) { if (INetMIME::isAlphanumeric(*p)) break; else if (*p == '.') { eState = STATE_DOT; break; } else if (*p == '-') { pLastAlphanumeric = p; eState = STATE_HYPHEN; break; } } rBegin = p; return nLabels; case STATE_HYPHEN: if (p != pEnd) { if (INetMIME::isAlphanumeric(*p)) { eState = STATE_LABEL; break; } else if (*p == '-') break; } if (bEager) return 0; rBegin = pLastAlphanumeric; return nLabels; } } //============================================================================ // static bool INetURLObject::scanIPv6reference(sal_Unicode const *& rBegin, sal_Unicode const * pEnd) { if (rBegin != pEnd && *rBegin == '[') { sal_Unicode const * p = rBegin + 1; //TODO: check for valid IPv6address (RFC 2373): while (p != pEnd && (INetMIME::isHexDigit(*p) || *p == ':' || *p == '.')) { ++p; } if (p != pEnd && *p == ']') { rBegin = p + 1; return true; } } return false; } //============================================================================ rtl::OUString INetURLObject::GetPartBeforeLastName(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { if (!checkHierarchical()) return rtl::OUString(); INetURLObject aTemp(*this); aTemp.clearFragment(); aTemp.clearQuery(); aTemp.removeSegment(LAST_SEGMENT, false); aTemp.setFinalSlash(); return aTemp.GetMainURL(eMechanism, eCharset); } //============================================================================ rtl::OUString INetURLObject::GetLastName(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { return getName(LAST_SEGMENT, true, eMechanism, eCharset); } //============================================================================ rtl::OUString INetURLObject::GetFileExtension(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) const { return getExtension(LAST_SEGMENT, false, eMechanism, eCharset); } //============================================================================ bool INetURLObject::CutLastName() { INetURLObject aTemp(*this); aTemp.clearFragment(); aTemp.clearQuery(); if (!aTemp.removeSegment(LAST_SEGMENT, false)) return false; *this = aTemp; return true; } //============================================================================ rtl::OUString INetURLObject::PathToFileName() const { if (m_eScheme != INET_PROT_FILE) return rtl::OUString(); rtl::OUString aSystemPath; if (osl::FileBase::getSystemPathFromFileURL( decode(m_aAbsURIRef.getStr(), m_aAbsURIRef.getStr() + m_aPath.getEnd(), getEscapePrefix(), NO_DECODE, RTL_TEXTENCODING_UTF8), aSystemPath) != osl::FileBase::E_None) return rtl::OUString(); return aSystemPath; } //============================================================================ rtl::OUString INetURLObject::GetFull() const { INetURLObject aTemp(*this); aTemp.removeFinalSlash(); return aTemp.PathToFileName(); } //============================================================================ rtl::OUString INetURLObject::GetPath() const { INetURLObject aTemp(*this); aTemp.removeSegment(LAST_SEGMENT, true); aTemp.removeFinalSlash(); return aTemp.PathToFileName(); } //============================================================================ void INetURLObject::SetBase(rtl::OUString const & rTheBase) { setBase(rTheBase, LAST_SEGMENT, true, ENCODE_ALL); } //============================================================================ rtl::OUString INetURLObject::GetBase() const { return getBase(LAST_SEGMENT, true, DECODE_WITH_CHARSET); } //============================================================================ void INetURLObject::SetName(rtl::OUString const & rTheName, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { INetURLObject aTemp(*this); if (aTemp.removeSegment(LAST_SEGMENT, true) && aTemp.insertName(rTheName, false, LAST_SEGMENT, true, eMechanism, eCharset)) *this = aTemp; } //============================================================================ rtl::OUString INetURLObject::CutName(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) { rtl::OUString aTheName(getName(LAST_SEGMENT, true, eMechanism, eCharset)); return removeSegment(LAST_SEGMENT, true) ? aTheName : rtl::OUString(); } //============================================================================ void INetURLObject::SetExtension(rtl::OUString const & rTheExtension, EncodeMechanism eMechanism, rtl_TextEncoding eCharset) { setExtension(rTheExtension, LAST_SEGMENT, false, eMechanism, eCharset); } //============================================================================ rtl::OUString INetURLObject::CutExtension(DecodeMechanism eMechanism, rtl_TextEncoding eCharset) { rtl::OUString aTheExtension(getExtension(LAST_SEGMENT, false, eMechanism, eCharset)); return removeExtension(LAST_SEGMENT, false) ? aTheExtension : rtl::OUString(); } //============================================================================ bool INetURLObject::IsCaseSensitive() const { return true; }