?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shlwapi: UrlCanonicalize should strip all the characters <= 32 from the end of the...
[wine/gsoc_dplay.git] / dlls / shlwapi / url.c
blob2efe38694666700838d8418bfb1f5a1e69fdc1ba
1 /*
2 * Url functions
3 *
4 * Copyright 2000 Huw D M Davies for CodeWeavers.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23 #include <stdarg.h>
24 #include <string.h>
25 #include <stdlib.h>
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winnls.h"
29 #include "winerror.h"
30 #include "wine/unicode.h"
31 #include "wininet.h"
32 #include "winreg.h"
33 #include "winternl.h"
34 #define NO_SHLWAPI_STREAM
35 #include "shlwapi.h"
36 #include "wine/debug.h"
37
38 HMODULE WINAPI MLLoadLibraryW(LPCWSTR,HMODULE,DWORD);
39 BOOL WINAPI MLFreeLibrary(HMODULE);
40 HRESULT WINAPI MLBuildResURLW(LPCWSTR,HMODULE,DWORD,LPCWSTR,LPWSTR,DWORD);
41
42 WINE_DEFAULT_DEBUG_CHANNEL(shell);
43
44 /* The following schemes were identified in the native version of
45 * SHLWAPI.DLL version 5.50
46 */
47 static const struct {
48 URL_SCHEME scheme_number;
49 WCHAR scheme_name[12];
50 } shlwapi_schemes[] = {
51 {URL_SCHEME_FTP, {'f','t','p',0}},
52 {URL_SCHEME_HTTP, {'h','t','t','p',0}},
53 {URL_SCHEME_GOPHER, {'g','o','p','h','e','r',0}},
54 {URL_SCHEME_MAILTO, {'m','a','i','l','t','o',0}},
55 {URL_SCHEME_NEWS, {'n','e','w','s',0}},
56 {URL_SCHEME_NNTP, {'n','n','t','p',0}},
57 {URL_SCHEME_TELNET, {'t','e','l','n','e','t',0}},
58 {URL_SCHEME_WAIS, {'w','a','i','s',0}},
59 {URL_SCHEME_FILE, {'f','i','l','e',0}},
60 {URL_SCHEME_MK, {'m','k',0}},
61 {URL_SCHEME_HTTPS, {'h','t','t','p','s',0}},
62 {URL_SCHEME_SHELL, {'s','h','e','l','l',0}},
63 {URL_SCHEME_SNEWS, {'s','n','e','w','s',0}},
64 {URL_SCHEME_LOCAL, {'l','o','c','a','l',0}},
65 {URL_SCHEME_JAVASCRIPT, {'j','a','v','a','s','c','r','i','p','t',0}},
66 {URL_SCHEME_VBSCRIPT, {'v','b','s','c','r','i','p','t',0}},
67 {URL_SCHEME_ABOUT, {'a','b','o','u','t',0}},
68 {URL_SCHEME_RES, {'r','e','s',0}},
69 };
70
71 typedef struct {
72 LPCWSTR pScheme; /* [out] start of scheme */
73 DWORD szScheme; /* [out] size of scheme (until colon) */
74 LPCWSTR pUserName; /* [out] start of Username */
75 DWORD szUserName; /* [out] size of Username (until ":" or "@") */
76 LPCWSTR pPassword; /* [out] start of Password */
77 DWORD szPassword; /* [out] size of Password (until "@") */
78 LPCWSTR pHostName; /* [out] start of Hostname */
79 DWORD szHostName; /* [out] size of Hostname (until ":" or "/") */
80 LPCWSTR pPort; /* [out] start of Port */
81 DWORD szPort; /* [out] size of Port (until "/" or eos) */
82 LPCWSTR pQuery; /* [out] start of Query */
83 DWORD szQuery; /* [out] size of Query (until eos) */
84 } WINE_PARSE_URL;
85
86 typedef enum {
87 SCHEME,
88 HOST,
89 PORT,
90 USERPASS,
91 } WINE_URL_SCAN_TYPE;
92
93 static const CHAR hexDigits[] = "0123456789ABCDEF";
94
95 static const WCHAR fileW[] = {'f','i','l','e','\0'};
96
97 static const unsigned char HashDataLookup[256] = {
98 0x01, 0x0E, 0x6E, 0x19, 0x61, 0xAE, 0x84, 0x77, 0x8A, 0xAA, 0x7D, 0x76, 0x1B,
99 0xE9, 0x8C, 0x33, 0x57, 0xC5, 0xB1, 0x6B, 0xEA, 0xA9, 0x38, 0x44, 0x1E, 0x07,
100 0xAD, 0x49, 0xBC, 0x28, 0x24, 0x41, 0x31, 0xD5, 0x68, 0xBE, 0x39, 0xD3, 0x94,
101 0xDF, 0x30, 0x73, 0x0F, 0x02, 0x43, 0xBA, 0xD2, 0x1C, 0x0C, 0xB5, 0x67, 0x46,
102 0x16, 0x3A, 0x4B, 0x4E, 0xB7, 0xA7, 0xEE, 0x9D, 0x7C, 0x93, 0xAC, 0x90, 0xB0,
103 0xA1, 0x8D, 0x56, 0x3C, 0x42, 0x80, 0x53, 0x9C, 0xF1, 0x4F, 0x2E, 0xA8, 0xC6,
104 0x29, 0xFE, 0xB2, 0x55, 0xFD, 0xED, 0xFA, 0x9A, 0x85, 0x58, 0x23, 0xCE, 0x5F,
105 0x74, 0xFC, 0xC0, 0x36, 0xDD, 0x66, 0xDA, 0xFF, 0xF0, 0x52, 0x6A, 0x9E, 0xC9,
106 0x3D, 0x03, 0x59, 0x09, 0x2A, 0x9B, 0x9F, 0x5D, 0xA6, 0x50, 0x32, 0x22, 0xAF,
107 0xC3, 0x64, 0x63, 0x1A, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xBD, 0x79, 0x40,
108 0x4D, 0x48, 0xD0, 0xF5, 0x82, 0x7A, 0x8F, 0x37, 0x69, 0x86, 0x1D, 0xA4, 0xB9,
109 0xC2, 0xC1, 0xEF, 0x65, 0xF2, 0x05, 0xAB, 0x7E, 0x0B, 0x4A, 0x3B, 0x89, 0xE4,
110 0x6C, 0xBF, 0xE8, 0x8B, 0x06, 0x18, 0x51, 0x14, 0x7F, 0x11, 0x5B, 0x5C, 0xFB,
111 0x97, 0xE1, 0xCF, 0x15, 0x62, 0x71, 0x70, 0x54, 0xE2, 0x12, 0xD6, 0xC7, 0xBB,
112 0x0D, 0x20, 0x5E, 0xDC, 0xE0, 0xD4, 0xF7, 0xCC, 0xC4, 0x2B, 0xF9, 0xEC, 0x2D,
113 0xF4, 0x6F, 0xB6, 0x99, 0x88, 0x81, 0x5A, 0xD9, 0xCA, 0x13, 0xA5, 0xE7, 0x47,
114 0xE6, 0x8E, 0x60, 0xE3, 0x3E, 0xB3, 0xF6, 0x72, 0xA2, 0x35, 0xA0, 0xD7, 0xCD,
115 0xB4, 0x2F, 0x6D, 0x2C, 0x26, 0x1F, 0x95, 0x87, 0x00, 0xD8, 0x34, 0x3F, 0x17,
116 0x25, 0x45, 0x27, 0x75, 0x92, 0xB8, 0xA3, 0xC8, 0xDE, 0xEB, 0xF8, 0xF3, 0xDB,
117 0x0A, 0x98, 0x83, 0x7B, 0xE5, 0xCB, 0x4C, 0x78, 0xD1 };
118
119 static DWORD get_scheme_code(LPCWSTR scheme, DWORD scheme_len)
120 {
121 int i;
122
123 for(i=0; i < sizeof(shlwapi_schemes)/sizeof(shlwapi_schemes[0]); i++) {
124 if(scheme_len == strlenW(shlwapi_schemes[i].scheme_name)
125 && !memcmp(scheme, shlwapi_schemes[i].scheme_name, scheme_len*sizeof(WCHAR)))
126 return shlwapi_schemes[i].scheme_number;
127 }
128
129 return URL_SCHEME_UNKNOWN;
130 }
131
132 static BOOL URL_JustLocation(LPCWSTR str)
133 {
134 while(*str && (*str == '/')) str++;
135 if (*str) {
136 while (*str && ((*str == '-') ||
137 (*str == '.') ||
138 isalnumW(*str))) str++;
139 if (*str == '/') return FALSE;
140 }
141 return TRUE;
142 }
143
144
145 /*************************************************************************
146 * @ [SHLWAPI.1]
147 *
148 * Parse a Url into its constituent parts.
149 *
150 * PARAMS
151 * x [I] Url to parse
152 * y [O] Undocumented structure holding the parsed information
153 *
154 * RETURNS
155 * Success: S_OK. y contains the parsed Url details.
156 * Failure: An HRESULT error code.
157 */
158 HRESULT WINAPI ParseURLA(LPCSTR x, PARSEDURLA *y)
159 {
160 WCHAR scheme[INTERNET_MAX_SCHEME_LENGTH];
161 DWORD cnt, len;
162
163 y->nScheme = URL_SCHEME_INVALID;
164 if (y->cbSize != sizeof(*y)) return E_INVALIDARG;
165 /* FIXME: leading white space generates error of 0x80041001 which
166 * is undefined
167 */
168 if (*x <= ' ') return 0x80041001;
169 cnt = 0;
170 y->cchProtocol = 0;
171 y->pszProtocol = x;
172 while (*x) {
173 if (*x == ':') {
174 y->cchProtocol = cnt;
175 cnt = -1;
176 y->pszSuffix = x+1;
177 break;
178 }
179 x++;
180 cnt++;
181 }
182
183 /* check for no scheme in string start */
184 /* (apparently schemes *must* be larger than a single character) */
185 if ((*x == '\0') || (y->cchProtocol <= 1)) {
186 y->pszProtocol = NULL;
187 return 0x80041001;
188 }
189
190 /* found scheme, set length of remainder */
191 y->cchSuffix = lstrlenA(y->pszSuffix);
192
193 len = MultiByteToWideChar(CP_ACP, 0, y->pszProtocol, y->cchProtocol,
194 scheme, sizeof(scheme)/sizeof(WCHAR));
195 y->nScheme = get_scheme_code(scheme, len);
196
197 return S_OK;
198 }
199
200 /*************************************************************************
201 * @ [SHLWAPI.2]
202 *
203 * Unicode version of ParseURLA.
204 */
205 HRESULT WINAPI ParseURLW(LPCWSTR x, PARSEDURLW *y)
206 {
207 DWORD cnt;
208
209 y->nScheme = URL_SCHEME_INVALID;
210 if (y->cbSize != sizeof(*y)) return E_INVALIDARG;
211 /* FIXME: leading white space generates error of 0x80041001 which
212 * is undefined
213 */
214 if (*x <= ' ') return 0x80041001;
215 cnt = 0;
216 y->cchProtocol = 0;
217 y->pszProtocol = x;
218 while (*x) {
219 if (*x == ':') {
220 y->cchProtocol = cnt;
221 cnt = -1;
222 y->pszSuffix = x+1;
223 break;
224 }
225 x++;
226 cnt++;
227 }
228
229 /* check for no scheme in string start */
230 /* (apparently schemes *must* be larger than a single character) */
231 if ((*x == '\0') || (y->cchProtocol <= 1)) {
232 y->pszProtocol = NULL;
233 return 0x80041001;
234 }
235
236 /* found scheme, set length of remainder */
237 y->cchSuffix = lstrlenW(y->pszSuffix);
238 y->nScheme = get_scheme_code(y->pszProtocol, y->cchProtocol);
239
240 return S_OK;
241 }
242
243 /*************************************************************************
244 * UrlCanonicalizeA [SHLWAPI.@]
245 *
246 * Canonicalize a Url.
247 *
248 * PARAMS
249 * pszUrl [I] Url to cCanonicalize
250 * pszCanonicalized [O] Destination for converted Url.
251 * pcchCanonicalized [I/O] Length of pszUrl, destination for length of pszCanonicalized
252 * dwFlags [I] Flags controlling the conversion.
253 *
254 * RETURNS
255 * Success: S_OK. The pszCanonicalized contains the converted Url.
256 * Failure: E_POINTER, if *pcchCanonicalized is too small.
257 *
258 * MSDN incorrectly describes the flags for this function. They should be:
259 *| URL_DONT_ESCAPE_EXTRA_INFO 0x02000000
260 *| URL_ESCAPE_SPACES_ONLY 0x04000000
261 *| URL_ESCAPE_PERCENT 0x00001000
262 *| URL_ESCAPE_UNSAFE 0x10000000
263 *| URL_UNESCAPE 0x10000000
264 *| URL_DONT_SIMPLIFY 0x08000000
265 *| URL_ESCAPE_SEGMENT_ONLY 0x00002000
266 */
267 HRESULT WINAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized,
268 LPDWORD pcchCanonicalized, DWORD dwFlags)
269 {
270 LPWSTR base, canonical;
271 HRESULT ret;
272 DWORD len, len2;
273
274 TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_a(pszUrl), pszCanonicalized,
275 pcchCanonicalized, dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
276
277 if(!pszUrl || !pszCanonicalized || !pcchCanonicalized)
278 return E_INVALIDARG;
279
280 base = HeapAlloc(GetProcessHeap(), 0,
281 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
282 canonical = base + INTERNET_MAX_URL_LENGTH;
283
284 MultiByteToWideChar(0, 0, pszUrl, -1, base, INTERNET_MAX_URL_LENGTH);
285 len = INTERNET_MAX_URL_LENGTH;
286
287 ret = UrlCanonicalizeW(base, canonical, &len, dwFlags);
288 if (ret != S_OK) {
289 *pcchCanonicalized = len * 2;
290 HeapFree(GetProcessHeap(), 0, base);
291 return ret;
292 }
293
294 len2 = WideCharToMultiByte(0, 0, canonical, -1, 0, 0, 0, 0);
295 if (len2 > *pcchCanonicalized) {
296 *pcchCanonicalized = len2;
297 HeapFree(GetProcessHeap(), 0, base);
298 return E_POINTER;
299 }
300 WideCharToMultiByte(0, 0, canonical, -1, pszCanonicalized, *pcchCanonicalized, 0, 0);
301 *pcchCanonicalized = len;
302 HeapFree(GetProcessHeap(), 0, base);
303 return S_OK;
304 }
305
306 /*************************************************************************
307 * UrlCanonicalizeW [SHLWAPI.@]
308 *
309 * See UrlCanonicalizeA.
310 */
311 HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized,
312 LPDWORD pcchCanonicalized, DWORD dwFlags)
313 {
314 HRESULT hr = S_OK;
315 DWORD EscapeFlags;
316 LPWSTR lpszUrlCpy, wk1, wk2, mp, mp2, root;
317 INT nByteLen, state;
318 DWORD nLen, nWkLen;
319 WCHAR slash = '/';
320
321 static const WCHAR wszFile[] = {'f','i','l','e',':'};
322 static const WCHAR wszLocalhost[] = {'l','o','c','a','l','h','o','s','t'};
323
324 TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_w(pszUrl), pszCanonicalized,
325 pcchCanonicalized, dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
326
327 if(!pszUrl || !pszCanonicalized || !pcchCanonicalized)
328 return E_INVALIDARG;
329
330 if(!*pszUrl) {
331 *pszCanonicalized = 0;
332 return S_OK;
333 }
334
335 nByteLen = (lstrlenW(pszUrl) + 1) * sizeof(WCHAR); /* length in bytes */
336 lpszUrlCpy = HeapAlloc(GetProcessHeap(), 0,
337 INTERNET_MAX_URL_LENGTH * sizeof(WCHAR));
338
339 if((dwFlags & URL_FILE_USE_PATHURL) && nByteLen >= sizeof(wszFile)
340 && !memcmp(wszFile, pszUrl, sizeof(wszFile)))
341 slash = '\\';
342
343 /*
344 * state =
345 * 0 initial 1,3
346 * 1 have 2[+] alnum 2,3
347 * 2 have scheme (found :) 4,6,3
348 * 3 failed (no location)
349 * 4 have // 5,3
350 * 5 have 1[+] alnum 6,3
351 * 6 have location (found /) save root location
352 */
353
354 wk1 = (LPWSTR)pszUrl;
355 wk2 = lpszUrlCpy;
356 state = 0;
357
358 if(pszUrl[1] == ':') { /* Assume path */
359 static const WCHAR wszFilePrefix[] = {'f','i','l','e',':','/','/','/'};
360
361 memcpy(wk2, wszFilePrefix, sizeof(wszFilePrefix));
362 wk2 += sizeof(wszFilePrefix)/sizeof(WCHAR);
363 if (dwFlags & URL_FILE_USE_PATHURL)
364 {
365 slash = '\\';
366 --wk2;
367 }
368 else
369 dwFlags |= URL_ESCAPE_UNSAFE;
370 state = 5;
371 }
372
373 while (*wk1) {
374 switch (state) {
375 case 0:
376 if (!isalnumW(*wk1)) {state = 3; break;}
377 *wk2++ = *wk1++;
378 if (!isalnumW(*wk1)) {state = 3; break;}
379 *wk2++ = *wk1++;
380 state = 1;
381 break;
382 case 1:
383 *wk2++ = *wk1;
384 if (*wk1++ == ':') state = 2;
385 break;
386 case 2:
387 if (*wk1 != '/') {state = 3; break;}
388 *wk2++ = *wk1++;
389 if (*wk1 != '/') {state = 6; break;}
390 *wk2++ = *wk1++;
391 if((dwFlags & URL_FILE_USE_PATHURL) && nByteLen >= sizeof(wszLocalhost)
392 && !memcmp(wszLocalhost, wk1, sizeof(wszLocalhost))){
393 wk1 += sizeof(wszLocalhost)/sizeof(WCHAR);
394 while(*wk1 == '\\' && (dwFlags & URL_FILE_USE_PATHURL))
395 wk1++;
396 }
397 if(*wk1 == '/' && (dwFlags & URL_FILE_USE_PATHURL))
398 wk1++;
399 state = 4;
400 break;
401 case 3:
402 nWkLen = strlenW(wk1);
403 memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
404 mp = wk2;
405 wk1 += nWkLen;
406 wk2 += nWkLen;
407
408 while(mp < wk2) {
409 if(*mp == '/' || *mp == '\\')
410 *mp = slash;
411 mp++;
412 }
413 break;
414 case 4:
415 if (!isalnumW(*wk1) && (*wk1 != '-') && (*wk1 != '.') && (*wk1 != ':'))
416 {state = 3; break;}
417 while(isalnumW(*wk1) || (*wk1 == '-') || (*wk1 == '.') || (*wk1 == ':'))
418 *wk2++ = *wk1++;
419 state = 5;
420 if (!*wk1)
421 *wk2++ = slash;
422 break;
423 case 5:
424 if (*wk1 != '/' && *wk1 != '\\') {state = 3; break;}
425 while(*wk1 == '/' || *wk1 == '\\') {
426 *wk2++ = slash;
427 wk1++;
428 }
429 state = 6;
430 break;
431 case 6:
432 if(dwFlags & URL_DONT_SIMPLIFY) {
433 state = 3;
434 break;
435 }
436
437 /* Now at root location, cannot back up any more. */
438 /* "root" will point at the '/' */
439
440 root = wk2-1;
441 while (*wk1) {
442 mp = strchrW(wk1, '/');
443 mp2 = strchrW(wk1, '\\');
444 if(mp2 && (!mp || mp2 < mp))
445 mp = mp2;
446 if (!mp) {
447 nWkLen = strlenW(wk1);
448 memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
449 wk1 += nWkLen;
450 wk2 += nWkLen;
451 continue;
452 }
453 nLen = mp - wk1;
454 if(nLen) {
455 memcpy(wk2, wk1, nLen * sizeof(WCHAR));
456 wk2 += nLen;
457 wk1 += nLen;
458 }
459 *wk2++ = slash;
460 wk1++;
461
462 if (*wk1 == '.') {
463 TRACE("found '/.'\n");
464 if (wk1[1] == '/' || wk1[1] == '\\') {
465 /* case of /./ -> skip the ./ */
466 wk1 += 2;
467 }
468 else if (wk1[1] == '.') {
469 /* found /.. look for next / */
470 TRACE("found '/..'\n");
471 if (wk1[2] == '/' || wk1[2] == '\\' ||wk1[2] == '?'
472 || wk1[2] == '#' || !wk1[2]) {
473 /* case /../ -> need to backup wk2 */
474 TRACE("found '/../'\n");
475 *(wk2-1) = '\0'; /* set end of string */
476 mp = strrchrW(root, slash);
477 if (mp && (mp >= root)) {
478 /* found valid backup point */
479 wk2 = mp + 1;
480 if(wk1[2] != '/' && wk1[2] != '\\')
481 wk1 += 2;
482 else
483 wk1 += 3;
484 }
485 else {
486 /* did not find point, restore '/' */
487 *(wk2-1) = slash;
488 }
489 }
490 }
491 }
492 }
493 *wk2 = '\0';
494 break;
495 default:
496 FIXME("how did we get here - state=%d\n", state);
497 HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
498 return E_INVALIDARG;
499 }
500 *wk2 = '\0';
501 TRACE("Simplified, orig <%s>, simple <%s>\n",
502 debugstr_w(pszUrl), debugstr_w(lpszUrlCpy));
503 }
504 nLen = lstrlenW(lpszUrlCpy);
505 while ((nLen > 0) && ((lpszUrlCpy[nLen-1] <= ' ')))
506 lpszUrlCpy[--nLen]=0;
507
508 if(dwFlags & (URL_UNESCAPE | URL_FILE_USE_PATHURL))
509 UrlUnescapeW(lpszUrlCpy, NULL, &nLen, URL_UNESCAPE_INPLACE);
510
511 if((EscapeFlags = dwFlags & (URL_ESCAPE_UNSAFE |
512 URL_ESCAPE_SPACES_ONLY |
513 URL_ESCAPE_PERCENT |
514 URL_DONT_ESCAPE_EXTRA_INFO |
515 URL_ESCAPE_SEGMENT_ONLY ))) {
516 EscapeFlags &= ~URL_ESCAPE_UNSAFE;
517 hr = UrlEscapeW(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
518 EscapeFlags);
519 } else { /* No escaping needed, just copy the string */
520 nLen = lstrlenW(lpszUrlCpy);
521 if(nLen < *pcchCanonicalized)
522 memcpy(pszCanonicalized, lpszUrlCpy, (nLen + 1)*sizeof(WCHAR));
523 else {
524 hr = E_POINTER;
525 nLen++;
526 }
527 *pcchCanonicalized = nLen;
528 }
529
530 HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
531
532 if (hr == S_OK)
533 TRACE("result %s\n", debugstr_w(pszCanonicalized));
534
535 return hr;
536 }
537
538 /*************************************************************************
539 * UrlCombineA [SHLWAPI.@]
540 *
541 * Combine two Urls.
542 *
543 * PARAMS
544 * pszBase [I] Base Url
545 * pszRelative [I] Url to combine with pszBase
546 * pszCombined [O] Destination for combined Url
547 * pcchCombined [O] Destination for length of pszCombined
548 * dwFlags [I] URL_ flags from "shlwapi.h"
549 *
550 * RETURNS
551 * Success: S_OK. pszCombined contains the combined Url, pcchCombined
552 * contains its length.
553 * Failure: An HRESULT error code indicating the error.
554 */
555 HRESULT WINAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative,
556 LPSTR pszCombined, LPDWORD pcchCombined,
557 DWORD dwFlags)
558 {
559 LPWSTR base, relative, combined;
560 DWORD ret, len, len2;
561
562 TRACE("(base %s, Relative %s, Combine size %d, flags %08x) using W version\n",
563 debugstr_a(pszBase),debugstr_a(pszRelative),
564 pcchCombined?*pcchCombined:0,dwFlags);
565
566 if(!pszBase || !pszRelative || !pcchCombined)
567 return E_INVALIDARG;
568
569 base = HeapAlloc(GetProcessHeap(), 0,
570 (3*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
571 relative = base + INTERNET_MAX_URL_LENGTH;
572 combined = relative + INTERNET_MAX_URL_LENGTH;
573
574 MultiByteToWideChar(0, 0, pszBase, -1, base, INTERNET_MAX_URL_LENGTH);
575 MultiByteToWideChar(0, 0, pszRelative, -1, relative, INTERNET_MAX_URL_LENGTH);
576 len = *pcchCombined;
577
578 ret = UrlCombineW(base, relative, pszCombined?combined:NULL, &len, dwFlags);
579 if (ret != S_OK) {
580 *pcchCombined = len;
581 HeapFree(GetProcessHeap(), 0, base);
582 return ret;
583 }
584
585 len2 = WideCharToMultiByte(0, 0, combined, len, 0, 0, 0, 0);
586 if (len2 > *pcchCombined) {
587 *pcchCombined = len2;
588 HeapFree(GetProcessHeap(), 0, base);
589 return E_POINTER;
590 }
591 WideCharToMultiByte(0, 0, combined, len+1, pszCombined, (*pcchCombined)+1,
592 0, 0);
593 *pcchCombined = len2;
594 HeapFree(GetProcessHeap(), 0, base);
595 return S_OK;
596 }
597
598 /*************************************************************************
599 * UrlCombineW [SHLWAPI.@]
600 *
601 * See UrlCombineA.
602 */
603 HRESULT WINAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative,
604 LPWSTR pszCombined, LPDWORD pcchCombined,
605 DWORD dwFlags)
606 {
607 PARSEDURLW base, relative;
608 DWORD myflags, sizeloc = 0;
609 DWORD len, res1, res2, process_case = 0;
610 LPWSTR work, preliminary, mbase, mrelative;
611 static const WCHAR myfilestr[] = {'f','i','l','e',':','/','/','/','\0'};
612 static const WCHAR single_slash[] = {'/','\0'};
613 HRESULT ret;
614
615 TRACE("(base %s, Relative %s, Combine size %d, flags %08x)\n",
616 debugstr_w(pszBase),debugstr_w(pszRelative),
617 pcchCombined?*pcchCombined:0,dwFlags);
618
619 if(!pszBase || !pszRelative || !pcchCombined)
620 return E_INVALIDARG;
621
622 base.cbSize = sizeof(base);
623 relative.cbSize = sizeof(relative);
624
625 /* Get space for duplicates of the input and the output */
626 preliminary = HeapAlloc(GetProcessHeap(), 0, (3*INTERNET_MAX_URL_LENGTH) *
627 sizeof(WCHAR));
628 mbase = preliminary + INTERNET_MAX_URL_LENGTH;
629 mrelative = mbase + INTERNET_MAX_URL_LENGTH;
630 *preliminary = '\0';
631
632 /* Canonicalize the base input prior to looking for the scheme */
633 myflags = dwFlags & (URL_DONT_SIMPLIFY | URL_UNESCAPE);
634 len = INTERNET_MAX_URL_LENGTH;
635 ret = UrlCanonicalizeW(pszBase, mbase, &len, myflags);
636
637 /* Canonicalize the relative input prior to looking for the scheme */
638 len = INTERNET_MAX_URL_LENGTH;
639 ret = UrlCanonicalizeW(pszRelative, mrelative, &len, myflags);
640
641 /* See if the base has a scheme */
642 res1 = ParseURLW(mbase, &base);
643 if (res1) {
644 /* if pszBase has no scheme, then return pszRelative */
645 TRACE("no scheme detected in Base\n");
646 process_case = 1;
647 }
648 else do {
649 /* mk is a special case */
650 if(base.nScheme == URL_SCHEME_MK) {
651 static const WCHAR wsz[] = {':',':',0};
652
653 WCHAR *ptr = strstrW(base.pszSuffix, wsz);
654 if(ptr) {
655 int delta;
656
657 ptr += 2;
658 delta = ptr-base.pszSuffix;
659 base.cchProtocol += delta;
660 base.pszSuffix += delta;
661 base.cchSuffix -= delta;
662 }
663 }
664
665 /* get size of location field (if it exists) */
666 work = (LPWSTR)base.pszSuffix;
667 sizeloc = 0;
668 if (*work++ == '/') {
669 if (*work++ == '/') {
670 /* At this point have start of location and
671 * it ends at next '/' or end of string.
672 */
673 while(*work && (*work != '/')) work++;
674 sizeloc = (DWORD)(work - base.pszSuffix);
675 }
676 }
677
678 /* Change .sizep2 to not have the last leaf in it,
679 * Note: we need to start after the location (if it exists)
680 */
681 work = strrchrW((base.pszSuffix+sizeloc), '/');
682 if (work) {
683 len = (DWORD)(work - base.pszSuffix + 1);
684 base.cchSuffix = len;
685 }
686
687 /*
688 * At this point:
689 * .pszSuffix points to location (starting with '//')
690 * .cchSuffix length of location (above) and rest less the last
691 * leaf (if any)
692 * sizeloc length of location (above) up to but not including
693 * the last '/'
694 */
695
696 res2 = ParseURLW(mrelative, &relative);
697 if (res2) {
698 /* no scheme in pszRelative */
699 TRACE("no scheme detected in Relative\n");
700 relative.pszSuffix = mrelative; /* case 3,4,5 depends on this */
701 relative.cchSuffix = strlenW(mrelative);
702 if (*pszRelative == ':') {
703 /* case that is either left alone or uses pszBase */
704 if (dwFlags & URL_PLUGGABLE_PROTOCOL) {
705 process_case = 5;
706 break;
707 }
708 process_case = 1;
709 break;
710 }
711 if (isalnum(*mrelative) && (*(mrelative + 1) == ':')) {
712 /* case that becomes "file:///" */
713 strcpyW(preliminary, myfilestr);
714 process_case = 1;
715 break;
716 }
717 if ((*mrelative == '/') && (*(mrelative+1) == '/')) {
718 /* pszRelative has location and rest */
719 process_case = 3;
720 break;
721 }
722 if (*mrelative == '/') {
723 /* case where pszRelative is root to location */
724 process_case = 4;
725 break;
726 }
727 process_case = (*base.pszSuffix == '/') ? 5 : 3;
728 break;
729 }
730
731 /* handle cases where pszRelative has scheme */
732 if ((base.cchProtocol == relative.cchProtocol) &&
733 (strncmpW(base.pszProtocol, relative.pszProtocol, base.cchProtocol) == 0)) {
734
735 /* since the schemes are the same */
736 if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
737 /* case where pszRelative replaces location and following */
738 process_case = 3;
739 break;
740 }
741 if (*relative.pszSuffix == '/') {
742 /* case where pszRelative is root to location */
743 process_case = 4;
744 break;
745 }
746 /* replace either just location if base's location starts with a
747 * slash or otherwise everything */
748 process_case = (*base.pszSuffix == '/') ? 5 : 1;
749 break;
750 }
751 if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
752 /* case where pszRelative replaces scheme, location,
753 * and following and handles PLUGGABLE
754 */
755 process_case = 2;
756 break;
757 }
758 process_case = 1;
759 break;
760 } while(FALSE); /* a little trick to allow easy exit from nested if's */
761
762 ret = S_OK;
763 switch (process_case) {
764
765 case 1: /*
766 * Return pszRelative appended to what ever is in pszCombined,
767 * (which may the string "file:///"
768 */
769 strcatW(preliminary, mrelative);
770 break;
771
772 case 2: /*
773 * Same as case 1, but if URL_PLUGGABLE_PROTOCOL was specified
774 * and pszRelative starts with "//", then append a "/"
775 */
776 strcpyW(preliminary, mrelative);
777 if (!(dwFlags & URL_PLUGGABLE_PROTOCOL) &&
778 URL_JustLocation(relative.pszSuffix))
779 strcatW(preliminary, single_slash);
780 break;
781
782 case 3: /*
783 * Return the pszBase scheme with pszRelative. Basically
784 * keeps the scheme and replaces the domain and following.
785 */
786 memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1)*sizeof(WCHAR));
787 work = preliminary + base.cchProtocol + 1;
788 strcpyW(work, relative.pszSuffix);
789 break;
790
791 case 4: /*
792 * Return the pszBase scheme and location but everything
793 * after the location is pszRelative. (Replace document
794 * from root on.)
795 */
796 memcpy(preliminary, base.pszProtocol, (base.cchProtocol+1+sizeloc)*sizeof(WCHAR));
797 work = preliminary + base.cchProtocol + 1 + sizeloc;
798 if (dwFlags & URL_PLUGGABLE_PROTOCOL)
799 *(work++) = '/';
800 strcpyW(work, relative.pszSuffix);
801 break;
802
803 case 5: /*
804 * Return the pszBase without its document (if any) and
805 * append pszRelative after its scheme.
806 */
807 memcpy(preliminary, base.pszProtocol,
808 (base.cchProtocol+1+base.cchSuffix)*sizeof(WCHAR));
809 work = preliminary + base.cchProtocol+1+base.cchSuffix - 1;
810 if (*work++ != '/')
811 *(work++) = '/';
812 strcpyW(work, relative.pszSuffix);
813 break;
814
815 default:
816 FIXME("How did we get here????? process_case=%d\n", process_case);
817 ret = E_INVALIDARG;
818 }
819
820 if (ret == S_OK) {
821 /* Reuse mrelative as temp storage as its already allocated and not needed anymore */
822 ret = UrlCanonicalizeW(preliminary, mrelative, pcchCombined, (dwFlags & ~URL_FILE_USE_PATHURL));
823 if(SUCCEEDED(ret) && pszCombined) {
824 lstrcpyW(pszCombined, mrelative);
825 }
826 TRACE("return-%d len=%d, %s\n",
827 process_case, *pcchCombined, debugstr_w(pszCombined));
828 }
829 HeapFree(GetProcessHeap(), 0, preliminary);
830 return ret;
831 }
832
833 /*************************************************************************
834 * UrlEscapeA [SHLWAPI.@]
835 */
836
837 HRESULT WINAPI UrlEscapeA(
838 LPCSTR pszUrl,
839 LPSTR pszEscaped,
840 LPDWORD pcchEscaped,
841 DWORD dwFlags)
842 {
843 WCHAR bufW[INTERNET_MAX_URL_LENGTH];
844 WCHAR *escapedW = bufW;
845 UNICODE_STRING urlW;
846 HRESULT ret;
847 DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
848
849 if (!pszEscaped || !pcchEscaped || !*pcchEscaped)
850 return E_INVALIDARG;
851
852 if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
853 return E_INVALIDARG;
854 if((ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags)) == E_POINTER) {
855 escapedW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
856 ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags);
857 }
858 if(ret == S_OK) {
859 RtlUnicodeToMultiByteSize(&lenA, escapedW, lenW * sizeof(WCHAR));
860 if(*pcchEscaped > lenA) {
861 RtlUnicodeToMultiByteN(pszEscaped, *pcchEscaped - 1, &lenA, escapedW, lenW * sizeof(WCHAR));
862 pszEscaped[lenA] = 0;
863 *pcchEscaped = lenA;
864 } else {
865 *pcchEscaped = lenA + 1;
866 ret = E_POINTER;
867 }
868 }
869 if(escapedW != bufW) HeapFree(GetProcessHeap(), 0, escapedW);
870 RtlFreeUnicodeString(&urlW);
871 return ret;
872 }
873
874 #define WINE_URL_BASH_AS_SLASH 0x01
875 #define WINE_URL_COLLAPSE_SLASHES 0x02
876 #define WINE_URL_ESCAPE_SLASH 0x04
877 #define WINE_URL_ESCAPE_HASH 0x08
878 #define WINE_URL_ESCAPE_QUESTION 0x10
879 #define WINE_URL_STOP_ON_HASH 0x20
880 #define WINE_URL_STOP_ON_QUESTION 0x40
881
882 static inline BOOL URL_NeedEscapeW(WCHAR ch, DWORD dwFlags, DWORD int_flags)
883 {
884
885 if (isalnumW(ch))
886 return FALSE;
887
888 if(dwFlags & URL_ESCAPE_SPACES_ONLY) {
889 if(ch == ' ')
890 return TRUE;
891 else
892 return FALSE;
893 }
894
895 if ((dwFlags & URL_ESCAPE_PERCENT) && (ch == '%'))
896 return TRUE;
897
898 if (ch <= 31 || ch >= 127)
899 return TRUE;
900
901 else {
902 switch (ch) {
903 case ' ':
904 case '<':
905 case '>':
906 case '\"':
907 case '{':
908 case '}':
909 case '|':
910 case '\\':
911 case '^':
912 case ']':
913 case '[':
914 case '`':
915 case '&':
916 return TRUE;
917
918 case '/':
919 if (int_flags & WINE_URL_ESCAPE_SLASH) return TRUE;
920 return FALSE;
921
922 case '?':
923 if (int_flags & WINE_URL_ESCAPE_QUESTION) return TRUE;
924 return FALSE;
925
926 case '#':
927 if (int_flags & WINE_URL_ESCAPE_HASH) return TRUE;
928 return FALSE;
929
930 default:
931 return FALSE;
932 }
933 }
934 }
935
936
937 /*************************************************************************
938 * UrlEscapeW [SHLWAPI.@]
939 *
940 * Converts unsafe characters in a Url into escape sequences.
941 *
942 * PARAMS
943 * pszUrl [I] Url to modify
944 * pszEscaped [O] Destination for modified Url
945 * pcchEscaped [I/O] Length of pszUrl, destination for length of pszEscaped
946 * dwFlags [I] URL_ flags from "shlwapi.h"
947 *
948 * RETURNS
949 * Success: S_OK. pszEscaped contains the escaped Url, pcchEscaped
950 * contains its length.
951 * Failure: E_POINTER, if pszEscaped is not large enough. In this case
952 * pcchEscaped is set to the required length.
953 *
954 * Converts unsafe characters into their escape sequences.
955 *
956 * NOTES
957 * - By default this function stops converting at the first '?' or
958 * '#' character.
959 * - If dwFlags contains URL_ESCAPE_SPACES_ONLY then only spaces are
960 * converted, but the conversion continues past a '?' or '#'.
961 * - Note that this function did not work well (or at all) in shlwapi version 4.
962 *
963 * BUGS
964 * Only the following flags are implemented:
965 *| URL_ESCAPE_SPACES_ONLY
966 *| URL_DONT_ESCAPE_EXTRA_INFO
967 *| URL_ESCAPE_SEGMENT_ONLY
968 *| URL_ESCAPE_PERCENT
969 */
970 HRESULT WINAPI UrlEscapeW(
971 LPCWSTR pszUrl,
972 LPWSTR pszEscaped,
973 LPDWORD pcchEscaped,
974 DWORD dwFlags)
975 {
976 LPCWSTR src;
977 DWORD needed = 0, ret;
978 BOOL stop_escaping = FALSE;
979 WCHAR next[5], *dst = pszEscaped;
980 INT len;
981 PARSEDURLW parsed_url;
982 DWORD int_flags;
983 DWORD slashes = 0;
984 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
985
986 TRACE("(%s %p %p 0x%08x)\n", debugstr_w(pszUrl), pszEscaped,
987 pcchEscaped, dwFlags);
988
989 if(!pszUrl || !pcchEscaped)
990 return E_INVALIDARG;
991
992 if(dwFlags & ~(URL_ESCAPE_SPACES_ONLY |
993 URL_ESCAPE_SEGMENT_ONLY |
994 URL_DONT_ESCAPE_EXTRA_INFO |
995 URL_ESCAPE_PERCENT))
996 FIXME("Unimplemented flags: %08x\n", dwFlags);
997
998 /* fix up flags */
999 if (dwFlags & URL_ESCAPE_SPACES_ONLY)
1000 /* if SPACES_ONLY specified, reset the other controls */
1001 dwFlags &= ~(URL_DONT_ESCAPE_EXTRA_INFO |
1002 URL_ESCAPE_PERCENT |
1003 URL_ESCAPE_SEGMENT_ONLY);
1004
1005 else
1006 /* if SPACES_ONLY *not* specified the assume DONT_ESCAPE_EXTRA_INFO */
1007 dwFlags |= URL_DONT_ESCAPE_EXTRA_INFO;
1008
1009
1010 int_flags = 0;
1011 if(dwFlags & URL_ESCAPE_SEGMENT_ONLY) {
1012 int_flags = WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH | WINE_URL_ESCAPE_SLASH;
1013 } else {
1014 parsed_url.cbSize = sizeof(parsed_url);
1015 if(ParseURLW(pszUrl, &parsed_url) != S_OK)
1016 parsed_url.nScheme = URL_SCHEME_INVALID;
1017
1018 TRACE("scheme = %d (%s)\n", parsed_url.nScheme, debugstr_wn(parsed_url.pszProtocol, parsed_url.cchProtocol));
1019
1020 if(dwFlags & URL_DONT_ESCAPE_EXTRA_INFO)
1021 int_flags = WINE_URL_STOP_ON_HASH | WINE_URL_STOP_ON_QUESTION;
1022
1023 switch(parsed_url.nScheme) {
1024 case URL_SCHEME_FILE:
1025 int_flags |= WINE_URL_BASH_AS_SLASH | WINE_URL_COLLAPSE_SLASHES | WINE_URL_ESCAPE_HASH;
1026 int_flags &= ~WINE_URL_STOP_ON_HASH;
1027 break;
1028
1029 case URL_SCHEME_HTTP:
1030 case URL_SCHEME_HTTPS:
1031 int_flags |= WINE_URL_BASH_AS_SLASH;
1032 if(parsed_url.pszSuffix[0] != '/' && parsed_url.pszSuffix[0] != '\\')
1033 int_flags |= WINE_URL_ESCAPE_SLASH;
1034 break;
1035
1036 case URL_SCHEME_MAILTO:
1037 int_flags |= WINE_URL_ESCAPE_SLASH | WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH;
1038 int_flags &= ~(WINE_URL_STOP_ON_QUESTION | WINE_URL_STOP_ON_HASH);
1039 break;
1040
1041 case URL_SCHEME_INVALID:
1042 break;
1043
1044 case URL_SCHEME_FTP:
1045 default:
1046 if(parsed_url.pszSuffix[0] != '/')
1047 int_flags |= WINE_URL_ESCAPE_SLASH;
1048 break;
1049 }
1050 }
1051
1052 for(src = pszUrl; *src; ) {
1053 WCHAR cur = *src;
1054 len = 0;
1055
1056 if((int_flags & WINE_URL_COLLAPSE_SLASHES) && src == pszUrl + parsed_url.cchProtocol + 1) {
1057 int localhost_len = sizeof(localhost)/sizeof(WCHAR) - 1;
1058 while(cur == '/' || cur == '\\') {
1059 slashes++;
1060 cur = *++src;
1061 }
1062 if(slashes == 2 && !strncmpiW(src, localhost, localhost_len)) { /* file://localhost/ -> file:/// */
1063 if(*(src + localhost_len) == '/' || *(src + localhost_len) == '\\')
1064 src += localhost_len + 1;
1065 slashes = 3;
1066 }
1067
1068 switch(slashes) {
1069 case 1:
1070 case 3:
1071 next[0] = next[1] = next[2] = '/';
1072 len = 3;
1073 break;
1074 case 0:
1075 len = 0;
1076 break;
1077 default:
1078 next[0] = next[1] = '/';
1079 len = 2;
1080 break;
1081 }
1082 }
1083 if(len == 0) {
1084
1085 if(cur == '#' && (int_flags & WINE_URL_STOP_ON_HASH))
1086 stop_escaping = TRUE;
1087
1088 if(cur == '?' && (int_flags & WINE_URL_STOP_ON_QUESTION))
1089 stop_escaping = TRUE;
1090
1091 if(cur == '\\' && (int_flags & WINE_URL_BASH_AS_SLASH) && !stop_escaping) cur = '/';
1092
1093 if(URL_NeedEscapeW(cur, dwFlags, int_flags) && stop_escaping == FALSE) {
1094 next[0] = '%';
1095 next[1] = hexDigits[(cur >> 4) & 0xf];
1096 next[2] = hexDigits[cur & 0xf];
1097 len = 3;
1098 } else {
1099 next[0] = cur;
1100 len = 1;
1101 }
1102 src++;
1103 }
1104
1105 if(needed + len <= *pcchEscaped) {
1106 memcpy(dst, next, len*sizeof(WCHAR));
1107 dst += len;
1108 }
1109 needed += len;
1110 }
1111
1112 if(needed < *pcchEscaped) {
1113 *dst = '\0';
1114 ret = S_OK;
1115 } else {
1116 needed++; /* add one for the '\0' */
1117 ret = E_POINTER;
1118 }
1119 *pcchEscaped = needed;
1120 return ret;
1121 }
1122
1123
1124 /*************************************************************************
1125 * UrlUnescapeA [SHLWAPI.@]
1126 *
1127 * Converts Url escape sequences back to ordinary characters.
1128 *
1129 * PARAMS
1130 * pszUrl [I/O] Url to convert
1131 * pszUnescaped [O] Destination for converted Url
1132 * pcchUnescaped [I/O] Size of output string
1133 * dwFlags [I] URL_ESCAPE_ Flags from "shlwapi.h"
1134 *
1135 * RETURNS
1136 * Success: S_OK. The converted value is in pszUnescaped, or in pszUrl if
1137 * dwFlags includes URL_ESCAPE_INPLACE.
1138 * Failure: E_POINTER if the converted Url is bigger than pcchUnescaped. In
1139 * this case pcchUnescaped is set to the size required.
1140 * NOTES
1141 * If dwFlags includes URL_DONT_ESCAPE_EXTRA_INFO, the conversion stops at
1142 * the first occurrence of either a '?' or '#' character.
1143 */
1144 HRESULT WINAPI UrlUnescapeA(
1145 LPSTR pszUrl,
1146 LPSTR pszUnescaped,
1147 LPDWORD pcchUnescaped,
1148 DWORD dwFlags)
1149 {
1150 char *dst, next;
1151 LPCSTR src;
1152 HRESULT ret;
1153 DWORD needed;
1154 BOOL stop_unescaping = FALSE;
1155
1156 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_a(pszUrl), pszUnescaped,
1157 pcchUnescaped, dwFlags);
1158
1159 if(!pszUrl || (!pszUnescaped && !(dwFlags & URL_UNESCAPE_INPLACE)) || !pcchUnescaped)
1160 return E_INVALIDARG;
1161
1162 if(dwFlags & URL_UNESCAPE_INPLACE)
1163 dst = pszUrl;
1164 else
1165 dst = pszUnescaped;
1166
1167 for(src = pszUrl, needed = 0; *src; src++, needed++) {
1168 if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1169 (*src == '#' || *src == '?')) {
1170 stop_unescaping = TRUE;
1171 next = *src;
1172 } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
1173 && stop_unescaping == FALSE) {
1174 INT ih;
1175 char buf[3];
1176 memcpy(buf, src + 1, 2);
1177 buf[2] = '\0';
1178 ih = strtol(buf, NULL, 16);
1179 next = (CHAR) ih;
1180 src += 2; /* Advance to end of escape */
1181 } else
1182 next = *src;
1183
1184 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1185 *dst++ = next;
1186 }
1187
1188 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1189 *dst = '\0';
1190 ret = S_OK;
1191 } else {
1192 needed++; /* add one for the '\0' */
1193 ret = E_POINTER;
1194 }
1195 if(!(dwFlags & URL_UNESCAPE_INPLACE))
1196 *pcchUnescaped = needed;
1197
1198 if (ret == S_OK) {
1199 TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1200 debugstr_a(pszUrl) : debugstr_a(pszUnescaped));
1201 }
1202
1203 return ret;
1204 }
1205
1206 /*************************************************************************
1207 * UrlUnescapeW [SHLWAPI.@]
1208 *
1209 * See UrlUnescapeA.
1210 */
1211 HRESULT WINAPI UrlUnescapeW(
1212 LPWSTR pszUrl,
1213 LPWSTR pszUnescaped,
1214 LPDWORD pcchUnescaped,
1215 DWORD dwFlags)
1216 {
1217 WCHAR *dst, next;
1218 LPCWSTR src;
1219 HRESULT ret;
1220 DWORD needed;
1221 BOOL stop_unescaping = FALSE;
1222
1223 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszUrl), pszUnescaped,
1224 pcchUnescaped, dwFlags);
1225
1226 if(!pszUrl || (!pszUnescaped && !(dwFlags & URL_UNESCAPE_INPLACE))|| !pcchUnescaped)
1227 return E_INVALIDARG;
1228
1229 if(dwFlags & URL_UNESCAPE_INPLACE)
1230 dst = pszUrl;
1231 else
1232 dst = pszUnescaped;
1233
1234 for(src = pszUrl, needed = 0; *src; src++, needed++) {
1235 if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1236 (*src == '#' || *src == '?')) {
1237 stop_unescaping = TRUE;
1238 next = *src;
1239 } else if(*src == '%' && isxdigitW(*(src + 1)) && isxdigitW(*(src + 2))
1240 && stop_unescaping == FALSE) {
1241 INT ih;
1242 WCHAR buf[5] = {'0','x',0};
1243 memcpy(buf + 2, src + 1, 2*sizeof(WCHAR));
1244 buf[4] = 0;
1245 StrToIntExW(buf, STIF_SUPPORT_HEX, &ih);
1246 next = (WCHAR) ih;
1247 src += 2; /* Advance to end of escape */
1248 } else
1249 next = *src;
1250
1251 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1252 *dst++ = next;
1253 }
1254
1255 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1256 *dst = '\0';
1257 ret = S_OK;
1258 } else {
1259 needed++; /* add one for the '\0' */
1260 ret = E_POINTER;
1261 }
1262 if(!(dwFlags & URL_UNESCAPE_INPLACE))
1263 *pcchUnescaped = needed;
1264
1265 if (ret == S_OK) {
1266 TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1267 debugstr_w(pszUrl) : debugstr_w(pszUnescaped));
1268 }
1269
1270 return ret;
1271 }
1272
1273 /*************************************************************************
1274 * UrlGetLocationA [SHLWAPI.@]
1275 *
1276 * Get the location from a Url.
1277 *
1278 * PARAMS
1279 * pszUrl [I] Url to get the location from
1280 *
1281 * RETURNS
1282 * A pointer to the start of the location in pszUrl, or NULL if there is
1283 * no location.
1284 *
1285 * NOTES
1286 * - MSDN erroneously states that "The location is the segment of the Url
1287 * starting with a '?' or '#' character". Neither V4 nor V5 of shlwapi.dll
1288 * stop at '?' and always return a NULL in this case.
1289 * - MSDN also erroneously states that "If a file URL has a query string,
1290 * the returned string is the query string". In all tested cases, if the
1291 * Url starts with "fi" then a NULL is returned. V5 gives the following results:
1292 *| Result Url
1293 *| ------ ---
1294 *| NULL file://aa/b/cd#hohoh
1295 *| #hohoh http://aa/b/cd#hohoh
1296 *| NULL fi://aa/b/cd#hohoh
1297 *| #hohoh ff://aa/b/cd#hohoh
1298 */
1299 LPCSTR WINAPI UrlGetLocationA(
1300 LPCSTR pszUrl)
1301 {
1302 PARSEDURLA base;
1303 DWORD res1;
1304
1305 base.cbSize = sizeof(base);
1306 res1 = ParseURLA(pszUrl, &base);
1307 if (res1) return NULL; /* invalid scheme */
1308
1309 /* if scheme is file: then never return pointer */
1310 if (strncmp(base.pszProtocol, "file", min(4,base.cchProtocol)) == 0) return NULL;
1311
1312 /* Look for '#' and return its addr */
1313 return strchr(base.pszSuffix, '#');
1314 }
1315
1316 /*************************************************************************
1317 * UrlGetLocationW [SHLWAPI.@]
1318 *
1319 * See UrlGetLocationA.
1320 */
1321 LPCWSTR WINAPI UrlGetLocationW(
1322 LPCWSTR pszUrl)
1323 {
1324 PARSEDURLW base;
1325 DWORD res1;
1326
1327 base.cbSize = sizeof(base);
1328 res1 = ParseURLW(pszUrl, &base);
1329 if (res1) return NULL; /* invalid scheme */
1330
1331 /* if scheme is file: then never return pointer */
1332 if (strncmpW(base.pszProtocol, fileW, min(4,base.cchProtocol)) == 0) return NULL;
1333
1334 /* Look for '#' and return its addr */
1335 return strchrW(base.pszSuffix, '#');
1336 }
1337
1338 /*************************************************************************
1339 * UrlCompareA [SHLWAPI.@]
1340 *
1341 * Compare two Urls.
1342 *
1343 * PARAMS
1344 * pszUrl1 [I] First Url to compare
1345 * pszUrl2 [I] Url to compare to pszUrl1
1346 * fIgnoreSlash [I] TRUE = compare only up to a final slash
1347 *
1348 * RETURNS
1349 * less than zero, zero, or greater than zero indicating pszUrl2 is greater
1350 * than, equal to, or less than pszUrl1 respectively.
1351 */
1352 INT WINAPI UrlCompareA(
1353 LPCSTR pszUrl1,
1354 LPCSTR pszUrl2,
1355 BOOL fIgnoreSlash)
1356 {
1357 INT ret, len, len1, len2;
1358
1359 if (!fIgnoreSlash)
1360 return strcmp(pszUrl1, pszUrl2);
1361 len1 = strlen(pszUrl1);
1362 if (pszUrl1[len1-1] == '/') len1--;
1363 len2 = strlen(pszUrl2);
1364 if (pszUrl2[len2-1] == '/') len2--;
1365 if (len1 == len2)
1366 return strncmp(pszUrl1, pszUrl2, len1);
1367 len = min(len1, len2);
1368 ret = strncmp(pszUrl1, pszUrl2, len);
1369 if (ret) return ret;
1370 if (len1 > len2) return 1;
1371 return -1;
1372 }
1373
1374 /*************************************************************************
1375 * UrlCompareW [SHLWAPI.@]
1376 *
1377 * See UrlCompareA.
1378 */
1379 INT WINAPI UrlCompareW(
1380 LPCWSTR pszUrl1,
1381 LPCWSTR pszUrl2,
1382 BOOL fIgnoreSlash)
1383 {
1384 INT ret;
1385 size_t len, len1, len2;
1386
1387 if (!fIgnoreSlash)
1388 return strcmpW(pszUrl1, pszUrl2);
1389 len1 = strlenW(pszUrl1);
1390 if (pszUrl1[len1-1] == '/') len1--;
1391 len2 = strlenW(pszUrl2);
1392 if (pszUrl2[len2-1] == '/') len2--;
1393 if (len1 == len2)
1394 return strncmpW(pszUrl1, pszUrl2, len1);
1395 len = min(len1, len2);
1396 ret = strncmpW(pszUrl1, pszUrl2, len);
1397 if (ret) return ret;
1398 if (len1 > len2) return 1;
1399 return -1;
1400 }
1401
1402 /*************************************************************************
1403 * HashData [SHLWAPI.@]
1404 *
1405 * Hash an input block into a variable sized digest.
1406 *
1407 * PARAMS
1408 * lpSrc [I] Input block
1409 * nSrcLen [I] Length of lpSrc
1410 * lpDest [I] Output for hash digest
1411 * nDestLen [I] Length of lpDest
1412 *
1413 * RETURNS
1414 * Success: TRUE. lpDest is filled with the computed hash value.
1415 * Failure: FALSE, if any argument is invalid.
1416 */
1417 HRESULT WINAPI HashData(const unsigned char *lpSrc, DWORD nSrcLen,
1418 unsigned char *lpDest, DWORD nDestLen)
1419 {
1420 INT srcCount = nSrcLen - 1, destCount = nDestLen - 1;
1421
1422 if (IsBadReadPtr(lpSrc, nSrcLen) ||
1423 IsBadWritePtr(lpDest, nDestLen))
1424 return E_INVALIDARG;
1425
1426 while (destCount >= 0)
1427 {
1428 lpDest[destCount] = (destCount & 0xff);
1429 destCount--;
1430 }
1431
1432 while (srcCount >= 0)
1433 {
1434 destCount = nDestLen - 1;
1435 while (destCount >= 0)
1436 {
1437 lpDest[destCount] = HashDataLookup[lpSrc[srcCount] ^ lpDest[destCount]];
1438 destCount--;
1439 }
1440 srcCount--;
1441 }
1442 return S_OK;
1443 }
1444
1445 /*************************************************************************
1446 * UrlHashA [SHLWAPI.@]
1447 *
1448 * Produce a Hash from a Url.
1449 *
1450 * PARAMS
1451 * pszUrl [I] Url to hash
1452 * lpDest [O] Destinationh for hash
1453 * nDestLen [I] Length of lpDest
1454 *
1455 * RETURNS
1456 * Success: S_OK. lpDest is filled with the computed hash value.
1457 * Failure: E_INVALIDARG, if any argument is invalid.
1458 */
1459 HRESULT WINAPI UrlHashA(LPCSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1460 {
1461 if (IsBadStringPtrA(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1462 return E_INVALIDARG;
1463
1464 HashData((const BYTE*)pszUrl, (int)strlen(pszUrl), lpDest, nDestLen);
1465 return S_OK;
1466 }
1467
1468 /*************************************************************************
1469 * UrlHashW [SHLWAPI.@]
1470 *
1471 * See UrlHashA.
1472 */
1473 HRESULT WINAPI UrlHashW(LPCWSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1474 {
1475 char szUrl[MAX_PATH];
1476
1477 TRACE("(%s,%p,%d)\n",debugstr_w(pszUrl), lpDest, nDestLen);
1478
1479 if (IsBadStringPtrW(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1480 return E_INVALIDARG;
1481
1482 /* Win32 hashes the data as an ASCII string, presumably so that both A+W
1483 * return the same digests for the same URL.
1484 */
1485 WideCharToMultiByte(0, 0, pszUrl, -1, szUrl, MAX_PATH, 0, 0);
1486 HashData((const BYTE*)szUrl, (int)strlen(szUrl), lpDest, nDestLen);
1487 return S_OK;
1488 }
1489
1490 /*************************************************************************
1491 * UrlApplySchemeA [SHLWAPI.@]
1492 *
1493 * Apply a scheme to a Url.
1494 *
1495 * PARAMS
1496 * pszIn [I] Url to apply scheme to
1497 * pszOut [O] Destination for modified Url
1498 * pcchOut [I/O] Length of pszOut/destination for length of pszOut
1499 * dwFlags [I] URL_ flags from "shlwapi.h"
1500 *
1501 * RETURNS
1502 * Success: S_OK: pszOut contains the modified Url, pcchOut contains its length.
1503 * Failure: An HRESULT error code describing the error.
1504 */
1505 HRESULT WINAPI UrlApplySchemeA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1506 {
1507 LPWSTR in, out;
1508 DWORD ret, len, len2;
1509
1510 TRACE("(in %s, out size %d, flags %08x) using W version\n",
1511 debugstr_a(pszIn), *pcchOut, dwFlags);
1512
1513 in = HeapAlloc(GetProcessHeap(), 0,
1514 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
1515 out = in + INTERNET_MAX_URL_LENGTH;
1516
1517 MultiByteToWideChar(0, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
1518 len = INTERNET_MAX_URL_LENGTH;
1519
1520 ret = UrlApplySchemeW(in, out, &len, dwFlags);
1521 if ((ret != S_OK) && (ret != S_FALSE)) {
1522 HeapFree(GetProcessHeap(), 0, in);
1523 return ret;
1524 }
1525
1526 len2 = WideCharToMultiByte(0, 0, out, len+1, 0, 0, 0, 0);
1527 if (len2 > *pcchOut) {
1528 *pcchOut = len2;
1529 HeapFree(GetProcessHeap(), 0, in);
1530 return E_POINTER;
1531 }
1532 WideCharToMultiByte(0, 0, out, len+1, pszOut, *pcchOut, 0, 0);
1533 *pcchOut = len2;
1534 HeapFree(GetProcessHeap(), 0, in);
1535 return ret;
1536 }
1537
1538 static HRESULT URL_GuessScheme(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1539 {
1540 HKEY newkey;
1541 BOOL j;
1542 INT index;
1543 DWORD value_len, data_len, dwType, i;
1544 WCHAR reg_path[MAX_PATH];
1545 WCHAR value[MAX_PATH], data[MAX_PATH];
1546 WCHAR Wxx, Wyy;
1547
1548 MultiByteToWideChar(0, 0,
1549 "Software\\Microsoft\\Windows\\CurrentVersion\\URL\\Prefixes",
1550 -1, reg_path, MAX_PATH);
1551 RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_path, 0, 1, &newkey);
1552 index = 0;
1553 while(value_len = data_len = MAX_PATH,
1554 RegEnumValueW(newkey, index, value, &value_len,
1555 0, &dwType, (LPVOID)data, &data_len) == 0) {
1556 TRACE("guess %d %s is %s\n",
1557 index, debugstr_w(value), debugstr_w(data));
1558
1559 j = FALSE;
1560 for(i=0; i<value_len; i++) {
1561 Wxx = pszIn[i];
1562 Wyy = value[i];
1563 /* remember that TRUE is not-equal */
1564 j = ChrCmpIW(Wxx, Wyy);
1565 if (j) break;
1566 }
1567 if ((i == value_len) && !j) {
1568 if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1569 *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1570 RegCloseKey(newkey);
1571 return E_POINTER;
1572 }
1573 strcpyW(pszOut, data);
1574 strcatW(pszOut, pszIn);
1575 *pcchOut = strlenW(pszOut);
1576 TRACE("matched and set to %s\n", debugstr_w(pszOut));
1577 RegCloseKey(newkey);
1578 return S_OK;
1579 }
1580 index++;
1581 }
1582 RegCloseKey(newkey);
1583 return -1;
1584 }
1585
1586 static HRESULT URL_ApplyDefault(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1587 {
1588 HKEY newkey;
1589 DWORD data_len, dwType;
1590 WCHAR value[MAX_PATH], data[MAX_PATH];
1591
1592 static const WCHAR prefix_keyW[] =
1593 {'S','o','f','t','w','a','r','e',
1594 '\\','M','i','c','r','o','s','o','f','t',
1595 '\\','W','i','n','d','o','w','s',
1596 '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',
1597 '\\','U','R','L',
1598 '\\','D','e','f','a','u','l','t','P','r','e','f','i','x',0};
1599
1600 /* get and prepend default */
1601 RegOpenKeyExW(HKEY_LOCAL_MACHINE, prefix_keyW, 0, 1, &newkey);
1602 data_len = MAX_PATH;
1603 value[0] = '@';
1604 value[1] = '\0';
1605 RegQueryValueExW(newkey, value, 0, &dwType, (LPBYTE)data, &data_len);
1606 RegCloseKey(newkey);
1607 if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1608 *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1609 return E_POINTER;
1610 }
1611 strcpyW(pszOut, data);
1612 strcatW(pszOut, pszIn);
1613 *pcchOut = strlenW(pszOut);
1614 TRACE("used default %s\n", debugstr_w(pszOut));
1615 return S_OK;
1616 }
1617
1618 /*************************************************************************
1619 * UrlApplySchemeW [SHLWAPI.@]
1620 *
1621 * See UrlApplySchemeA.
1622 */
1623 HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1624 {
1625 PARSEDURLW in_scheme;
1626 DWORD res1;
1627 HRESULT ret;
1628
1629 TRACE("(in %s, out size %d, flags %08x)\n",
1630 debugstr_w(pszIn), *pcchOut, dwFlags);
1631
1632 if (dwFlags & URL_APPLY_GUESSFILE) {
1633 FIXME("(%s %p %p(%d) 0x%08x): stub URL_APPLY_GUESSFILE not implemented\n",
1634 debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwFlags);
1635 strcpyW(pszOut, pszIn);
1636 *pcchOut = strlenW(pszOut);
1637 return S_FALSE;
1638 }
1639
1640 in_scheme.cbSize = sizeof(in_scheme);
1641 /* See if the base has a scheme */
1642 res1 = ParseURLW(pszIn, &in_scheme);
1643 if (res1) {
1644 /* no scheme in input, need to see if we need to guess */
1645 if (dwFlags & URL_APPLY_GUESSSCHEME) {
1646 if ((ret = URL_GuessScheme(pszIn, pszOut, pcchOut)) != -1)
1647 return ret;
1648 }
1649 }
1650 else {
1651 /* we have a scheme, see if valid (known scheme) */
1652 if (in_scheme.nScheme) {
1653 /* have valid scheme, so just copy and exit */
1654 if (strlenW(pszIn) + 1 > *pcchOut) {
1655 *pcchOut = strlenW(pszIn) + 1;
1656 return E_POINTER;
1657 }
1658 strcpyW(pszOut, pszIn);
1659 *pcchOut = strlenW(pszOut);
1660 TRACE("valid scheme, returning copy\n");
1661 return S_OK;
1662 }
1663 }
1664
1665 /* If we are here, then either invalid scheme,
1666 * or no scheme and can't/failed guess.
1667 */
1668 if ( ( ((res1 == 0) && (dwFlags & URL_APPLY_FORCEAPPLY)) ||
1669 ((res1 != 0)) ) &&
1670 (dwFlags & URL_APPLY_DEFAULT)) {
1671 /* find and apply default scheme */
1672 return URL_ApplyDefault(pszIn, pszOut, pcchOut);
1673 }
1674
1675 /* just copy and give proper return code */
1676 if (strlenW(pszIn) + 1 > *pcchOut) {
1677 *pcchOut = strlenW(pszIn) + 1;
1678 return E_POINTER;
1679 }
1680 strcpyW(pszOut, pszIn);
1681 *pcchOut = strlenW(pszOut);
1682 TRACE("returning copy, left alone\n");
1683 return S_FALSE;
1684 }
1685
1686 /*************************************************************************
1687 * UrlIsA [SHLWAPI.@]
1688 *
1689 * Determine if a Url is of a certain class.
1690 *
1691 * PARAMS
1692 * pszUrl [I] Url to check
1693 * Urlis [I] URLIS_ constant from "shlwapi.h"
1694 *
1695 * RETURNS
1696 * TRUE if pszUrl belongs to the class type in Urlis.
1697 * FALSE Otherwise.
1698 */
1699 BOOL WINAPI UrlIsA(LPCSTR pszUrl, URLIS Urlis)
1700 {
1701 PARSEDURLA base;
1702 DWORD res1;
1703 LPCSTR last;
1704
1705 TRACE("(%s %d)\n", debugstr_a(pszUrl), Urlis);
1706
1707 switch (Urlis) {
1708
1709 case URLIS_OPAQUE:
1710 base.cbSize = sizeof(base);
1711 res1 = ParseURLA(pszUrl, &base);
1712 if (res1) return FALSE; /* invalid scheme */
1713 switch (base.nScheme)
1714 {
1715 case URL_SCHEME_MAILTO:
1716 case URL_SCHEME_SHELL:
1717 case URL_SCHEME_JAVASCRIPT:
1718 case URL_SCHEME_VBSCRIPT:
1719 case URL_SCHEME_ABOUT:
1720 return TRUE;
1721 }
1722 return FALSE;
1723
1724 case URLIS_FILEURL:
1725 return !StrCmpNA("file:", pszUrl, 5);
1726
1727 case URLIS_DIRECTORY:
1728 last = pszUrl + strlen(pszUrl) - 1;
1729 return (last >= pszUrl && (*last == '/' || *last == '\\' ));
1730
1731 case URLIS_URL:
1732 return PathIsURLA(pszUrl);
1733
1734 case URLIS_NOHISTORY:
1735 case URLIS_APPLIABLE:
1736 case URLIS_HASQUERY:
1737 default:
1738 FIXME("(%s %d): stub\n", debugstr_a(pszUrl), Urlis);
1739 }
1740 return FALSE;
1741 }
1742
1743 /*************************************************************************
1744 * UrlIsW [SHLWAPI.@]
1745 *
1746 * See UrlIsA.
1747 */
1748 BOOL WINAPI UrlIsW(LPCWSTR pszUrl, URLIS Urlis)
1749 {
1750 static const WCHAR stemp[] = { 'f','i','l','e',':',0 };
1751 PARSEDURLW base;
1752 DWORD res1;
1753 LPCWSTR last;
1754
1755 TRACE("(%s %d)\n", debugstr_w(pszUrl), Urlis);
1756
1757 switch (Urlis) {
1758
1759 case URLIS_OPAQUE:
1760 base.cbSize = sizeof(base);
1761 res1 = ParseURLW(pszUrl, &base);
1762 if (res1) return FALSE; /* invalid scheme */
1763 switch (base.nScheme)
1764 {
1765 case URL_SCHEME_MAILTO:
1766 case URL_SCHEME_SHELL:
1767 case URL_SCHEME_JAVASCRIPT:
1768 case URL_SCHEME_VBSCRIPT:
1769 case URL_SCHEME_ABOUT:
1770 return TRUE;
1771 }
1772 return FALSE;
1773
1774 case URLIS_FILEURL:
1775 return !strncmpW(stemp, pszUrl, 5);
1776
1777 case URLIS_DIRECTORY:
1778 last = pszUrl + strlenW(pszUrl) - 1;
1779 return (last >= pszUrl && (*last == '/' || *last == '\\'));
1780
1781 case URLIS_URL:
1782 return PathIsURLW(pszUrl);
1783
1784 case URLIS_NOHISTORY:
1785 case URLIS_APPLIABLE:
1786 case URLIS_HASQUERY:
1787 default:
1788 FIXME("(%s %d): stub\n", debugstr_w(pszUrl), Urlis);
1789 }
1790 return FALSE;
1791 }
1792
1793 /*************************************************************************
1794 * UrlIsNoHistoryA [SHLWAPI.@]
1795 *
1796 * Determine if a Url should not be stored in the users history list.
1797 *
1798 * PARAMS
1799 * pszUrl [I] Url to check
1800 *
1801 * RETURNS
1802 * TRUE, if pszUrl should be excluded from the history list,
1803 * FALSE otherwise.
1804 */
1805 BOOL WINAPI UrlIsNoHistoryA(LPCSTR pszUrl)
1806 {
1807 return UrlIsA(pszUrl, URLIS_NOHISTORY);
1808 }
1809
1810 /*************************************************************************
1811 * UrlIsNoHistoryW [SHLWAPI.@]
1812 *
1813 * See UrlIsNoHistoryA.
1814 */
1815 BOOL WINAPI UrlIsNoHistoryW(LPCWSTR pszUrl)
1816 {
1817 return UrlIsW(pszUrl, URLIS_NOHISTORY);
1818 }
1819
1820 /*************************************************************************
1821 * UrlIsOpaqueA [SHLWAPI.@]
1822 *
1823 * Determine if a Url is opaque.
1824 *
1825 * PARAMS
1826 * pszUrl [I] Url to check
1827 *
1828 * RETURNS
1829 * TRUE if pszUrl is opaque,
1830 * FALSE Otherwise.
1831 *
1832 * NOTES
1833 * An opaque Url is one that does not start with "<protocol>://".
1834 */
1835 BOOL WINAPI UrlIsOpaqueA(LPCSTR pszUrl)
1836 {
1837 return UrlIsA(pszUrl, URLIS_OPAQUE);
1838 }
1839
1840 /*************************************************************************
1841 * UrlIsOpaqueW [SHLWAPI.@]
1842 *
1843 * See UrlIsOpaqueA.
1844 */
1845 BOOL WINAPI UrlIsOpaqueW(LPCWSTR pszUrl)
1846 {
1847 return UrlIsW(pszUrl, URLIS_OPAQUE);
1848 }
1849
1850 /*************************************************************************
1851 * Scans for characters of type "type" and when not matching found,
1852 * returns pointer to it and length in size.
1853 *
1854 * Characters tested based on RFC 1738
1855 */
1856 static LPCWSTR URL_ScanID(LPCWSTR start, LPDWORD size, WINE_URL_SCAN_TYPE type)
1857 {
1858 static DWORD alwayszero = 0;
1859 BOOL cont = TRUE;
1860
1861 *size = 0;
1862
1863 switch(type){
1864
1865 case SCHEME:
1866 while (cont) {
1867 if ( (islowerW(*start) && isalphaW(*start)) ||
1868 isdigitW(*start) ||
1869 (*start == '+') ||
1870 (*start == '-') ||
1871 (*start == '.')) {
1872 start++;
1873 (*size)++;
1874 }
1875 else
1876 cont = FALSE;
1877 }
1878 break;
1879
1880 case USERPASS:
1881 while (cont) {
1882 if ( isalphaW(*start) ||
1883 isdigitW(*start) ||
1884 /* user/password only characters */
1885 (*start == ';') ||
1886 (*start == '?') ||
1887 (*start == '&') ||
1888 (*start == '=') ||
1889 /* *extra* characters */
1890 (*start == '!') ||
1891 (*start == '*') ||
1892 (*start == '\'') ||
1893 (*start == '(') ||
1894 (*start == ')') ||
1895 (*start == ',') ||
1896 /* *safe* characters */
1897 (*start == '$') ||
1898 (*start == '_') ||
1899 (*start == '+') ||
1900 (*start == '-') ||
1901 (*start == '.')) {
1902 start++;
1903 (*size)++;
1904 } else if (*start == '%') {
1905 if (isxdigitW(*(start+1)) &&
1906 isxdigitW(*(start+2))) {
1907 start += 3;
1908 *size += 3;
1909 } else
1910 cont = FALSE;
1911 } else
1912 cont = FALSE;
1913 }
1914 break;
1915
1916 case PORT:
1917 while (cont) {
1918 if (isdigitW(*start)) {
1919 start++;
1920 (*size)++;
1921 }
1922 else
1923 cont = FALSE;
1924 }
1925 break;
1926
1927 case HOST:
1928 while (cont) {
1929 if (isalnumW(*start) ||
1930 (*start == '-') ||
1931 (*start == '.') ) {
1932 start++;
1933 (*size)++;
1934 }
1935 else
1936 cont = FALSE;
1937 }
1938 break;
1939 default:
1940 FIXME("unknown type %d\n", type);
1941 return (LPWSTR)&alwayszero;
1942 }
1943 /* TRACE("scanned %d characters next char %p<%c>\n",
1944 *size, start, *start); */
1945 return start;
1946 }
1947
1948 /*************************************************************************
1949 * Attempt to parse URL into pieces.
1950 */
1951 static LONG URL_ParseUrl(LPCWSTR pszUrl, WINE_PARSE_URL *pl)
1952 {
1953 LPCWSTR work;
1954
1955 memset(pl, 0, sizeof(WINE_PARSE_URL));
1956 pl->pScheme = pszUrl;
1957 work = URL_ScanID(pl->pScheme, &pl->szScheme, SCHEME);
1958 if (!*work || (*work != ':')) goto ErrorExit;
1959 work++;
1960 if ((*work != '/') || (*(work+1) != '/')) goto ErrorExit;
1961 pl->pUserName = work + 2;
1962 work = URL_ScanID(pl->pUserName, &pl->szUserName, USERPASS);
1963 if (*work == ':' ) {
1964 /* parse password */
1965 work++;
1966 pl->pPassword = work;
1967 work = URL_ScanID(pl->pPassword, &pl->szPassword, USERPASS);
1968 if (*work != '@') {
1969 /* what we just parsed must be the hostname and port
1970 * so reset pointers and clear then let it parse */
1971 pl->szUserName = pl->szPassword = 0;
1972 work = pl->pUserName - 1;
1973 pl->pUserName = pl->pPassword = 0;
1974 }
1975 } else if (*work == '@') {
1976 /* no password */
1977 pl->szPassword = 0;
1978 pl->pPassword = 0;
1979 } else if (!*work || (*work == '/') || (*work == '.')) {
1980 /* what was parsed was hostname, so reset pointers and let it parse */
1981 pl->szUserName = pl->szPassword = 0;
1982 work = pl->pUserName - 1;
1983 pl->pUserName = pl->pPassword = 0;
1984 } else goto ErrorExit;
1985
1986 /* now start parsing hostname or hostnumber */
1987 work++;
1988 pl->pHostName = work;
1989 work = URL_ScanID(pl->pHostName, &pl->szHostName, HOST);
1990 if (*work == ':') {
1991 /* parse port */
1992 work++;
1993 pl->pPort = work;
1994 work = URL_ScanID(pl->pPort, &pl->szPort, PORT);
1995 }
1996 if (*work == '/') {
1997 /* see if query string */
1998 pl->pQuery = strchrW(work, '?');
1999 if (pl->pQuery) pl->szQuery = strlenW(pl->pQuery);
2000 }
2001 TRACE("parse successful: scheme=%p(%d), user=%p(%d), pass=%p(%d), host=%p(%d), port=%p(%d), query=%p(%d)\n",
2002 pl->pScheme, pl->szScheme,
2003 pl->pUserName, pl->szUserName,
2004 pl->pPassword, pl->szPassword,
2005 pl->pHostName, pl->szHostName,
2006 pl->pPort, pl->szPort,
2007 pl->pQuery, pl->szQuery);
2008 return S_OK;
2009 ErrorExit:
2010 FIXME("failed to parse %s\n", debugstr_w(pszUrl));
2011 return E_INVALIDARG;
2012 }
2013
2014 /*************************************************************************
2015 * UrlGetPartA [SHLWAPI.@]
2016 *
2017 * Retrieve part of a Url.
2018 *
2019 * PARAMS
2020 * pszIn [I] Url to parse
2021 * pszOut [O] Destination for part of pszIn requested
2022 * pcchOut [I] Size of pszOut
2023 * [O] length of pszOut string EXCLUDING '\0' if S_OK, otherwise
2024 * needed size of pszOut INCLUDING '\0'.
2025 * dwPart [I] URL_PART_ enum from "shlwapi.h"
2026 * dwFlags [I] URL_ flags from "shlwapi.h"
2027 *
2028 * RETURNS
2029 * Success: S_OK. pszOut contains the part requested, pcchOut contains its length.
2030 * Failure: An HRESULT error code describing the error.
2031 */
2032 HRESULT WINAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut,
2033 DWORD dwPart, DWORD dwFlags)
2034 {
2035 LPWSTR in, out;
2036 DWORD ret, len, len2;
2037
2038 in = HeapAlloc(GetProcessHeap(), 0,
2039 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
2040 out = in + INTERNET_MAX_URL_LENGTH;
2041
2042 MultiByteToWideChar(0, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
2043
2044 len = INTERNET_MAX_URL_LENGTH;
2045 ret = UrlGetPartW(in, out, &len, dwPart, dwFlags);
2046
2047 if (ret != S_OK) {
2048 HeapFree(GetProcessHeap(), 0, in);
2049 return ret;
2050 }
2051
2052 len2 = WideCharToMultiByte(0, 0, out, len, 0, 0, 0, 0);
2053 if (len2 > *pcchOut) {
2054 *pcchOut = len2;
2055 HeapFree(GetProcessHeap(), 0, in);
2056 return E_POINTER;
2057 }
2058 WideCharToMultiByte(0, 0, out, len+1, pszOut, *pcchOut, 0, 0);
2059 *pcchOut = len2;
2060 HeapFree(GetProcessHeap(), 0, in);
2061 return S_OK;
2062 }
2063
2064 /*************************************************************************
2065 * UrlGetPartW [SHLWAPI.@]
2066 *
2067 * See UrlGetPartA.
2068 */
2069 HRESULT WINAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut,
2070 DWORD dwPart, DWORD dwFlags)
2071 {
2072 WINE_PARSE_URL pl;
2073 HRESULT ret;
2074 DWORD size, schsize;
2075 LPCWSTR addr, schaddr;
2076
2077 TRACE("(%s %p %p(%d) %08x %08x)\n",
2078 debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwPart, dwFlags);
2079
2080 ret = URL_ParseUrl(pszIn, &pl);
2081 if (!ret) {
2082 schaddr = pl.pScheme;
2083 schsize = pl.szScheme;
2084
2085 switch (dwPart) {
2086 case URL_PART_SCHEME:
2087 if (!pl.szScheme) return E_INVALIDARG;
2088 addr = pl.pScheme;
2089 size = pl.szScheme;
2090 break;
2091
2092 case URL_PART_HOSTNAME:
2093 if (!pl.szHostName) return E_INVALIDARG;
2094 addr = pl.pHostName;
2095 size = pl.szHostName;
2096 break;
2097
2098 case URL_PART_USERNAME:
2099 if (!pl.szUserName) return E_INVALIDARG;
2100 addr = pl.pUserName;
2101 size = pl.szUserName;
2102 break;
2103
2104 case URL_PART_PASSWORD:
2105 if (!pl.szPassword) return E_INVALIDARG;
2106 addr = pl.pPassword;
2107 size = pl.szPassword;
2108 break;
2109
2110 case URL_PART_PORT:
2111 if (!pl.szPort) return E_INVALIDARG;
2112 addr = pl.pPort;
2113 size = pl.szPort;
2114 break;
2115
2116 case URL_PART_QUERY:
2117 if (!pl.szQuery) return E_INVALIDARG;
2118 addr = pl.pQuery;
2119 size = pl.szQuery;
2120 break;
2121
2122 default:
2123 return E_INVALIDARG;
2124 }
2125
2126 if (dwFlags == URL_PARTFLAG_KEEPSCHEME) {
2127 if (*pcchOut < schsize + size + 2) {
2128 *pcchOut = schsize + size + 2;
2129 return E_POINTER;
2130 }
2131 memcpy(pszOut, schaddr, schsize*sizeof(WCHAR));
2132 pszOut[schsize] = ':';
2133 memcpy(pszOut+schsize+1, addr, size*sizeof(WCHAR));
2134 pszOut[schsize+1+size] = 0;
2135 *pcchOut = schsize + 1 + size;
2136 }
2137 else {
2138 if (*pcchOut < size + 1) {*pcchOut = size+1; return E_POINTER;}
2139 memcpy(pszOut, addr, size*sizeof(WCHAR));
2140 pszOut[size] = 0;
2141 *pcchOut = size;
2142 }
2143 TRACE("len=%d %s\n", *pcchOut, debugstr_w(pszOut));
2144 }
2145 return ret;
2146 }
2147
2148 /*************************************************************************
2149 * PathIsURLA [SHLWAPI.@]
2150 *
2151 * Check if the given path is a Url.
2152 *
2153 * PARAMS
2154 * lpszPath [I] Path to check.
2155 *
2156 * RETURNS
2157 * TRUE if lpszPath is a Url.
2158 * FALSE if lpszPath is NULL or not a Url.
2159 */
2160 BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
2161 {
2162 PARSEDURLA base;
2163
2164 TRACE("%s\n", debugstr_a(lpstrPath));
2165
2166 if (!lpstrPath || !*lpstrPath) return FALSE;
2167
2168 /* get protocol */
2169 base.cbSize = sizeof(base);
2170 ParseURLA(lpstrPath, &base);
2171 return (base.nScheme != URL_SCHEME_INVALID);
2172 }
2173
2174 /*************************************************************************
2175 * PathIsURLW [SHLWAPI.@]
2176 *
2177 * See PathIsURLA.
2178 */
2179 BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
2180 {
2181 PARSEDURLW base;
2182
2183 TRACE("%s\n", debugstr_w(lpstrPath));
2184
2185 if (!lpstrPath || !*lpstrPath) return FALSE;
2186
2187 /* get protocol */
2188 base.cbSize = sizeof(base);
2189 ParseURLW(lpstrPath, &base);
2190 return (base.nScheme != URL_SCHEME_INVALID);
2191 }
2192
2193 /*************************************************************************
2194 * UrlCreateFromPathA [SHLWAPI.@]
2195 *
2196 * See UrlCreateFromPathW
2197 */
2198 HRESULT WINAPI UrlCreateFromPathA(LPCSTR pszPath, LPSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2199 {
2200 WCHAR bufW[INTERNET_MAX_URL_LENGTH];
2201 WCHAR *urlW = bufW;
2202 UNICODE_STRING pathW;
2203 HRESULT ret;
2204 DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
2205
2206 if(!RtlCreateUnicodeStringFromAsciiz(&pathW, pszPath))
2207 return E_INVALIDARG;
2208 if((ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved)) == E_POINTER) {
2209 urlW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
2210 ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved);
2211 }
2212 if(ret == S_OK || ret == S_FALSE) {
2213 RtlUnicodeToMultiByteSize(&lenA, urlW, lenW * sizeof(WCHAR));
2214 if(*pcchUrl > lenA) {
2215 RtlUnicodeToMultiByteN(pszUrl, *pcchUrl - 1, &lenA, urlW, lenW * sizeof(WCHAR));
2216 pszUrl[lenA] = 0;
2217 *pcchUrl = lenA;
2218 } else {
2219 *pcchUrl = lenA + 1;
2220 ret = E_POINTER;
2221 }
2222 }
2223 if(urlW != bufW) HeapFree(GetProcessHeap(), 0, urlW);
2224 RtlFreeUnicodeString(&pathW);
2225 return ret;
2226 }
2227
2228 /*************************************************************************
2229 * UrlCreateFromPathW [SHLWAPI.@]
2230 *
2231 * Create a Url from a file path.
2232 *
2233 * PARAMS
2234 * pszPath [I] Path to convert
2235 * pszUrl [O] Destination for the converted Url
2236 * pcchUrl [I/O] Length of pszUrl
2237 * dwReserved [I] Reserved, must be 0
2238 *
2239 * RETURNS
2240 * Success: S_OK pszUrl contains the converted path, S_FALSE if the path is already a Url
2241 * Failure: An HRESULT error code.
2242 */
2243 HRESULT WINAPI UrlCreateFromPathW(LPCWSTR pszPath, LPWSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2244 {
2245 DWORD needed;
2246 HRESULT ret;
2247 WCHAR *pszNewUrl;
2248 WCHAR file_colonW[] = {'f','i','l','e',':',0};
2249 WCHAR three_slashesW[] = {'/','/','/',0};
2250 PARSEDURLW parsed_url;
2251
2252 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszPath), pszUrl, pcchUrl, dwReserved);
2253
2254 /* Validate arguments */
2255 if (dwReserved != 0)
2256 return E_INVALIDARG;
2257 if (!pszUrl || !pcchUrl)
2258 return E_INVALIDARG;
2259
2260
2261 parsed_url.cbSize = sizeof(parsed_url);
2262 if(ParseURLW(pszPath, &parsed_url) == S_OK) {
2263 if(parsed_url.nScheme != URL_SCHEME_INVALID && parsed_url.cchProtocol > 1) {
2264 needed = strlenW(pszPath);
2265 if (needed >= *pcchUrl) {
2266 *pcchUrl = needed + 1;
2267 return E_POINTER;
2268 } else {
2269 *pcchUrl = needed;
2270 strcpyW(pszUrl, pszPath);
2271 return S_FALSE;
2272 }
2273 }
2274 }
2275
2276 pszNewUrl = HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath) + 9) * sizeof(WCHAR)); /* "file:///" + pszPath_len + 1 */
2277 strcpyW(pszNewUrl, file_colonW);
2278 if(isalphaW(pszPath[0]) && pszPath[1] == ':')
2279 strcatW(pszNewUrl, three_slashesW);
2280 strcatW(pszNewUrl, pszPath);
2281 ret = UrlEscapeW(pszNewUrl, pszUrl, pcchUrl, URL_ESCAPE_PERCENT);
2282
2283 HeapFree(GetProcessHeap(), 0, pszNewUrl);
2284 return ret;
2285 }
2286
2287 /*************************************************************************
2288 * SHAutoComplete [SHLWAPI.@]
2289 *
2290 * Enable auto-completion for an edit control.
2291 *
2292 * PARAMS
2293 * hwndEdit [I] Handle of control to enable auto-completion for
2294 * dwFlags [I] SHACF_ flags from "shlwapi.h"
2295 *
2296 * RETURNS
2297 * Success: S_OK. Auto-completion is enabled for the control.
2298 * Failure: An HRESULT error code indicating the error.
2299 */
2300 HRESULT WINAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags)
2301 {
2302 FIXME("SHAutoComplete stub\n");
2303 return S_FALSE;
2304 }
2305
2306 /*************************************************************************
2307 * MLBuildResURLA [SHLWAPI.405]
2308 *
2309 * Create a Url pointing to a resource in a module.
2310 *
2311 * PARAMS
2312 * lpszLibName [I] Name of the module containing the resource
2313 * hMod [I] Callers module handle
2314 * dwFlags [I] Undocumented flags for loading the module
2315 * lpszRes [I] Resource name
2316 * lpszDest [O] Destination for resulting Url
2317 * dwDestLen [I] Length of lpszDest
2318 *
2319 * RETURNS
2320 * Success: S_OK. lpszDest contains the resource Url.
2321 * Failure: E_INVALIDARG, if any argument is invalid, or
2322 * E_FAIL if dwDestLen is too small.
2323 */
2324 HRESULT WINAPI MLBuildResURLA(LPCSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2325 LPCSTR lpszRes, LPSTR lpszDest, DWORD dwDestLen)
2326 {
2327 WCHAR szLibName[MAX_PATH], szRes[MAX_PATH], szDest[MAX_PATH];
2328 HRESULT hRet;
2329
2330 if (lpszLibName)
2331 MultiByteToWideChar(CP_ACP, 0, lpszLibName, -1, szLibName, sizeof(szLibName)/sizeof(WCHAR));
2332
2333 if (lpszRes)
2334 MultiByteToWideChar(CP_ACP, 0, lpszRes, -1, szRes, sizeof(szRes)/sizeof(WCHAR));
2335
2336 if (dwDestLen > sizeof(szLibName)/sizeof(WCHAR))
2337 dwDestLen = sizeof(szLibName)/sizeof(WCHAR);
2338
2339 hRet = MLBuildResURLW(lpszLibName ? szLibName : NULL, hMod, dwFlags,
2340 lpszRes ? szRes : NULL, lpszDest ? szDest : NULL, dwDestLen);
2341 if (SUCCEEDED(hRet) && lpszDest)
2342 WideCharToMultiByte(CP_ACP, 0, szDest, -1, lpszDest, dwDestLen, 0, 0);
2343
2344 return hRet;
2345 }
2346
2347 /*************************************************************************
2348 * MLBuildResURLA [SHLWAPI.406]
2349 *
2350 * See MLBuildResURLA.
2351 */
2352 HRESULT WINAPI MLBuildResURLW(LPCWSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2353 LPCWSTR lpszRes, LPWSTR lpszDest, DWORD dwDestLen)
2354 {
2355 static const WCHAR szRes[] = { 'r','e','s',':','/','/','\0' };
2356 #define szResLen ((sizeof(szRes) - sizeof(WCHAR))/sizeof(WCHAR))
2357 HRESULT hRet = E_FAIL;
2358
2359 TRACE("(%s,%p,0x%08x,%s,%p,%d)\n", debugstr_w(lpszLibName), hMod, dwFlags,
2360 debugstr_w(lpszRes), lpszDest, dwDestLen);
2361
2362 if (!lpszLibName || !hMod || hMod == INVALID_HANDLE_VALUE || !lpszRes ||
2363 !lpszDest || (dwFlags && dwFlags != 2))
2364 return E_INVALIDARG;
2365
2366 if (dwDestLen >= szResLen + 1)
2367 {
2368 dwDestLen -= (szResLen + 1);
2369 memcpy(lpszDest, szRes, sizeof(szRes));
2370
2371 hMod = MLLoadLibraryW(lpszLibName, hMod, dwFlags);
2372
2373 if (hMod)
2374 {
2375 WCHAR szBuff[MAX_PATH];
2376 DWORD len;
2377
2378 len = GetModuleFileNameW(hMod, szBuff, sizeof(szBuff)/sizeof(WCHAR));
2379 if (len && len < sizeof(szBuff)/sizeof(WCHAR))
2380 {
2381 DWORD dwPathLen = strlenW(szBuff) + 1;
2382
2383 if (dwDestLen >= dwPathLen)
2384 {
2385 DWORD dwResLen;
2386
2387 dwDestLen -= dwPathLen;
2388 memcpy(lpszDest + szResLen, szBuff, dwPathLen * sizeof(WCHAR));
2389
2390 dwResLen = strlenW(lpszRes) + 1;
2391 if (dwDestLen >= dwResLen + 1)
2392 {
2393 lpszDest[szResLen + dwPathLen + dwResLen] = '/';
2394 memcpy(lpszDest + szResLen + dwPathLen, lpszRes, dwResLen * sizeof(WCHAR));
2395 hRet = S_OK;
2396 }
2397 }
2398 }
2399 MLFreeLibrary(hMod);
2400 }
2401 }
2402 return hRet;
2403 }
DirectPlay implementation for GSoC