22 #include "wine/port.h" 30 #include "wine/unicode.h" 34 #define NO_SHLWAPI_STREAM 81 {
URL_SCHEME_JAVASCRIPT, {
'j',
'a',
'v',
'a',
's',
'c',
'r',
'i',
'p',
't',0}},
82 {
URL_SCHEME_VBSCRIPT, {
'v',
'b',
's',
'c',
'r',
'i',
'p',
't',0}},
114 0x01, 0x0E, 0x6E, 0x19, 0x61, 0xAE, 0x84, 0x77, 0x8A, 0xAA, 0x7D, 0x76, 0x1B,
115 0xE9, 0x8C, 0x33, 0x57, 0xC5, 0xB1, 0x6B, 0xEA, 0xA9, 0x38, 0x44, 0x1E, 0x07,
116 0xAD, 0x49, 0xBC, 0x28, 0x24, 0x41, 0x31, 0xD5, 0x68, 0xBE, 0x39, 0xD3, 0x94,
117 0xDF, 0x30, 0x73, 0x0F, 0x02, 0x43, 0xBA, 0xD2, 0x1C, 0x0C, 0xB5, 0x67, 0x46,
118 0x16, 0x3A, 0x4B, 0x4E, 0xB7, 0xA7, 0xEE, 0x9D, 0x7C, 0x93, 0xAC, 0x90, 0xB0,
119 0xA1, 0x8D, 0x56, 0x3C, 0x42, 0x80, 0x53, 0x9C, 0xF1, 0x4F, 0x2E, 0xA8, 0xC6,
120 0x29, 0xFE, 0xB2, 0x55, 0xFD, 0xED, 0xFA, 0x9A, 0x85, 0x58, 0x23, 0xCE, 0x5F,
121 0x74, 0xFC, 0xC0, 0x36, 0xDD, 0x66, 0xDA, 0xFF, 0xF0, 0x52, 0x6A, 0x9E, 0xC9,
122 0x3D, 0x03, 0x59, 0x09, 0x2A, 0x9B, 0x9F, 0x5D, 0xA6, 0x50, 0x32, 0x22, 0xAF,
123 0xC3, 0x64, 0x63, 0x1A, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xBD, 0x79, 0x40,
124 0x4D, 0x48, 0xD0, 0xF5, 0x82, 0x7A, 0x8F, 0x37, 0x69, 0x86, 0x1D, 0xA4, 0xB9,
125 0xC2, 0xC1, 0xEF, 0x65, 0xF2, 0x05, 0xAB, 0x7E, 0x0B, 0x4A, 0x3B, 0x89, 0xE4,
126 0x6C, 0xBF, 0xE8, 0x8B, 0x06, 0x18, 0x51, 0x14, 0x7F, 0x11, 0x5B, 0x5C, 0xFB,
127 0x97, 0xE1, 0xCF, 0x15, 0x62, 0x71, 0x70, 0x54, 0xE2, 0x12, 0xD6, 0xC7, 0xBB,
128 0x0D, 0x20, 0x5E, 0xDC, 0xE0, 0xD4, 0xF7, 0xCC, 0xC4, 0x2B, 0xF9, 0xEC, 0x2D,
129 0xF4, 0x6F, 0xB6, 0x99, 0x88, 0x81, 0x5A, 0xD9, 0xCA, 0x13, 0xA5, 0xE7, 0x47,
130 0xE6, 0x8E, 0x60, 0xE3, 0x3E, 0xB3, 0xF6, 0x72, 0xA2, 0x35, 0xA0, 0xD7, 0xCD,
131 0xB4, 0x2F, 0x6D, 0x2C, 0x26, 0x1F, 0x95, 0x87, 0x00, 0xD8, 0x34, 0x3F, 0x17,
132 0x25, 0x45, 0x27, 0x75, 0x92, 0xB8, 0xA3, 0xC8, 0xDE, 0xEB, 0xF8, 0xF3, 0xDB,
133 0x0A, 0x98, 0x83, 0x7B, 0xE5, 0xCB, 0x4C, 0x78, 0xD1 };
169 if(
y->cbSize !=
sizeof(*
y))
175 if (*
ptr !=
':' ||
ptr <=
x+1) {
176 y->pszProtocol =
NULL;
181 y->cchProtocol =
ptr-
x;
182 y->pszSuffix =
ptr+1;
183 y->cchSuffix =
strlen(
y->pszSuffix);
203 if(
y->cbSize !=
sizeof(*
y))
209 if (*
ptr !=
':' ||
ptr <=
x+1) {
210 y->pszProtocol =
NULL;
215 y->cchProtocol =
ptr-
x;
216 y->pszSuffix =
ptr+1;
253 TRACE(
"(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n",
debugstr_a(pszUrl), pszCanonicalized,
254 pcchCanonicalized,
dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
256 if(!pszUrl || !pszCanonicalized || !pcchCanonicalized || !*pcchCanonicalized)
261 if(!
url || !canonical) {
290 DWORD nByteLen, nLen, nWkLen;
297 static const WCHAR wszLocalhost[] = {
'l',
'o',
'c',
'a',
'l',
'h',
'o',
's',
't'};
298 static const WCHAR wszFilePrefix[] = {
'f',
'i',
'l',
'e',
':',
'/',
'/',
'/'};
300 TRACE(
"(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n",
debugstr_w(pszUrl), pszCanonicalized,
301 pcchCanonicalized,
dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
303 if(!pszUrl || !pszCanonicalized || !pcchCanonicalized || !*pcchCanonicalized)
307 *pszCanonicalized = 0;
328 nByteLen+
sizeof(wszFilePrefix)+
sizeof(
WCHAR));
336 if ((nByteLen >=
sizeof(
wszHttp) &&
364 memcpy(wk2, wszFilePrefix,
sizeof(wszFilePrefix));
365 wk2 +=
sizeof(wszFilePrefix)/
sizeof(
WCHAR);
375 }
else if(
url[0] ==
'/') {
391 if (*wk1++ ==
':')
state = 2;
395 if (*wk1 !=
'/') {
state = 6;
break;}
399 && !
memcmp(wszLocalhost, wk1,
sizeof(wszLocalhost))){
400 wk1 +=
sizeof(wszLocalhost)/
sizeof(
WCHAR);
407 }
else if(is_file_url){
422 if(*wk1 ==
'/' && *(wk1+1) !=
'/'){
429 if(*wk1 ==
'/' && *(wk1+1) !=
'/'){
450 if(*mp ==
'/' || *mp ==
'\\')
457 if (!
isalnumW(*wk1) && (*wk1 !=
'-') && (*wk1 !=
'.') && (*wk1 !=
':'))
459 while(
isalnumW(*wk1) || (*wk1 ==
'-') || (*wk1 ==
'.') || (*wk1 ==
':'))
470 if (*wk1 !=
'/' && *wk1 !=
'\\') {
state = 3;
break;}
471 while(*wk1 ==
'/' || *wk1 ==
'\\') {
493 if(mp2 && (!mp || mp2 < mp))
514 while (*wk1 ==
'.') {
515 TRACE(
"found '/.'\n");
516 if (wk1[1] ==
'/' || wk1[1] ==
'\\') {
520 else if (wk1[1] ==
'.' && (wk1[2] ==
'/' 521 || wk1[2] ==
'\\' || wk1[2] ==
'?' 522 || wk1[2] ==
'#' || !wk1[2])) {
524 TRACE(
"found '/../'\n");
528 if(mp2 && (!mp || mp2 < mp))
530 if (mp && (mp >=
root)) {
533 if(wk1[2] !=
'/' && wk1[2] !=
'\\')
551 FIXME(
"how did we get here - state=%d\n",
state);
557 TRACE(
"Simplified, orig <%s>, simple <%s>\n",
561 while ((nLen > 0) && ((lpszUrlCpy[nLen-1] <=
' ')))
562 lpszUrlCpy[--nLen]=0;
575 hr =
UrlEscapeW(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
579 if(nLen < *pcchCanonicalized)
580 memcpy(pszCanonicalized, lpszUrlCpy, (nLen + 1)*
sizeof(
WCHAR));
585 *pcchCanonicalized = nLen;
621 TRACE(
"(base %s, Relative %s, Combine size %d, flags %08x) using W version\n",
623 pcchCombined?*pcchCombined:0,
dwFlags);
625 if(!pszBase || !pszRelative || !pcchCombined)
645 if (len2 > *pcchCombined) {
646 *pcchCombined = len2;
652 *pcchCombined = len2;
667 DWORD myflags, sizeloc = 0;
668 DWORD i,
len, res1, res2, process_case = 0;
669 LPWSTR work, preliminary, mbase, mrelative;
670 static const WCHAR myfilestr[] = {
'f',
'i',
'l',
'e',
':',
'/',
'/',
'/',
'\0'};
671 static const WCHAR fragquerystr[] = {
'#',
'?',0};
674 TRACE(
"(base %s, Relative %s, Combine size %d, flags %08x)\n",
676 pcchCombined?*pcchCombined:0,
dwFlags);
678 if(!pszBase || !pszRelative || !pcchCombined)
682 relative.
cbSize =
sizeof(relative);
704 TRACE(
"no scheme detected in Base\n");
711 for(
i=0;
i<
base.cchProtocol;
i++)
716 static const WCHAR wsz[] = {
':',
':',0};
724 base.cchProtocol += delta;
725 base.pszSuffix += delta;
726 base.cchSuffix -= delta;
732 if (*work++ ==
'/') {
733 if (*work++ ==
'/') {
737 while(*work && (*work !=
'/')) work++;
738 sizeloc = (
DWORD)(work -
base.pszSuffix);
749 if ((work =
strpbrkW(
base.pszSuffix + sizeloc, fragquerystr))) {
750 const WCHAR htmlW[] = {
'.',
'h',
't',
'm',
'l',0};
751 const int len_htmlW = 5;
752 const WCHAR htmW[] = {
'.',
'h',
't',
'm',0};
753 const int len_htmW = 4;
756 manual_search =
TRUE;
757 else if (work -
base.pszSuffix > len_htmW) {
759 if (
strncmpiW(work, htmW, len_htmW) == 0)
760 manual_search =
TRUE;
764 if (!manual_search &&
765 work -
base.pszSuffix > len_htmlW) {
767 if (
strncmpiW(work, htmlW, len_htmlW) == 0)
768 manual_search =
TRUE;
775 while (*work !=
'/' && work >
base.pszSuffix + sizeloc)
777 base.cchSuffix = work -
base.pszSuffix + 1;
785 base.cchSuffix = sizeloc;
800 TRACE(
"no scheme detected in Relative\n");
803 if (*pszRelative ==
':') {
812 if (
isalnumW(*mrelative) && (*(mrelative + 1) ==
':')) {
814 strcpyW(preliminary, myfilestr);
818 if ((*mrelative ==
'/') && (*(mrelative+1) ==
'/')) {
823 if (*mrelative ==
'/') {
828 if (*mrelative ==
'#') {
833 preliminary[work-
base.pszProtocol] =
'\0';
862 process_case = (*
base.pszSuffix ==
'/') ? 5 : 1;
877 switch (process_case) {
883 strcatW(preliminary, mrelative);
887 strcpyW(preliminary, mrelative);
895 work = preliminary +
base.cchProtocol + 1;
905 work = preliminary +
base.cchProtocol + 1 + sizeloc;
917 work = preliminary +
base.cchProtocol+1+
base.cchSuffix - 1;
927 FIXME(
"How did we get here????? process_case=%d\n", process_case);
933 if(*pcchCombined == 0)
939 TRACE(
"return-%d len=%d, %s\n",
940 process_case, *pcchCombined,
debugstr_w(pszCombined));
957 WCHAR *escapedW = bufW;
960 DWORD lenW =
sizeof(bufW)/
sizeof(
WCHAR), lenA;
962 if (!pszEscaped || !pcchEscaped || !*pcchEscaped)
977 if(*pcchEscaped > lenA) {
979 pszEscaped[lenA] = 0;
982 *pcchEscaped = lenA + 1;
991 #define WINE_URL_BASH_AS_SLASH 0x01 992 #define WINE_URL_COLLAPSE_SLASHES 0x02 993 #define WINE_URL_ESCAPE_SLASH 0x04 994 #define WINE_URL_ESCAPE_HASH 0x08 995 #define WINE_URL_ESCAPE_QUESTION 0x10 996 #define WINE_URL_STOP_ON_HASH 0x20 997 #define WINE_URL_STOP_ON_QUESTION 0x40 1010 if (ch <= 31 || (ch >= 127 && ch <= 255) )
1090 static const WCHAR localhost[] = {
'l',
'o',
'c',
'a',
'l',
'h',
'o',
's',
't',0};
1093 pszEscaped, pcchEscaped,
dwFlags);
1095 if(!pszUrl || !pcchEscaped || !pszEscaped || *pcchEscaped == 0)
1125 parsed_url.
cbSize =
sizeof(parsed_url);
1163 for(
src = pszUrl; *
src; ) {
1169 while(
cur ==
'/' ||
cur ==
'\\') {
1174 if(*(
src + localhost_len) ==
'/' || *(
src + localhost_len) ==
'\\')
1175 src += localhost_len + 1;
1197 stop_escaping =
TRUE;
1200 stop_escaping =
TRUE;
1208 if ((
cur >= 0xd800 &&
cur <= 0xdfff) &&
1209 (
src[1] >= 0xdc00 &&
src[1] <= 0xdfff))
1236 for(
i = 0;
i <
len;
i++) {
1255 if(needed +
len <= *pcchEscaped) {
1262 if(needed < *pcchEscaped) {
1264 memcpy(pszEscaped, dst_ptr, (needed+1)*
sizeof(
WCHAR));
1271 *pcchEscaped = needed;
1319 if (!pszUnescaped || !pcchUnescaped)
return E_INVALIDARG;
1323 for(
src = pszUrl, needed = 0; *
src;
src++, needed++) {
1325 (*
src ==
'#' || *
src ==
'?')) {
1326 stop_unescaping =
TRUE;
1329 && stop_unescaping ==
FALSE) {
1352 *pcchUnescaped = needed;
1388 if (!pszUnescaped || !pcchUnescaped)
return E_INVALIDARG;
1392 for(
src = pszUrl, needed = 0; *
src;
src++, needed++) {
1394 (*
src ==
'#' || *
src ==
'?')) {
1395 stop_unescaping =
TRUE;
1398 && stop_unescaping ==
FALSE) {
1421 *pcchUnescaped = needed;
1465 if (res1)
return NULL;
1487 if (res1)
return NULL;
1518 return strcmp(pszUrl1, pszUrl2);
1520 if (pszUrl1[len1-1] ==
'/') len1--;
1522 if (pszUrl2[len2-1] ==
'/') len2--;
1524 return strncmp(pszUrl1, pszUrl2, len1);
1528 if (len1 > len2)
return 1;
1543 size_t len, len1, len2;
1546 return strcmpW(pszUrl1, pszUrl2);
1548 if (pszUrl1[len1-1] ==
'/') len1--;
1550 if (pszUrl2[len2-1] ==
'/') len2--;
1552 return strncmpW(pszUrl1, pszUrl2, len1);
1556 if (len1 > len2)
return 1;
1576 unsigned char *lpDest,
DWORD nDestLen)
1578 INT srcCount = nSrcLen - 1, destCount = nDestLen - 1;
1580 if (!lpSrc || !lpDest)
1583 while (destCount >= 0)
1585 lpDest[destCount] = (destCount & 0xff);
1589 while (srcCount >= 0)
1591 destCount = nDestLen - 1;
1592 while (destCount >= 0)
1594 lpDest[destCount] =
HashDataLookup[lpSrc[srcCount] ^ lpDest[destCount]];
1669 pszOut, pcchOut, pcchOut ? *pcchOut : 0,
dwFlags);
1671 if (!pszIn || !pszOut || !pcchOut)
return E_INVALIDARG;
1687 if (
len > *pcchOut) {
1706 DWORD value_len, data_len, dwType,
i;
1712 "Software\\Microsoft\\Windows\\CurrentVersion\\URL\\Prefixes",
1716 while(value_len = data_len =
MAX_PATH,
1719 TRACE(
"guess %d %s is %s\n",
1723 for(
i=0;
i<value_len;
i++) {
1730 if ((
i == value_len) && !
j) {
1754 WCHAR file_colonW[] = {
'f',
'i',
'l',
'e',
':',0};
1755 WCHAR three_slashesW[] = {
'/',
'/',
'/',0};
1758 parsed_url.
cbSize =
sizeof(parsed_url);
1762 if (needed >= *pcchUrl) {
1763 *pcchUrl = needed + 1;
1773 strcpyW(pszNewUrl, file_colonW);
1774 if(
isalphaW(pszPath[0]) && pszPath[1] ==
':')
1775 strcatW(pszNewUrl, three_slashesW);
1785 DWORD data_len, dwType;
1788 static const WCHAR prefix_keyW[] =
1789 {
'S',
'o',
'f',
't',
'w',
'a',
'r',
'e',
1790 '\\',
'M',
'i',
'c',
'r',
'o',
's',
'o',
'f',
't',
1791 '\\',
'W',
'i',
'n',
'd',
'o',
'w',
's',
1792 '\\',
'C',
'u',
'r',
'r',
'e',
'n',
't',
'V',
'e',
'r',
's',
'i',
'o',
'n',
1794 '\\',
'D',
'e',
'f',
'a',
'u',
'l',
't',
'P',
'r',
'e',
'f',
'i',
'x',0};
1798 data_len =
sizeof(
data);
1824 pszOut, pcchOut, pcchOut ? *pcchOut : 0,
dwFlags);
1826 if (!pszIn || !pszOut || !pcchOut)
return E_INVALIDARG;
1829 if (*pcchOut > 1 &&
':' == pszIn[1]) {
1843 in_scheme.
cbSize =
sizeof(in_scheme);
1896 if (res1)
return FALSE;
1897 switch (
base.nScheme)
1914 return (
last >= pszUrl && (*
last ==
'/' || *
last ==
'\\' ));
1935 static const WCHAR file_colon[] = {
'f',
'i',
'l',
'e',
':',0 };
1950 if (res1)
return FALSE;
1951 switch (
base.nScheme)
1968 return (
last >= pszUrl && (*
last ==
'/' || *
last ==
'\\'));
2047 static DWORD alwayszero = 0;
2098 }
else if (*
start ==
'%') {
2137 return (
LPWSTR)&alwayszero;
2154 if (!*work || (*work !=
':'))
goto ErrorExit;
2156 if ((*work !=
'/') || (*(work+1) !=
'/'))
goto SuccessExit;
2159 if (*work ==
':' ) {
2171 }
else if (*work ==
'@') {
2175 }
else if (!*work || (*work ==
'/') || (*work ==
'.')) {
2198 TRACE(
"parse successful: scheme=%p(%d), user=%p(%d), pass=%p(%d), host=%p(%d), port=%p(%d), query=%p(%d)\n",
2235 if(!pszIn || !pszOut || !pcchOut || *pcchOut <= 0)
2253 if (len2 > *pcchOut) {
2277 TRACE(
"(%s %p %p(%d) %08x %08x)\n",
2280 if(!pszIn || !pszOut || !pcchOut || *pcchOut <= 0)
2379 if (*pcchOut < schsize +
size + 2) {
2380 *pcchOut = schsize +
size + 2;
2384 pszOut[schsize] =
':';
2386 pszOut[schsize+1+
size] = 0;
2387 *pcchOut = schsize + 1 +
size;
2419 if (!lpstrPath || !*lpstrPath)
return FALSE;
2439 if (!lpstrPath || !*lpstrPath)
return FALSE;
2458 DWORD lenW =
sizeof(bufW)/
sizeof(
WCHAR), lenA;
2468 if(*pcchUrl > lenA) {
2473 *pcchUrl = lenA + 1;
2506 if (!pszUrl || !pcchUrl)
2568 if (dwDestLen >
sizeof(szLibName)/
sizeof(
WCHAR))
2569 dwDestLen =
sizeof(szLibName)/
sizeof(
WCHAR);
2587 static const WCHAR szRes[] = {
'r',
'e',
's',
':',
'/',
'/',
'\0' };
2588 #define szResLen ((sizeof(szRes) - sizeof(WCHAR))/sizeof(WCHAR)) 2615 if (dwDestLen >= dwPathLen)
2619 dwDestLen -= dwPathLen;
2622 dwResLen =
strlenW(lpszRes) + 1;
2623 if (dwDestLen >= dwResLen + 1)
2664 lstrcpynW(translatedUrl,
url, (maxChars < srcLen) ? maxChars : srcLen);
#define URL_APPLY_FORCEAPPLY
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
static const WCHAR wszHttp[]
HRESULT WINAPI UrlCreateFromPathA(LPCSTR pszPath, LPSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
#define WINE_URL_ESCAPE_QUESTION
WINE_UNICODE_INLINE int islowerW(WCHAR wc)
HRESULT WINAPI UrlEscapeW(LPCWSTR pszUrl, LPWSTR pszEscaped, LPDWORD pcchEscaped, DWORD dwFlags)
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
#define WINE_URL_STOP_ON_HASH
#define WideCharToMultiByte
HRESULT WINAPI UrlApplySchemeA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
ACPI_SIZE strlen(const char *String)
static BOOL URL_NeedEscapeW(WCHAR ch, DWORD flags, DWORD int_flags)
HRESULT WINAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwPart, DWORD dwFlags)
WINE_UNICODE_INLINE WCHAR * strchrW(const WCHAR *str, WCHAR ch)
#define URL_UNESCAPE_INPLACE
#define WINE_URL_COLLAPSE_SLASHES
HRESULT WINAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized, LPDWORD pcchCanonicalized, DWORD dwFlags)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeToMultiByteSize(PULONG MbSize, PCWCH UnicodeString, ULONG UnicodeSize)
#define INTERNET_MAX_SCHEME_LENGTH
#define URL_DONT_UNESCAPE_EXTRA_INFO
HRESULT WINAPI ParseURLA(LPCSTR x, PARSEDURLA *y)
static const BYTE localhost[]
BOOL WINAPI UrlIsOpaqueA(LPCSTR pszUrl)
#define INVALID_HANDLE_VALUE
HRESULT WINAPI HashData(const unsigned char *lpSrc, DWORD nSrcLen, unsigned char *lpDest, DWORD nDestLen)
GLint GLint GLint GLint GLint x
#define URL_ESCAPE_AS_UTF8
#define strncmpiW(s1, s2, n)
_Check_return_ _CRTIMP int __cdecl isalnum(_In_ int _C)
BOOL WINAPI UrlIsNoHistoryW(LPCWSTR pszUrl)
WINE_UNICODE_INLINE int strncmpW(const WCHAR *str1, const WCHAR *str2, int n)
BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
HRESULT WINAPI UrlUnescapeW(LPWSTR pszUrl, LPWSTR pszUnescaped, LPDWORD pcchUnescaped, DWORD dwFlags)
static LPCWSTR URL_ScanID(LPCWSTR start, LPDWORD size, WINE_URL_SCAN_TYPE type)
GLenum GLuint GLenum GLsizei const GLchar * buf
HRESULT WINAPI UrlUnescapeA(LPSTR pszUrl, LPSTR pszUnescaped, LPDWORD pcchUnescaped, DWORD dwFlags)
LONG WINAPI RegCloseKey(HKEY hKey)
static const CHAR hexDigits[]
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
static const WCHAR wszFile[]
static HRESULT URL_CreateFromPath(LPCWSTR pszPath, LPWSTR pszUrl, LPDWORD pcchUrl)
BOOL WINAPI UrlIsA(LPCSTR pszUrl, URLIS Urlis)
LONG WINAPI RegEnumValueW(_In_ HKEY hKey, _In_ DWORD index, _Out_ LPWSTR value, _Inout_ PDWORD val_count, _Reserved_ PDWORD reserved, _Out_opt_ PDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ PDWORD count)
#define WINE_URL_ESCAPE_HASH
#define INTERNET_MAX_URL_LENGTH
#define URL_WININET_COMPATIBILITY
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
#define URL_E_INVALID_SYNTAX
#define WINE_URL_STOP_ON_QUESTION
#define URL_PARTFLAG_KEEPSCHEME
#define URL_ESCAPE_SEGMENT_ONLY
WINE_DEFAULT_DEBUG_CHANNEL(shell)
HRESULT WINAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwPart, DWORD dwFlags)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
INT WINAPI CompareStringW(LCID lcid, DWORD flags, LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)
HRESULT WINAPI MLBuildResURLA(LPCSTR lpszLibName, HMODULE hMod, DWORD dwFlags, LPCSTR lpszRes, LPSTR lpszDest, DWORD dwDestLen)
BOOL WINAPI UrlIsOpaqueW(LPCWSTR pszUrl)
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
HRESULT WINAPI UrlCreateFromPathW(LPCWSTR pszPath, LPWSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
#define URL_APPLY_DEFAULT
static const unsigned char HashDataLookup[256]
HRESULT WINAPI UrlHashA(LPCSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
WINE_UNICODE_INLINE WCHAR * strpbrkW(const WCHAR *str, const WCHAR *accept)
#define WC_ERR_INVALID_CHARS
HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized, LPDWORD pcchCanonicalized, DWORD dwFlags)
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
WINE_UNICODE_INLINE WCHAR tolowerW(WCHAR ch)
INT WINAPI UrlCompareW(LPCWSTR pszUrl1, LPCWSTR pszUrl2, BOOL fIgnoreSlash)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
#define URL_FILE_USE_PATHURL
BOOL WINAPI IsInternetESCEnabled(void)
BOOL WINAPI StrToIntExW(LPCWSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
WINE_UNICODE_INLINE int isxdigitW(WCHAR wc)
BOOL WINAPI UrlIsNoHistoryA(LPCSTR pszUrl)
static HRESULT URL_ApplyDefault(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeToMultiByteN(PCHAR MbString, ULONG MbSize, PULONG ResultSize, PCWCH UnicodeString, ULONG UnicodeSize)
HRESULT WINAPI ParseURLW(LPCWSTR x, PARSEDURLW *y)
static const struct @548 shlwapi_schemes[]
GLenum const GLvoid * addr
static LONG URL_ParseUrl(LPCWSTR pszUrl, WINE_PARSE_URL *pl)
HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
#define URL_DONT_SIMPLIFY
#define WINE_URL_BASH_AS_SLASH
#define memcpy(s1, s2, n)
#define WINE_URL_ESCAPE_SLASH
HMODULE WINAPI MLLoadLibraryW(LPCWSTR, HMODULE, DWORD)
HRESULT WINAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative, LPSTR pszCombined, LPDWORD pcchCombined, DWORD dwFlags)
BOOL WINAPI UrlIsW(LPCWSTR pszUrl, URLIS Urlis)
static DWORD get_scheme_code(LPCWSTR scheme, DWORD scheme_len)
LPCWSTR WINAPI UrlGetLocationW(LPCWSTR pszUrl)
WINE_UNICODE_INLINE int isalnumW(WCHAR wc)
HRESULT WINAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative, LPWSTR pszCombined, LPDWORD pcchCombined, DWORD dwFlags)
#define URL_ESCAPE_PERCENT
#define URL_ESCAPE_UNSAFE
WINE_UNICODE_INLINE WCHAR * strrchrW(const WCHAR *str, WCHAR ch)
INT WINAPI UrlCompareA(LPCSTR pszUrl1, LPCSTR pszUrl2, BOOL fIgnoreSlash)
static WCHAR * heap_strdupAtoW(const char *str)
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
static unsigned __int64 next
BOOL NTAPI IsBadStringPtrA(IN LPCSTR lpsz, IN UINT_PTR ucchMax)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
void shell(int argc, const char *argv[])
static VOID ErrorExit(LPTSTR lpszMessage)
WINE_UNICODE_INLINE WCHAR * strcatW(WCHAR *dst, const WCHAR *src)
WINE_UNICODE_INLINE int isdigitW(WCHAR wc)
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
HRESULT WINAPI UrlEscapeA(LPCSTR pszUrl, LPSTR pszEscaped, LPDWORD pcchEscaped, DWORD dwFlags)
BOOL NTAPI IsBadStringPtrW(IN LPCWSTR lpsz, IN UINT_PTR ucchMax)
LPCSTR WINAPI UrlGetLocationA(LPCSTR pszUrl)
GLint GLint GLint GLint GLint GLint y
#define MultiByteToWideChar
HRESULT WINAPI MLBuildResURLW(LPCWSTR, HMODULE, DWORD, LPCWSTR, LPWSTR, DWORD)
char * strchr(const char *String, int ch)
#define URL_APPLY_GUESSSCHEME
HRESULT WINAPI UrlHashW(LPCWSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
_Check_return_ long __cdecl strtol(_In_z_ const char *_Str, _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix)
WINE_UNICODE_INLINE int strcmpW(const WCHAR *str1, const WCHAR *str2)
static const WCHAR wszRes[]
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
int strcmp(const char *String1, const char *String2)
BOOL WINAPI MLFreeLibrary(HMODULE)
char * cleanup(char *str)
HRESULT WINAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags)
GLuint GLuint GLsizei GLenum type
#define memicmpW(s1, s2, n)
WINE_UNICODE_INLINE int isalphaW(WCHAR wc)
#define URL_ESCAPE_SPACES_ONLY
#define URL_APPLY_GUESSFILE
#define URL_PLUGGABLE_PROTOCOL
static HRESULT URL_GuessScheme(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
static const WCHAR fileW[]
HRESULT WINAPI UrlFixupW(LPCWSTR url, LPWSTR translatedUrl, DWORD maxChars)
#define HeapFree(x, y, z)
#define URL_DONT_ESCAPE_EXTRA_INFO
BOOL WINAPI ChrCmpIW(WCHAR ch1, WCHAR ch2)
#define HKEY_LOCAL_MACHINE