dlls/urlmon/internet.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "urlmon_main.h"
  20 #include "winreg.h"
  21 #include "shlwapi.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  26
  27 static HRESULT parse_schema(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
  28 {
  29     WCHAR *ptr;
  30     DWORD len = 0;
  31
  32     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
  33
  34     if(flags)
  35         ERR("wrong flags\n");
  36
  37     ptr = strchrW(url, ':');
  38     if(ptr)
  39         len = ptr-url;
  40
  41     if(rsize)
  42         *rsize = len;
  43
  44     if(len >= size)
  45         return E_POINTER;
  46
  47     if(len)
  48         memcpy(result, url, len*sizeof(WCHAR));
  49     result[len] = 0;
  50
  51     return S_OK;
  52 }
  53
  54 static HRESULT parse_canonicalize_url(LPCWSTR url, DWORD flags, LPWSTR result,
  55         DWORD size, DWORD *rsize)
  56 {
  57     IInternetProtocolInfo *protocol_info;
  58     DWORD prsize = size;
  59     HRESULT hres;
  60
  61     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
  62
  63     protocol_info = get_protocol_info(url);
  64
  65     if(protocol_info) {
  66         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_CANONICALIZE,
  67                 flags, result, size, rsize, 0);
  68         IInternetProtocolInfo_Release(protocol_info);
  69         if(SUCCEEDED(hres))
  70             return hres;
  71     }
  72
  73     hres = UrlCanonicalizeW(url, result, &prsize, flags);
  74
  75     if(rsize)
  76         *rsize = prsize;
  77     return hres;
  78 }
  79
  80 static HRESULT parse_security_url(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
  81 {
  82     IInternetProtocolInfo *protocol_info;
  83     HRESULT hres;
  84
  85     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
  86
  87     protocol_info = get_protocol_info(url);
  88
  89     if(protocol_info) {
  90         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_URL,
  91                 flags, result, size, rsize, 0);
  92         IInternetProtocolInfo_Release(protocol_info);
  93         return hres;
  94     }
  95
  96     return E_FAIL;
  97 }
  98
  99 static HRESULT parse_encode(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
 100 {
 101     IInternetProtocolInfo *protocol_info;
 102     DWORD prsize;
 103     HRESULT hres;
 104
 105     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 106
 107     protocol_info = get_protocol_info(url);
 108
 109     if(protocol_info) {
 110         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_ENCODE,
 111                 flags, result, size, rsize, 0);
 112         IInternetProtocolInfo_Release(protocol_info);
 113         if(SUCCEEDED(hres))
 114             return hres;
 115     }
 116
 117     prsize = size;
 118     hres = UrlUnescapeW((LPWSTR)url, result, &prsize, flags);
 119
 120     if(rsize)
 121         *rsize = prsize;
 122
 123     return hres;
 124 }
 125
 126 static HRESULT parse_path_from_url(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
 127 {
 128     IInternetProtocolInfo *protocol_info;
 129     DWORD prsize;
 130     HRESULT hres;
 131
 132     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 133
 134     protocol_info = get_protocol_info(url);
 135
 136     if(protocol_info) {
 137         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_PATH_FROM_URL,
 138                 flags, result, size, rsize, 0);
 139         IInternetProtocolInfo_Release(protocol_info);
 140         if(SUCCEEDED(hres))
 141             return hres;
 142     }
 143
 144     prsize = size;
 145     hres = PathCreateFromUrlW(url, result, &prsize, 0);
 146
 147     if(rsize)
 148         *rsize = prsize;
 149     return hres;
 150 }
 151
 152 static HRESULT parse_security_domain(LPCWSTR url, DWORD flags, LPWSTR result,
 153         DWORD size, DWORD *rsize)
 154 {
 155     IInternetProtocolInfo *protocol_info;
 156     HRESULT hres;
 157
 158     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 159
 160     protocol_info = get_protocol_info(url);
 161
 162     if(protocol_info) {
 163         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_DOMAIN,
 164                 flags, result, size, rsize, 0);
 165         IInternetProtocolInfo_Release(protocol_info);
 166         if(SUCCEEDED(hres))
 167             return hres;
 168     }
 169
 170     return E_FAIL;
 171 }
 172
 173 static HRESULT parse_domain(LPCWSTR url, DWORD flags, LPWSTR result,
 174         DWORD size, DWORD *rsize)
 175 {
 176     IInternetProtocolInfo *protocol_info;
 177     HRESULT hres;
 178
 179     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 180
 181     protocol_info = get_protocol_info(url);
 182
 183     if(protocol_info) {
 184         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_DOMAIN,
 185                 flags, result, size, rsize, 0);
 186         IInternetProtocolInfo_Release(protocol_info);
 187         if(SUCCEEDED(hres))
 188             return hres;
 189     }
 190
 191     hres = UrlGetPartW(url, result, &size, URL_PART_HOSTNAME, flags);
 192     if(rsize)
 193         *rsize = size;
 194
 195     if(hres == E_POINTER)
 196         return S_FALSE;
 197
 198     if(FAILED(hres))
 199         return E_FAIL;
 200     return S_OK;
 201 }
 202
 203 static HRESULT parse_rootdocument(LPCWSTR url, DWORD flags, LPWSTR result,
 204         DWORD size, DWORD *rsize)
 205 {
 206     IInternetProtocolInfo *protocol_info;
 207     PARSEDURLW url_info;
 208     HRESULT hres;
 209
 210     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 211
 212     protocol_info = get_protocol_info(url);
 213
 214     if(protocol_info) {
 215         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_ROOTDOCUMENT,
 216                 flags, result, size, rsize, 0);
 217         IInternetProtocolInfo_Release(protocol_info);
 218         if(SUCCEEDED(hres))
 219             return hres;
 220     }
 221
 222     url_info.cbSize = sizeof(url_info);
 223     if(FAILED(ParseURLW(url, &url_info)))
 224         return E_FAIL;
 225
 226     switch(url_info.nScheme) {
 227         case URL_SCHEME_FTP:
 228         case URL_SCHEME_HTTP:
 229         case URL_SCHEME_HTTPS:
 230             if(url_info.cchSuffix<3 || *(url_info.pszSuffix)!='/'
 231                     || *(url_info.pszSuffix+1)!='/')
 232                 return E_FAIL;
 233
 234             if(size < url_info.cchProtocol+3) {
 235                 size = 0;
 236                 hres = UrlGetPartW(url, result, &size, URL_PART_HOSTNAME, flags);
 237
 238                 if(rsize)
 239                     *rsize = size+url_info.cchProtocol+3;
 240
 241                 if(hres == E_POINTER)
 242                     return S_FALSE;
 243
 244                 return hres;
 245             }
 246
 247             size -= url_info.cchProtocol+3;
 248             hres = UrlGetPartW(url, result+url_info.cchProtocol+3,
 249                     &size, URL_PART_HOSTNAME, flags);
 250
 251             if(hres == E_POINTER)
 252                 return S_FALSE;
 253
 254             if(FAILED(hres))
 255                 return E_FAIL;
 256
 257             if(rsize)
 258                 *rsize = size+url_info.cchProtocol+3;
 259
 260             memcpy(result, url, (url_info.cchProtocol+3)*sizeof(WCHAR));
 261             return hres;
 262         default:
 263             return E_FAIL;
 264     }
 265 }
 266
 267 /**************************************************************************
 268  *          CoInternetParseUrl    (URLMON.@)
 269  */
 270 HRESULT WINAPI CoInternetParseUrl(LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD dwFlags,
 271         LPWSTR pszResult, DWORD cchResult, DWORD *pcchResult, DWORD dwReserved)
 272 {
 273     if(dwReserved)
 274         WARN("dwReserved = %d\n", dwReserved);
 275
 276     switch(ParseAction) {
 277     case PARSE_CANONICALIZE:
 278         return parse_canonicalize_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 279     case PARSE_SECURITY_URL:
 280         return parse_security_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 281     case PARSE_ENCODE:
 282         return parse_encode(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 283     case PARSE_PATH_FROM_URL:
 284         return parse_path_from_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 285     case PARSE_SCHEMA:
 286         return parse_schema(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 287     case PARSE_SECURITY_DOMAIN:
 288         return parse_security_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 289     case PARSE_DOMAIN:
 290         return parse_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 291     case PARSE_ROOTDOCUMENT:
 292         return parse_rootdocument(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 293     default:
 294         FIXME("not supported action %d\n", ParseAction);
 295     }
 296
 297     return E_NOTIMPL;
 298 }
 299
 300 /**************************************************************************
 301  *          CoInternetCombineUrl    (URLMON.@)
 302  */
 303 HRESULT WINAPI CoInternetCombineUrl(LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl,
 304         DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult,
 305         DWORD dwReserved)
 306 {
 307     IInternetProtocolInfo *protocol_info;
 308     DWORD size = cchResult;
 309     HRESULT hres;
 310
 311     TRACE("(%s,%s,0x%08x,%p,%d,%p,%d)\n", debugstr_w(pwzBaseUrl),
 312           debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult, pcchResult,
 313           dwReserved);
 314
 315     protocol_info = get_protocol_info(pwzBaseUrl);
 316
 317     if(protocol_info) {
 318         hres = IInternetProtocolInfo_CombineUrl(protocol_info, pwzBaseUrl, pwzRelativeUrl,
 319                 dwCombineFlags, pwzResult, cchResult, pcchResult, dwReserved);
 320         IInternetProtocolInfo_Release(protocol_info);
 321         if(SUCCEEDED(hres))
 322             return hres;
 323     }
 324
 325
 326     hres = UrlCombineW(pwzBaseUrl, pwzRelativeUrl, pwzResult, &size, dwCombineFlags);
 327
 328     if(pcchResult)
 329         *pcchResult = size;
 330
 331     return hres;
 332 }
 333
 334 /**************************************************************************
 335  *          CoInternetCompareUrl    (URLMON.@)
 336  */
 337 HRESULT WINAPI CoInternetCompareUrl(LPCWSTR pwzUrl1, LPCWSTR pwzUrl2, DWORD dwCompareFlags)
 338 {
 339     IInternetProtocolInfo *protocol_info;
 340     HRESULT hres;
 341
 342     TRACE("(%s,%s,%08x)\n", debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 343
 344     protocol_info = get_protocol_info(pwzUrl1);
 345
 346     if(protocol_info) {
 347         hres = IInternetProtocolInfo_CompareUrl(protocol_info, pwzUrl1, pwzUrl2, dwCompareFlags);
 348         IInternetProtocolInfo_Release(protocol_info);
 349         if(SUCCEEDED(hres))
 350             return hres;
 351     }
 352
 353     return UrlCompareW(pwzUrl1, pwzUrl2, dwCompareFlags) ? S_FALSE : S_OK;
 354 }
 355
 356 /***********************************************************************
 357  *           CoInternetQueryInfo (URLMON.@)
 358  *
 359  * Retrieves information relevant to a specified URL
 360  *
 361  */
 362 HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption,
 363         DWORD dwQueryFlags, LPVOID pvBuffer, DWORD cbBuffer, DWORD *pcbBuffer,
 364         DWORD dwReserved)
 365 {
 366     IInternetProtocolInfo *protocol_info;
 367     HRESULT hres;
 368
 369     TRACE("(%s, %x, %x, %p, %x, %p, %x): stub\n", debugstr_w(pwzUrl),
 370           QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 371
 372     protocol_info = get_protocol_info(pwzUrl);
 373
 374     if(protocol_info) {
 375         hres = IInternetProtocolInfo_QueryInfo(protocol_info, pwzUrl, QueryOption, dwQueryFlags,
 376                 pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 377         IInternetProtocolInfo_Release(protocol_info);
 378
 379         return SUCCEEDED(hres) ? hres : E_FAIL;
 380     }
 381
 382     switch(QueryOption) {
 383     case QUERY_USES_NETWORK:
 384         if(!pvBuffer || cbBuffer < sizeof(DWORD))
 385             return E_FAIL;
 386
 387         *(DWORD*)pvBuffer = 0;
 388         if(pcbBuffer)
 389             *pcbBuffer = sizeof(DWORD);
 390         break;
 391
 392     default:
 393         FIXME("Not supported option %d\n", QueryOption);
 394         return E_NOTIMPL;
 395     }
 396
 397     return S_OK;
 398 }
 399
 400 /***********************************************************************
 401  *             CoInternetSetFeatureEnabled (URLMON.@)
 402  */
 403 HRESULT WINAPI CoInternetSetFeatureEnabled(INTERNETFEATURELIST feature, DWORD flags, BOOL enable)
 404 {
 405     FIXME("%d, 0x%08x, %x, stub\n", feature, flags, enable);
 406     return E_NOTIMPL;
 407 }
 408
 409 /***********************************************************************
 410  *             CoInternetIsFeatureEnabled (URLMON.@)
 411  */
 412 HRESULT WINAPI CoInternetIsFeatureEnabled(INTERNETFEATURELIST feature, DWORD flags)
 413 {
 414     FIXME("%d, 0x%08x, stub\n", feature, flags);
 415     return E_NOTIMPL;
 416 }