ie_importer.cc revision 731df977c0511bca2206b5f333555b1205ff1f43 
1// Copyright (c) 2010 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/importer/ie_importer.h"
6
7#include <ole2.h>
8#include <intshcut.h>
9#include <pstore.h>
10#include <shlobj.h>
11#include <urlhist.h>
12
13#include <algorithm>
14#include <map>
15#include <string>
16#include <vector>
17
18#include "app/l10n_util.h"
19#include "app/win_util.h"
20#include "base/file_path.h"
21#include "base/file_util.h"
22#include "base/scoped_comptr_win.h"
23#include "base/string_split.h"
24#include "base/string_util.h"
25#include "base/time.h"
26#include "base/values.h"
27#include "base/utf_string_conversions.h"
28#include "base/win/registry.h"
29#include "base/win/windows_version.h"
30#include "chrome/browser/bookmarks/bookmark_model.h"
31#include "chrome/browser/importer/importer_bridge.h"
32#include "chrome/browser/importer/importer_data_types.h"
33#include "chrome/browser/password_manager/ie7_password.h"
34#include "chrome/browser/search_engines/template_url.h"
35#include "chrome/browser/search_engines/template_url_model.h"
36#include "chrome/common/time_format.h"
37#include "chrome/common/url_constants.h"
38#include "googleurl/src/gurl.h"
39#include "grit/generated_resources.h"
40#include "webkit/glue/password_form.h"
41
42using base::Time;
43using base::win::RegKey;
44using base::win::RegistryValueIterator;
45using webkit_glue::PasswordForm;
46
47namespace {
48
49// Gets the creation time of the given file or directory.
50static Time GetFileCreationTime(const std::wstring& file) {
51  Time creation_time;
52  ScopedHandle file_handle(
53      CreateFile(file.c_str(), GENERIC_READ,
54                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
55                 NULL, OPEN_EXISTING,
56                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL));
57  FILETIME creation_filetime;
58  if (GetFileTime(file_handle, &creation_filetime, NULL, NULL))
59    creation_time = Time::FromFileTime(creation_filetime);
60  return creation_time;
61}
62
63}  // namespace
64
65// static
66// {E161255A-37C3-11D2-BCAA-00C04fD929DB}
67const GUID IEImporter::kPStoreAutocompleteGUID = {0xe161255a, 0x37c3, 0x11d2,
68    {0xbc, 0xaa, 0x00, 0xc0, 0x4f, 0xd9, 0x29, 0xdb}};
69// {A79029D6-753E-4e27-B807-3D46AB1545DF}
70const GUID IEImporter::kUnittestGUID = { 0xa79029d6, 0x753e, 0x4e27,
71    {0xb8, 0x7, 0x3d, 0x46, 0xab, 0x15, 0x45, 0xdf}};
72
73void IEImporter::StartImport(ProfileInfo profile_info,
74                             uint16 items,
75                             ImporterBridge* bridge) {
76  bridge_ = bridge;
77  source_path_ = profile_info.source_path.ToWStringHack();
78
79  bridge_->NotifyStarted();
80
81  // Some IE settings (such as Protected Storage) are obtained via COM APIs.
82  win_util::ScopedCOMInitializer com_initializer;
83
84  if ((items & importer::HOME_PAGE) && !cancelled())
85    ImportHomepage();  // Doesn't have a UI item.
86  // The order here is important!
87  if ((items & importer::HISTORY) && !cancelled()) {
88    bridge_->NotifyItemStarted(importer::HISTORY);
89    ImportHistory();
90    bridge_->NotifyItemEnded(importer::HISTORY);
91  }
92  if ((items & importer::FAVORITES) && !cancelled()) {
93    bridge_->NotifyItemStarted(importer::FAVORITES);
94    ImportFavorites();
95    bridge_->NotifyItemEnded(importer::FAVORITES);
96  }
97  if ((items & importer::SEARCH_ENGINES) && !cancelled()) {
98    bridge_->NotifyItemStarted(importer::SEARCH_ENGINES);
99    ImportSearchEngines();
100    bridge_->NotifyItemEnded(importer::SEARCH_ENGINES);
101  }
102  if ((items & importer::PASSWORDS) && !cancelled()) {
103    bridge_->NotifyItemStarted(importer::PASSWORDS);
104    // Always import IE6 passwords.
105    ImportPasswordsIE6();
106
107    if (CurrentIEVersion() >= 7)
108      ImportPasswordsIE7();
109    bridge_->NotifyItemEnded(importer::PASSWORDS);
110  }
111  bridge_->NotifyEnded();
112}
113
114void IEImporter::ImportFavorites() {
115  std::wstring path;
116
117  FavoritesInfo info;
118  if (!GetFavoritesInfo(&info))
119    return;
120
121  BookmarkVector bookmarks;
122  ParseFavoritesFolder(info, &bookmarks);
123
124  if (!bookmarks.empty() && !cancelled()) {
125    const std::wstring& first_folder_name =
126        l10n_util::GetString(IDS_BOOKMARK_GROUP_FROM_IE);
127    int options = 0;
128    if (import_to_bookmark_bar())
129      options = ProfileWriter::IMPORT_TO_BOOKMARK_BAR;
130    bridge_->AddBookmarkEntries(bookmarks, first_folder_name, options);
131  }
132}
133
134void IEImporter::ImportPasswordsIE6() {
135  GUID AutocompleteGUID = kPStoreAutocompleteGUID;
136  if (!source_path_.empty()) {
137    // We supply a fake GUID for testting.
138    AutocompleteGUID = kUnittestGUID;
139  }
140
141  // The PStoreCreateInstance function retrieves an interface pointer
142  // to a storage provider. But this function has no associated import
143  // library or header file, we must call it using the LoadLibrary()
144  // and GetProcAddress() functions.
145  typedef HRESULT (WINAPI *PStoreCreateFunc)(IPStore**, DWORD, DWORD, DWORD);
146  HMODULE pstorec_dll = LoadLibrary(L"pstorec.dll");
147  if (!pstorec_dll)
148    return;
149  PStoreCreateFunc PStoreCreateInstance =
150      (PStoreCreateFunc)GetProcAddress(pstorec_dll, "PStoreCreateInstance");
151  if (!PStoreCreateInstance) {
152    FreeLibrary(pstorec_dll);
153    return;
154  }
155
156  ScopedComPtr<IPStore, &IID_IPStore> pstore;
157  HRESULT result = PStoreCreateInstance(pstore.Receive(), 0, 0, 0);
158  if (result != S_OK) {
159    FreeLibrary(pstorec_dll);
160    return;
161  }
162
163  std::vector<AutoCompleteInfo> ac_list;
164
165  // Enumerates AutoComplete items in the protected database.
166  ScopedComPtr<IEnumPStoreItems, &IID_IEnumPStoreItems> item;
167  result = pstore->EnumItems(0, &AutocompleteGUID,
168                             &AutocompleteGUID, 0, item.Receive());
169  if (result != PST_E_OK) {
170    pstore.Release();
171    FreeLibrary(pstorec_dll);
172    return;
173  }
174
175  wchar_t* item_name;
176  while (!cancelled() && SUCCEEDED(item->Next(1, &item_name, 0))) {
177    DWORD length = 0;
178    unsigned char* buffer = NULL;
179    result = pstore->ReadItem(0, &AutocompleteGUID, &AutocompleteGUID,
180                              item_name, &length, &buffer, NULL, 0);
181    if (SUCCEEDED(result)) {
182      AutoCompleteInfo ac;
183      ac.key = item_name;
184      std::wstring data;
185      data.insert(0, reinterpret_cast<wchar_t*>(buffer),
186                  length / sizeof(wchar_t));
187
188      // The key name is always ended with ":StringData".
189      const wchar_t kDataSuffix[] = L":StringData";
190      size_t i = ac.key.rfind(kDataSuffix);
191      if (i != std::wstring::npos && ac.key.substr(i) == kDataSuffix) {
192        ac.key.erase(i);
193        ac.is_url = (ac.key.find(L"://") != std::wstring::npos);
194        ac_list.push_back(ac);
195        base::SplitString(data, L'\0', &ac_list[ac_list.size() - 1].data);
196      }
197      CoTaskMemFree(buffer);
198    }
199    CoTaskMemFree(item_name);
200  }
201  // Releases them before unload the dll.
202  item.Release();
203  pstore.Release();
204  FreeLibrary(pstorec_dll);
205
206  size_t i;
207  for (i = 0; i < ac_list.size(); i++) {
208    if (!ac_list[i].is_url || ac_list[i].data.size() < 2)
209      continue;
210
211    GURL url(ac_list[i].key.c_str());
212    if (!(LowerCaseEqualsASCII(url.scheme(), chrome::kHttpScheme) ||
213        LowerCaseEqualsASCII(url.scheme(), chrome::kHttpsScheme))) {
214      continue;
215    }
216
217    PasswordForm form;
218    GURL::Replacements rp;
219    rp.ClearUsername();
220    rp.ClearPassword();
221    rp.ClearQuery();
222    rp.ClearRef();
223    form.origin = url.ReplaceComponents(rp);
224    form.username_value = ac_list[i].data[0];
225    form.password_value = ac_list[i].data[1];
226    form.signon_realm = url.GetOrigin().spec();
227
228    // This is not precise, because a scheme of https does not imply a valid
229    // certificate was presented; however we assign it this way so that if we
230    // import a password from IE whose scheme is https, we give it the benefit
231    // of the doubt and DONT auto-fill it unless the form appears under
232    // valid SSL conditions.
233    form.ssl_valid = url.SchemeIsSecure();
234
235    // Goes through the list to find out the username field
236    // of the web page.
237    size_t list_it, item_it;
238    for (list_it = 0; list_it < ac_list.size(); ++list_it) {
239      if (ac_list[list_it].is_url)
240        continue;
241
242      for (item_it = 0; item_it < ac_list[list_it].data.size(); ++item_it)
243        if (ac_list[list_it].data[item_it] == form.username_value) {
244          form.username_element = ac_list[list_it].key;
245          break;
246        }
247    }
248
249    bridge_->SetPasswordForm(form);
250  }
251}
252
253void IEImporter::ImportPasswordsIE7() {
254  if (!source_path_.empty()) {
255    // We have been called from the unit tests. Don't import real passwords.
256    return;
257  }
258
259  const wchar_t kStorage2Path[] =
260      L"Software\\Microsoft\\Internet Explorer\\IntelliForms\\Storage2";
261
262  RegKey key(HKEY_CURRENT_USER, kStorage2Path, KEY_READ);
263  RegistryValueIterator reg_iterator(HKEY_CURRENT_USER, kStorage2Path);
264  while (reg_iterator.Valid() && !cancelled()) {
265    // Get the size of the encrypted data.
266    DWORD value_len = 0;
267    if (key.ReadValue(reg_iterator.Name(), NULL, &value_len, NULL) &&
268        value_len) {
269      // Query the encrypted data.
270      std::vector<unsigned char> value;
271      value.resize(value_len);
272      if (key.ReadValue(reg_iterator.Name(), &value.front(), &value_len,
273                        NULL)) {
274        IE7PasswordInfo password_info;
275        password_info.url_hash = reg_iterator.Name();
276        password_info.encrypted_data = value;
277        password_info.date_created = Time::Now();
278
279        bridge_->AddIE7PasswordInfo(password_info);
280      }
281    }
282
283    ++reg_iterator;
284  }
285}
286
287// Reads history information from COM interface.
288void IEImporter::ImportHistory() {
289  const std::string kSchemes[] = {chrome::kHttpScheme,
290                                  chrome::kHttpsScheme,
291                                  chrome::kFtpScheme,
292                                  chrome::kFileScheme};
293  int total_schemes = arraysize(kSchemes);
294
295  ScopedComPtr<IUrlHistoryStg2> url_history_stg2;
296  HRESULT result;
297  result = url_history_stg2.CreateInstance(CLSID_CUrlHistory, NULL,
298                                           CLSCTX_INPROC_SERVER);
299  if (FAILED(result))
300    return;
301  ScopedComPtr<IEnumSTATURL> enum_url;
302  if (SUCCEEDED(result = url_history_stg2->EnumUrls(enum_url.Receive()))) {
303    std::vector<history::URLRow> rows;
304    STATURL stat_url;
305    ULONG fetched;
306    while (!cancelled() &&
307           (result = enum_url->Next(1, &stat_url, &fetched)) == S_OK) {
308      std::wstring url_string;
309      std::wstring title_string;
310      if (stat_url.pwcsUrl) {
311        url_string = stat_url.pwcsUrl;
312        CoTaskMemFree(stat_url.pwcsUrl);
313      }
314      if (stat_url.pwcsTitle) {
315        title_string = stat_url.pwcsTitle;
316        CoTaskMemFree(stat_url.pwcsTitle);
317      }
318
319      GURL url(url_string);
320      // Skips the URLs that are invalid or have other schemes.
321      if (!url.is_valid() ||
322          (std::find(kSchemes, kSchemes + total_schemes, url.scheme()) ==
323           kSchemes + total_schemes))
324        continue;
325
326      history::URLRow row(url);
327      row.set_title(title_string);
328      row.set_last_visit(Time::FromFileTime(stat_url.ftLastVisited));
329      if (stat_url.dwFlags == STATURL_QUERYFLAG_TOPLEVEL) {
330        row.set_visit_count(1);
331        row.set_hidden(false);
332      } else {
333        row.set_hidden(true);
334      }
335
336      rows.push_back(row);
337    }
338
339    if (!rows.empty() && !cancelled()) {
340      bridge_->SetHistoryItems(rows, history::SOURCE_IE_IMPORTED);
341    }
342  }
343}
344
345void IEImporter::ImportSearchEngines() {
346  // On IE, search engines are stored in the registry, under:
347  // Software\Microsoft\Internet Explorer\SearchScopes
348  // Each key represents a search engine. The URL value contains the URL and
349  // the DisplayName the name.
350  // The default key's name is contained under DefaultScope.
351  const wchar_t kSearchScopePath[] =
352      L"Software\\Microsoft\\Internet Explorer\\SearchScopes";
353
354  RegKey key(HKEY_CURRENT_USER, kSearchScopePath, KEY_READ);
355  std::wstring default_search_engine_name;
356  const TemplateURL* default_search_engine = NULL;
357  std::map<std::string, TemplateURL*> search_engines_map;
358  key.ReadValue(L"DefaultScope", &default_search_engine_name);
359  base::win::RegistryKeyIterator key_iterator(HKEY_CURRENT_USER,
360                                              kSearchScopePath);
361  while (key_iterator.Valid()) {
362    std::wstring sub_key_name = kSearchScopePath;
363    sub_key_name.append(L"\\").append(key_iterator.Name());
364    RegKey sub_key(HKEY_CURRENT_USER, sub_key_name.c_str(), KEY_READ);
365    std::wstring wide_url;
366    if (!sub_key.ReadValue(L"URL", &wide_url) || wide_url.empty()) {
367      VLOG(1) << "No URL for IE search engine at " << key_iterator.Name();
368      ++key_iterator;
369      continue;
370    }
371    // For the name, we try the default value first (as Live Search uses a
372    // non displayable name in DisplayName, and the readable name under the
373    // default value).
374    std::wstring name;
375    if (!sub_key.ReadValue(NULL, &name) || name.empty()) {
376      // Try the displayable name.
377      if (!sub_key.ReadValue(L"DisplayName", &name) || name.empty()) {
378        VLOG(1) << "No name for IE search engine at " << key_iterator.Name();
379        ++key_iterator;
380        continue;
381      }
382    }
383
384    std::string url(WideToUTF8(wide_url));
385    std::map<std::string, TemplateURL*>::iterator t_iter =
386        search_engines_map.find(url);
387    TemplateURL* template_url =
388        (t_iter != search_engines_map.end()) ? t_iter->second : NULL;
389    if (!template_url) {
390      // First time we see that URL.
391      template_url = new TemplateURL();
392      template_url->set_short_name(name);
393      template_url->SetURL(url, 0, 0);
394      // Give this a keyword to facilitate tab-to-search, if possible.
395      template_url->set_keyword(TemplateURLModel::GenerateKeyword(GURL(url),
396                                                                  false));
397      template_url->set_show_in_default_list(true);
398      search_engines_map[url] = template_url;
399    }
400    if (template_url && key_iterator.Name() == default_search_engine_name) {
401      DCHECK(!default_search_engine);
402      default_search_engine = template_url;
403    }
404    ++key_iterator;
405  }
406
407  // ProfileWriter::AddKeywords() requires a vector and we have a map.
408  std::map<std::string, TemplateURL*>::iterator t_iter;
409  std::vector<TemplateURL*> search_engines;
410  int default_search_engine_index = -1;
411  for (t_iter = search_engines_map.begin(); t_iter != search_engines_map.end();
412       ++t_iter) {
413    search_engines.push_back(t_iter->second);
414    if (default_search_engine == t_iter->second) {
415      default_search_engine_index =
416          static_cast<int>(search_engines.size()) - 1;
417    }
418  }
419  bridge_->SetKeywords(search_engines, default_search_engine_index, true);
420}
421
422void IEImporter::ImportHomepage() {
423  const wchar_t kIESettingsMain[] =
424      L"Software\\Microsoft\\Internet Explorer\\Main";
425  const wchar_t kIEHomepage[] = L"Start Page";
426  const wchar_t kIEDefaultHomepage[] = L"Default_Page_URL";
427
428  RegKey key(HKEY_CURRENT_USER, kIESettingsMain, KEY_READ);
429  std::wstring homepage_url;
430  if (!key.ReadValue(kIEHomepage, &homepage_url) || homepage_url.empty())
431    return;
432
433  GURL homepage = GURL(homepage_url);
434  if (!homepage.is_valid())
435    return;
436
437  // Check to see if this is the default website and skip import.
438  RegKey keyDefault(HKEY_LOCAL_MACHINE, kIESettingsMain, KEY_READ);
439  std::wstring default_homepage_url;
440  if (keyDefault.ReadValue(kIEDefaultHomepage, &default_homepage_url) &&
441      !default_homepage_url.empty()) {
442    if (homepage.spec() == GURL(default_homepage_url).spec())
443      return;
444  }
445
446  bridge_->AddHomePage(homepage);
447}
448
449bool IEImporter::GetFavoritesInfo(IEImporter::FavoritesInfo *info) {
450  if (!source_path_.empty()) {
451    // Source path exists during testing.
452    info->path = source_path_;
453    file_util::AppendToPath(&info->path, L"Favorites");
454    info->links_folder = L"Links";
455    return true;
456  }
457
458  // IE stores the favorites in the Favorites under user profile's folder.
459  wchar_t buffer[MAX_PATH];
460  if (FAILED(SHGetFolderPath(NULL, CSIDL_FAVORITES, NULL,
461                             SHGFP_TYPE_CURRENT, buffer)))
462    return false;
463  info->path = buffer;
464
465  // There is a Links folder under Favorites folder in Windows Vista, but it
466  // is not recording in Vista's registry. So in Vista, we assume the Links
467  // folder is under Favorites folder since it looks like there is not name
468  // different in every language version of Windows Vista.
469  if (base::win::GetVersion() < base::win::VERSION_VISTA) {
470    // The Link folder name is stored in the registry.
471    DWORD buffer_length = sizeof(buffer);
472    RegKey reg_key(HKEY_CURRENT_USER,
473                   L"Software\\Microsoft\\Internet Explorer\\Toolbar",
474                   KEY_READ);
475    if (!reg_key.ReadValue(L"LinksFolderName", buffer, &buffer_length, NULL))
476      return false;
477    info->links_folder = buffer;
478  } else {
479    info->links_folder = L"Links";
480  }
481
482  return true;
483}
484
485void IEImporter::ParseFavoritesFolder(const FavoritesInfo& info,
486                                      BookmarkVector* bookmarks) {
487  std::wstring ie_folder = l10n_util::GetString(IDS_BOOKMARK_GROUP_FROM_IE);
488  BookmarkVector toolbar_bookmarks;
489  FilePath file;
490  std::vector<FilePath::StringType> file_list;
491  FilePath favorites_path(info.path);
492  // Favorites path length.  Make sure it doesn't include the trailing \.
493  size_t favorites_path_len =
494      favorites_path.StripTrailingSeparators().value().size();
495  file_util::FileEnumerator file_enumerator(
496      favorites_path, true, file_util::FileEnumerator::FILES);
497  while (!(file = file_enumerator.Next()).value().empty() && !cancelled())
498    file_list.push_back(file.value());
499
500  // Keep the bookmarks in alphabetical order.
501  std::sort(file_list.begin(), file_list.end());
502
503  for (std::vector<FilePath::StringType>::iterator it = file_list.begin();
504       it != file_list.end(); ++it) {
505    FilePath shortcut(*it);
506    if (!LowerCaseEqualsASCII(shortcut.Extension(), ".url"))
507      continue;
508
509    // Skip the bookmark with invalid URL.
510    GURL url = GURL(ResolveInternetShortcut(*it));
511    if (!url.is_valid())
512      continue;
513
514    // Make the relative path from the Favorites folder, without the basename.
515    // ex. Suppose that the Favorites folder is C:\Users\Foo\Favorites.
516    //   C:\Users\Foo\Favorites\Foo.url -> ""
517    //   C:\Users\Foo\Favorites\Links\Bar\Baz.url -> "Links\Bar"
518    FilePath::StringType relative_string =
519        shortcut.DirName().value().substr(favorites_path_len);
520    if (relative_string.size() > 0 && FilePath::IsSeparator(relative_string[0]))
521      relative_string = relative_string.substr(1);
522    FilePath relative_path(relative_string);
523
524    ProfileWriter::BookmarkEntry entry;
525    // Remove the dot, the file extension, and the directory path.
526    entry.title = shortcut.RemoveExtension().BaseName().value();
527    entry.url = url;
528    entry.creation_time = GetFileCreationTime(*it);
529    if (!relative_path.empty())
530      relative_path.GetComponents(&entry.path);
531
532    // Flatten the bookmarks in Link folder onto bookmark toolbar. Otherwise,
533    // put it into "Other bookmarks".
534    if (import_to_bookmark_bar() &&
535        (entry.path.size() > 0 && entry.path[0] == info.links_folder)) {
536      entry.in_toolbar = true;
537      entry.path.erase(entry.path.begin());
538      toolbar_bookmarks.push_back(entry);
539    } else {
540      // We put the bookmarks in a "Imported From IE"
541      // folder, so that we don't mess up the "Other bookmarks".
542      if (!import_to_bookmark_bar())
543        entry.path.insert(entry.path.begin(), ie_folder);
544      bookmarks->push_back(entry);
545    }
546  }
547  bookmarks->insert(bookmarks->begin(), toolbar_bookmarks.begin(),
548                    toolbar_bookmarks.end());
549}
550
551std::wstring IEImporter::ResolveInternetShortcut(const std::wstring& file) {
552  win_util::CoMemReleaser<wchar_t> url;
553  ScopedComPtr<IUniformResourceLocator> url_locator;
554  HRESULT result = url_locator.CreateInstance(CLSID_InternetShortcut, NULL,
555                                              CLSCTX_INPROC_SERVER);
556  if (FAILED(result))
557    return std::wstring();
558
559  ScopedComPtr<IPersistFile> persist_file;
560  result = persist_file.QueryFrom(url_locator);
561  if (FAILED(result))
562    return std::wstring();
563
564  // Loads the Internet Shortcut from persistent storage.
565  result = persist_file->Load(file.c_str(), STGM_READ);
566  if (FAILED(result))
567    return std::wstring();
568
569  result = url_locator->GetURL(&url);
570  // GetURL can return S_FALSE (FAILED(S_FALSE) is false) when url == NULL.
571  if (FAILED(result) || (url == NULL))
572    return std::wstring();
573
574  return std::wstring(url);
575}
576
577int IEImporter::CurrentIEVersion() const {
578  static int version = -1;
579  if (version < 0) {
580    wchar_t buffer[128];
581    DWORD buffer_length = sizeof(buffer);
582    RegKey reg_key(HKEY_LOCAL_MACHINE,
583                   L"Software\\Microsoft\\Internet Explorer", KEY_READ);
584    bool result = reg_key.ReadValue(L"Version", buffer, &buffer_length, NULL);
585    version = (result ? _wtoi(buffer) : 0);
586  }
587  return version;
588}
589