programs/winebrowser/main.c

   1 /*
   2  * winebrowser - winelib app to launch native OS browser or mail client.
   3  *
   4  * Copyright (C) 2004 Chris Morgan
   5  * Copyright (C) 2005 Hans Leidekker
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * NOTES:
  22  *  Winebrowser is a winelib application that will start the appropriate
  23  *  native browser or mail client for a wine installation that lacks a
  24  *  windows browser/mail client. For example, you will be able to open
  25  *  URLs via native mozilla if no browser has yet been installed in wine.
  26  *
  27  *  The application to launch is chosen from a default set or, if set,
  28  *  taken from a registry key.
  29  *
  30  *  The argument may be a regular Windows file name, a file URL, an
  31  *  URL or a mailto URL. In the first three cases the argument
  32  *  will be fed to a web browser. In the last case the argument is fed
  33  *  to a mail client. A mailto URL is composed as follows:
  34  *
  35  *   mailto:[E-MAIL]?subject=[TOPIC]&cc=[E-MAIL]&bcc=[E-MAIL]&body=[TEXT]
  36  */
  37
  38 #define WIN32_LEAN_AND_MEAN
  39 #define COBJMACROS
  40
  41 #include "config.h"
  42 #include "wine/port.h"
  43 #include "wine/debug.h"
  44 #include "wine/unicode.h"
  45
  46 #include <windows.h>
  47 #include <shlwapi.h>
  48 #include <shellapi.h>
  49 #include <urlmon.h>
  50 #include <ddeml.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <errno.h>
  54
  55 WINE_DEFAULT_DEBUG_CHANNEL(winebrowser);
  56
  57 typedef LPSTR (*wine_get_unix_file_name_t)(LPCWSTR unixname);
  58
  59 static const WCHAR browser_key[] =
  60     {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
  61      'W','i','n','e','B','r','o','w','s','e','r',0};
  62
  63 static char *strdup_unixcp( const WCHAR *str )
  64 {
  65     char *ret;
  66     int len = WideCharToMultiByte( CP_UNIXCP, 0, str, -1, NULL, 0, NULL, NULL );
  67     if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
  68         WideCharToMultiByte( CP_UNIXCP, 0, str, -1, ret, len, NULL, NULL );
  69     return ret;
  70 }
  71
  72 /* try to launch a unix app from a comma separated string of app names */
  73 static int launch_app( const WCHAR *candidates, const WCHAR *argv1 )
  74 {
  75     char *cmdline;
  76     int i, count;
  77     char **argv_new;
  78
  79     if (!(cmdline = strdup_unixcp( argv1 ))) return 1;
  80
  81     while (*candidates)
  82     {
  83         WCHAR **args = CommandLineToArgvW( candidates, &count );
  84
  85         if (!(argv_new = HeapAlloc( GetProcessHeap(), 0, (count + 1) * sizeof(*argv_new) ))) break;
  86         for (i = 0; i < count; i++) argv_new[i] = strdup_unixcp( args[i] );
  87         argv_new[count] = cmdline;
  88         argv_new[count + 1] = NULL;
  89
  90         TRACE( "Trying" );
  91         for (i = 0; i <= count; i++) TRACE( " %s", wine_dbgstr_a( argv_new[i] ));
  92         TRACE( "\n" );
  93
  94         _spawnvp( _P_OVERLAY, argv_new[0], (const char **)argv_new );  /* only returns on error */
  95         for (i = 0; i < count; i++) HeapFree( GetProcessHeap(), 0, argv_new[i] );
  96         HeapFree( GetProcessHeap(), 0, argv_new );
  97         candidates += strlenW( candidates ) + 1;  /* grab the next app */
  98     }
  99     WINE_ERR( "could not find a suitable app to open %s\n", debugstr_w( argv1 ));
 100
 101     HeapFree( GetProcessHeap(), 0, cmdline );
 102     return 1;
 103 }
 104
 105 static LSTATUS get_commands( HKEY key, const WCHAR *value, WCHAR *buffer, DWORD size )
 106 {
 107     DWORD type;
 108     LSTATUS res;
 109
 110     size -= sizeof(WCHAR);
 111     if (!(res = RegQueryValueExW( key, value, 0, &type, (LPBYTE)buffer, &size )) && (type == REG_SZ))
 112     {
 113         /* convert to REG_MULTI_SZ type */
 114         WCHAR *p = buffer;
 115         p[strlenW(p) + 1] = 0;
 116         while ((p = strchrW( p, ',' ))) *p++ = 0;
 117     }
 118     return res;
 119 }
 120
 121 static int open_http_url( const WCHAR *url )
 122 {
 123 #ifdef __APPLE__
 124     static const WCHAR defaultbrowsers[] =
 125         { '/','u','s','r','/','b','i','n','/','o','p','e','n',0,0 };
 126 #else
 127     static const WCHAR defaultbrowsers[] =
 128         {'x','d','g','-','o','p','e','n',0,
 129          'f','i','r','e','f','o','x',0,
 130          'k','o','n','q','u','e','r','o','r',0,
 131          'm','o','z','i','l','l','a',0,
 132          'n','e','t','s','c','a','p','e',0,
 133          'g','a','l','e','o','n',0,
 134          'o','p','e','r','a',0,
 135          'd','i','l','l','o',0,0};
 136 #endif
 137     static const WCHAR browsersW[] =
 138         {'B','r','o','w','s','e','r','s',0};
 139
 140     WCHAR browsers[256];
 141     HKEY key;
 142     LONG r;
 143
 144     /* @@ Wine registry key: HKCU\Software\Wine\WineBrowser */
 145     if  (!(r = RegOpenKeyW( HKEY_CURRENT_USER, browser_key, &key )))
 146     {
 147         r = get_commands( key, browsersW, browsers, sizeof(browsers) );
 148         RegCloseKey( key );
 149     }
 150     if (r != ERROR_SUCCESS)
 151         memcpy( browsers, defaultbrowsers, sizeof(defaultbrowsers) );
 152
 153     return launch_app( browsers, url );
 154 }
 155
 156 static int open_mailto_url( const WCHAR *url )
 157 {
 158 #ifdef __APPLE__
 159     static const WCHAR defaultmailers[] =
 160         { '/','u','s','r','/','b','i','n','/','o','p','e','n',0,0 };
 161 #else
 162     static const WCHAR defaultmailers[] =
 163         {'x','d','g','-','e','m','a','i','l',0,
 164          'm','o','z','i','l','l','a','-','t','h','u','n','d','e','r','b','i','r','d',0,
 165          't','h','u','n','d','e','r','b','i','r','d',0,
 166          'e','v','o','l','u','t','i','o','n',0,0 };
 167 #endif
 168     static const WCHAR mailersW[] =
 169         {'M','a','i','l','e','r','s',0};
 170
 171     WCHAR mailers[256];
 172     HKEY key;
 173     LONG r;
 174
 175     /* @@ Wine registry key: HKCU\Software\Wine\WineBrowser */
 176     if (!(r = RegOpenKeyW( HKEY_CURRENT_USER, browser_key, &key )))
 177     {
 178         r = get_commands( key, mailersW, mailers, sizeof(mailers) );
 179         RegCloseKey( key );
 180     }
 181     if (r != ERROR_SUCCESS)
 182         memcpy( mailers, defaultmailers, sizeof(defaultmailers) );
 183
 184     return launch_app( mailers, url );
 185 }
 186
 187 /*****************************************************************************
 188  * DDE helper functions.
 189  */
 190
 191 static WCHAR *ddeString = NULL;
 192 static HSZ hszTopic = 0, hszReturn = 0;
 193 static DWORD ddeInst = 0;
 194
 195 /* Dde callback, save the execute or request string for processing */
 196 static HDDEDATA CALLBACK ddeCb(UINT uType, UINT uFmt, HCONV hConv,
 197                                 HSZ hsz1, HSZ hsz2, HDDEDATA hData,
 198                                 ULONG_PTR dwData1, ULONG_PTR dwData2)
 199 {
 200     DWORD size = 0, ret = 0;
 201
 202     WINE_TRACE("dde_cb: %04x, %04x, %p, %p, %p, %p, %08lx, %08lx\n",
 203                uType, uFmt, hConv, hsz1, hsz2, hData, dwData1, dwData2);
 204
 205     switch (uType)
 206     {
 207         case XTYP_CONNECT:
 208             if (!DdeCmpStringHandles(hsz1, hszTopic))
 209                 return (HDDEDATA)TRUE;
 210             return (HDDEDATA)FALSE;
 211
 212         case XTYP_EXECUTE:
 213             if (!(size = DdeGetData(hData, NULL, 0, 0)))
 214                 WINE_ERR("DdeGetData returned zero size of execute string\n");
 215             else if (!(ddeString = HeapAlloc(GetProcessHeap(), 0, size)))
 216                 WINE_ERR("Out of memory\n");
 217             else if (DdeGetData(hData, (LPBYTE)ddeString, size, 0) != size)
 218                 WINE_WARN("DdeGetData did not return %d bytes\n", size);
 219             DdeFreeDataHandle(hData);
 220             return (HDDEDATA)DDE_FACK;
 221
 222         case XTYP_REQUEST:
 223             ret = -3; /* error */
 224             if (!(size = DdeQueryStringW(ddeInst, hsz2, NULL, 0, CP_WINUNICODE)))
 225                 WINE_ERR("DdeQueryString returned zero size of request string\n");
 226             else if (!(ddeString = HeapAlloc(GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR))))
 227                 WINE_ERR("Out of memory\n");
 228             else if (DdeQueryStringW(ddeInst, hsz2, ddeString, size + 1, CP_WINUNICODE) != size)
 229                 WINE_WARN("DdeQueryString did not return %d characters\n", size);
 230             else
 231                 ret = -2; /* acknowledgment */
 232             return DdeCreateDataHandle(ddeInst, (LPBYTE)&ret, sizeof(ret), 0,
 233                                        hszReturn, CF_TEXT, 0);
 234
 235         default:
 236             return NULL;
 237     }
 238 }
 239
 240 static WCHAR *get_url_from_dde(void)
 241 {
 242     static const WCHAR szApplication[] = {'I','E','x','p','l','o','r','e',0};
 243     static const WCHAR szTopic[] = {'W','W','W','_','O','p','e','n','U','R','L',0};
 244     static const WCHAR szReturn[] = {'R','e','t','u','r','n',0};
 245
 246     HSZ hszApplication = 0;
 247     UINT_PTR timer = 0;
 248     int rc;
 249     WCHAR *ret = NULL;
 250
 251     rc = DdeInitializeW(&ddeInst, ddeCb, CBF_SKIP_ALLNOTIFICATIONS | CBF_FAIL_ADVISES | CBF_FAIL_POKES, 0);
 252     if (rc != DMLERR_NO_ERROR)
 253     {
 254         WINE_ERR("Unable to initialize DDE, DdeInitialize returned %d\n", rc);
 255         goto done;
 256     }
 257
 258     hszApplication = DdeCreateStringHandleW(ddeInst, szApplication, CP_WINUNICODE);
 259     if (!hszApplication)
 260     {
 261         WINE_ERR("Unable to initialize DDE, DdeCreateStringHandle failed\n");
 262         goto done;
 263     }
 264
 265     hszTopic = DdeCreateStringHandleW(ddeInst, szTopic, CP_WINUNICODE);
 266     if (!hszTopic)
 267     {
 268         WINE_ERR("Unable to initialize DDE, DdeCreateStringHandle failed\n");
 269         goto done;
 270     }
 271
 272     hszReturn = DdeCreateStringHandleW(ddeInst, szReturn, CP_WINUNICODE);
 273     if (!hszReturn)
 274     {
 275         WINE_ERR("Unable to initialize DDE, DdeCreateStringHandle failed\n");
 276         goto done;
 277     }
 278
 279     if (!DdeNameService(ddeInst, hszApplication, 0, DNS_REGISTER))
 280     {
 281         WINE_ERR("Unable to initialize DDE, DdeNameService failed\n");
 282         goto done;
 283     }
 284
 285     timer = SetTimer(NULL, 0, 5000, NULL);
 286     if (!timer)
 287     {
 288         WINE_ERR("SetTimer failed to create timer\n");
 289         goto done;
 290     }
 291
 292     while (!ddeString)
 293     {
 294         MSG msg;
 295         if (!GetMessageW(&msg, NULL, 0, 0)) break;
 296         if (msg.message == WM_TIMER) break;
 297         DispatchMessageW(&msg);
 298     }
 299
 300     if (ddeString)
 301     {
 302         if (*ddeString == '"')
 303         {
 304             WCHAR *endquote = strchrW(ddeString + 1, '"');
 305             if (!endquote)
 306             {
 307                 WINE_ERR("Unable to retrieve URL from string %s\n", wine_dbgstr_w(ddeString));
 308                 goto done;
 309             }
 310             *endquote = 0;
 311             ret = ddeString+1;
 312         }
 313         else
 314             ret = ddeString;
 315     }
 316
 317 done:
 318     if (timer) KillTimer(NULL, timer);
 319     if (ddeInst)
 320     {
 321         if (hszTopic && hszApplication) DdeNameService(ddeInst, hszApplication, 0, DNS_UNREGISTER);
 322         if (hszReturn) DdeFreeStringHandle(ddeInst, hszReturn);
 323         if (hszTopic) DdeFreeStringHandle(ddeInst, hszTopic);
 324         if (hszApplication) DdeFreeStringHandle(ddeInst, hszApplication);
 325         DdeUninitialize(ddeInst);
 326     }
 327     return ret;
 328 }
 329
 330 static WCHAR *encode_unix_path(const char *src)
 331 {
 332     const char *tmp_src;
 333     WCHAR *dst, *tmp_dst;
 334     const char safe_chars[] = "/-_.~@&=+$,:";
 335     const char hex_digits[] = "0123456789ABCDEF";
 336     const WCHAR schema[] = {'f','i','l','e',':','/','/',0};
 337     int len = sizeof(schema)/sizeof(schema[0]);
 338
 339     tmp_src = src;
 340
 341     while (*tmp_src != 0)
 342     {
 343         if ((*tmp_src >= 'a' && *tmp_src <= 'z') ||
 344             (*tmp_src >= 'A' && *tmp_src <= 'Z') ||
 345             (*tmp_src >= '0' && *tmp_src <= '9') ||
 346             strchr(safe_chars, *tmp_src))
 347             len += 1;
 348         else
 349             len += 3;
 350         tmp_src++;
 351     }
 352
 353     dst = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 354
 355     if (!dst)
 356         return NULL;
 357
 358     strcpyW(dst, schema);
 359
 360     tmp_src = src;
 361     tmp_dst = dst + strlenW(dst);
 362
 363     while (*tmp_src != 0)
 364     {
 365         if ((*tmp_src >= 'a' && *tmp_src <= 'z') ||
 366             (*tmp_src >= 'A' && *tmp_src <= 'Z') ||
 367             (*tmp_src >= '0' && *tmp_src <= '9') ||
 368             strchr(safe_chars, *tmp_src))
 369         {
 370             *tmp_dst++ = *tmp_src;
 371         }
 372         else
 373         {
 374             *tmp_dst++ = '%';
 375             *tmp_dst++ = hex_digits[*(unsigned char*)(tmp_src) / 16];
 376             *tmp_dst++ = hex_digits[*tmp_src & 0xf];
 377         }
 378         tmp_src++;
 379     }
 380
 381     *tmp_dst = 0;
 382
 383     return dst;
 384 }
 385
 386 static WCHAR *convert_file_uri(IUri *uri)
 387 {
 388     wine_get_unix_file_name_t wine_get_unix_file_name_ptr;
 389     struct stat dummy;
 390     WCHAR *new_path;
 391     char *unixpath;
 392     BSTR filename;
 393     HRESULT hres;
 394
 395     /* check if the argument is a local file */
 396     wine_get_unix_file_name_ptr = (wine_get_unix_file_name_t)
 397            GetProcAddress( GetModuleHandleA( "KERNEL32" ), "wine_get_unix_file_name" );
 398     if(!wine_get_unix_file_name_ptr)
 399         return NULL;
 400
 401     hres = IUri_GetPath(uri, &filename);
 402     if(FAILED(hres))
 403         return NULL;
 404
 405     WINE_TRACE("Windows path: %s\n", wine_dbgstr_w(filename));
 406
 407     unixpath = wine_get_unix_file_name_ptr(filename);
 408     SysFreeString(filename);
 409     if(unixpath && stat(unixpath, &dummy) >= 0) {
 410         WINE_TRACE("Unix path: %s\n", wine_dbgstr_a(unixpath));
 411         new_path = encode_unix_path(unixpath);
 412         HeapFree(GetProcessHeap(), 0, unixpath);
 413     }else {
 414         WINE_WARN("File %s does not exist\n", wine_dbgstr_a(unixpath));
 415         HeapFree(GetProcessHeap(), 0, unixpath);
 416         new_path = NULL;
 417     }
 418
 419     WINE_TRACE("New path: %s\n", wine_dbgstr_w(new_path));
 420
 421     return new_path;
 422 }
 423
 424 /*****************************************************************************
 425  * Main entry point. This is a console application so we have a wmain() not a
 426  * winmain().
 427  */
 428 int wmain(int argc, WCHAR *argv[])
 429 {
 430     static const WCHAR nohomeW[] = {'-','n','o','h','o','m','e',0};
 431
 432     WCHAR *url = argv[1];
 433     BSTR display_uri = NULL;
 434     DWORD scheme;
 435     IUri *uri;
 436     HRESULT hres;
 437     int ret = 1;
 438
 439     /* DDE used only if -nohome is specified; avoids delay in printing usage info
 440      * when no parameters are passed */
 441     if (url && !strcmpiW( url, nohomeW ))
 442         url = argc > 2 ? argv[2] : get_url_from_dde();
 443
 444     if (!url) {
 445         WINE_ERR( "Usage: winebrowser URL\n" );
 446         return -1;
 447     }
 448
 449     hres = CreateUri(url, Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|Uri_CREATE_FILE_USE_DOS_PATH, 0, &uri);
 450     if(FAILED(hres)) {
 451         WINE_ERR("Failed to parse URL\n");
 452         ret = open_http_url(url);
 453         HeapFree(GetProcessHeap(), 0, ddeString);
 454         return ret;
 455     }
 456
 457     HeapFree(GetProcessHeap(), 0, ddeString);
 458     IUri_GetScheme(uri, &scheme);
 459
 460     if(scheme == URL_SCHEME_FILE) {
 461         display_uri = convert_file_uri(uri);
 462         if(!display_uri) {
 463             WINE_ERR("Failed to convert file URL to unix path\n");
 464         }
 465     }
 466
 467     if (!display_uri)
 468         hres = IUri_GetDisplayUri(uri, &display_uri);
 469     IUri_Release(uri);
 470     if(FAILED(hres))
 471         return -1;
 472
 473     WINE_TRACE("opening %s\n", wine_dbgstr_w(display_uri));
 474
 475     if(scheme == URL_SCHEME_MAILTO)
 476         ret = open_mailto_url(display_uri);
 477     else
 478         /* let the browser decide how to handle the given url */
 479         ret = open_http_url(display_uri);
 480
 481     SysFreeString(display_uri);
 482     return ret;
 483 }