windows/winjump.c

   1 /*
   2  * winjump.c: support for Windows 7 jump lists.
   3  *
   4  * The Windows 7 jumplist is a customizable list defined by the
   5  * application. It is persistent across application restarts: the OS
   6  * maintains the list when the app is not running. The list is shown
   7  * when the user right-clicks on the taskbar button of a running app
   8  * or a pinned non-running application. We use the jumplist to
   9  * maintain a list of recently started saved sessions, started either
  10  * by doubleclicking on a saved session, or with the command line
  11  * "-load" parameter.
  12  *
  13  * Since the jumplist is write-only: it can only be replaced and the
  14  * current list cannot be read, we must maintain the contents of the
  15  * list persistantly in the registry. The file winstore.h contains
  16  * functions to directly manipulate these registry entries. This file
  17  * contains higher level functions to manipulate the jumplist.
  18  */
  19
  20 #include <assert.h>
  21
  22 #include "putty.h"
  23 #include "storage.h"
  24
  25 #define MAX_JUMPLIST_ITEMS 30 /* PuTTY will never show more items in
  26                                * the jumplist than this, regardless of
  27                                * user preferences. */
  28
  29 /*
  30  * COM structures and functions.
  31  */
  32 #ifndef PROPERTYKEY_DEFINED
  33 #define PROPERTYKEY_DEFINED
  34 typedef struct _tagpropertykey {
  35     GUID fmtid;
  36     DWORD pid;
  37 } PROPERTYKEY;
  38 #endif
  39 #ifndef _REFPROPVARIANT_DEFINED
  40 #define _REFPROPVARIANT_DEFINED
  41 typedef PROPVARIANT *REFPROPVARIANT;
  42 #endif
  43 /* MinGW doesn't define this yet: */
  44 #ifndef _PROPVARIANTINIT_DEFINED_
  45 #define _PROPVARIANTINIT_DEFINED_
  46 #define PropVariantInit(pvar) memset((pvar),0,sizeof(PROPVARIANT))
  47 #endif
  48
  49 #define IID_IShellLink IID_IShellLinkA
  50
  51 typedef struct ICustomDestinationListVtbl {
  52     HRESULT ( __stdcall *QueryInterface ) (
  53         /* [in] ICustomDestinationList*/ void *This,
  54         /* [in] */  const GUID * const riid,
  55         /* [out] */ void **ppvObject);
  56
  57     ULONG ( __stdcall *AddRef )(
  58         /* [in] ICustomDestinationList*/ void *This);
  59
  60     ULONG ( __stdcall *Release )(
  61         /* [in] ICustomDestinationList*/ void *This);
  62
  63     HRESULT ( __stdcall *SetAppID )(
  64         /* [in] ICustomDestinationList*/ void *This,
  65         /* [string][in] */ LPCWSTR pszAppID);
  66
  67     HRESULT ( __stdcall *BeginList )(
  68         /* [in] ICustomDestinationList*/ void *This,
  69         /* [out] */ UINT *pcMinSlots,
  70         /* [in] */  const GUID * const riid,
  71         /* [out] */ void **ppv);
  72
  73     HRESULT ( __stdcall *AppendCategory )(
  74         /* [in] ICustomDestinationList*/ void *This,
  75         /* [string][in] */ LPCWSTR pszCategory,
  76         /* [in] IObjectArray*/ void *poa);
  77
  78     HRESULT ( __stdcall *AppendKnownCategory )(
  79         /* [in] ICustomDestinationList*/ void *This,
  80         /* [in] KNOWNDESTCATEGORY*/ int category);
  81
  82     HRESULT ( __stdcall *AddUserTasks )(
  83         /* [in] ICustomDestinationList*/ void *This,
  84         /* [in] IObjectArray*/ void *poa);
  85
  86     HRESULT ( __stdcall *CommitList )(
  87         /* [in] ICustomDestinationList*/ void *This);
  88
  89     HRESULT ( __stdcall *GetRemovedDestinations )(
  90         /* [in] ICustomDestinationList*/ void *This,
  91         /* [in] */ const IID * const riid,
  92         /* [out] */ void **ppv);
  93
  94     HRESULT ( __stdcall *DeleteList )(
  95         /* [in] ICustomDestinationList*/ void *This,
  96         /* [string][unique][in] */ LPCWSTR pszAppID);
  97
  98     HRESULT ( __stdcall *AbortList )(
  99         /* [in] ICustomDestinationList*/ void *This);
 100
 101 } ICustomDestinationListVtbl;
 102
 103 typedef struct ICustomDestinationList
 104 {
 105     ICustomDestinationListVtbl *lpVtbl;
 106 } ICustomDestinationList;
 107
 108 typedef struct IObjectArrayVtbl
 109 {
 110     HRESULT ( __stdcall *QueryInterface )(
 111         /* [in] IObjectArray*/ void *This,
 112         /* [in] */ const GUID * const riid,
 113         /* [out] */ void **ppvObject);
 114
 115     ULONG ( __stdcall *AddRef )(
 116         /* [in] IObjectArray*/ void *This);
 117
 118     ULONG ( __stdcall *Release )(
 119         /* [in] IObjectArray*/ void *This);
 120
 121     HRESULT ( __stdcall *GetCount )(
 122         /* [in] IObjectArray*/ void *This,
 123         /* [out] */ UINT *pcObjects);
 124
 125     HRESULT ( __stdcall *GetAt )(
 126         /* [in] IObjectArray*/ void *This,
 127         /* [in] */ UINT uiIndex,
 128         /* [in] */ const GUID * const riid,
 129         /* [out] */ void **ppv);
 130
 131 } IObjectArrayVtbl;
 132
 133 typedef struct IObjectArray
 134 {
 135     IObjectArrayVtbl *lpVtbl;
 136 } IObjectArray;
 137
 138 typedef struct IShellLinkVtbl
 139 {
 140     HRESULT ( __stdcall *QueryInterface )(
 141         /* [in] IShellLink*/ void *This,
 142         /* [in] */ const GUID * const riid,
 143         /* [out] */ void **ppvObject);
 144
 145     ULONG ( __stdcall *AddRef )(
 146         /* [in] IShellLink*/ void *This);
 147
 148     ULONG ( __stdcall *Release )(
 149         /* [in] IShellLink*/ void *This);
 150
 151     HRESULT ( __stdcall *GetPath )(
 152         /* [in] IShellLink*/ void *This,
 153         /* [string][out] */ LPSTR pszFile,
 154         /* [in] */ int cch,
 155         /* [unique][out][in] */ WIN32_FIND_DATAA *pfd,
 156         /* [in] */ DWORD fFlags);
 157
 158     HRESULT ( __stdcall *GetIDList )(
 159         /* [in] IShellLink*/ void *This,
 160         /* [out] LPITEMIDLIST*/ void **ppidl);
 161
 162     HRESULT ( __stdcall *SetIDList )(
 163         /* [in] IShellLink*/ void *This,
 164         /* [in] LPITEMIDLIST*/ void *pidl);
 165
 166     HRESULT ( __stdcall *GetDescription )(
 167         /* [in] IShellLink*/ void *This,
 168         /* [string][out] */ LPSTR pszName,
 169         /* [in] */ int cch);
 170
 171     HRESULT ( __stdcall *SetDescription )(
 172         /* [in] IShellLink*/ void *This,
 173         /* [string][in] */ LPCSTR pszName);
 174
 175     HRESULT ( __stdcall *GetWorkingDirectory )(
 176         /* [in] IShellLink*/ void *This,
 177         /* [string][out] */ LPSTR pszDir,
 178         /* [in] */ int cch);
 179
 180     HRESULT ( __stdcall *SetWorkingDirectory )(
 181         /* [in] IShellLink*/ void *This,
 182         /* [string][in] */ LPCSTR pszDir);
 183
 184     HRESULT ( __stdcall *GetArguments )(
 185         /* [in] IShellLink*/ void *This,
 186         /* [string][out] */ LPSTR pszArgs,
 187         /* [in] */ int cch);
 188
 189     HRESULT ( __stdcall *SetArguments )(
 190         /* [in] IShellLink*/ void *This,
 191         /* [string][in] */ LPCSTR pszArgs);
 192
 193     HRESULT ( __stdcall *GetHotkey )(
 194         /* [in] IShellLink*/ void *This,
 195         /* [out] */ WORD *pwHotkey);
 196
 197     HRESULT ( __stdcall *SetHotkey )(
 198         /* [in] IShellLink*/ void *This,
 199         /* [in] */ WORD wHotkey);
 200
 201     HRESULT ( __stdcall *GetShowCmd )(
 202         /* [in] IShellLink*/ void *This,
 203         /* [out] */ int *piShowCmd);
 204
 205     HRESULT ( __stdcall *SetShowCmd )(
 206         /* [in] IShellLink*/ void *This,
 207         /* [in] */ int iShowCmd);
 208
 209     HRESULT ( __stdcall *GetIconLocation )(
 210         /* [in] IShellLink*/ void *This,
 211         /* [string][out] */ LPSTR pszIconPath,
 212         /* [in] */ int cch,
 213         /* [out] */ int *piIcon);
 214
 215     HRESULT ( __stdcall *SetIconLocation )(
 216         /* [in] IShellLink*/ void *This,
 217         /* [string][in] */ LPCSTR pszIconPath,
 218         /* [in] */ int iIcon);
 219
 220     HRESULT ( __stdcall *SetRelativePath )(
 221         /* [in] IShellLink*/ void *This,
 222         /* [string][in] */ LPCSTR pszPathRel,
 223         /* [in] */ DWORD dwReserved);
 224
 225     HRESULT ( __stdcall *Resolve )(
 226         /* [in] IShellLink*/ void *This,
 227         /* [unique][in] */ HWND hwnd,
 228         /* [in] */ DWORD fFlags);
 229
 230     HRESULT ( __stdcall *SetPath )(
 231         /* [in] IShellLink*/ void *This,
 232         /* [string][in] */ LPCSTR pszFile);
 233
 234 } IShellLinkVtbl;
 235
 236 typedef struct IShellLink
 237 {
 238     IShellLinkVtbl *lpVtbl;
 239 } IShellLink;
 240
 241 typedef struct IObjectCollectionVtbl
 242 {
 243     HRESULT ( __stdcall *QueryInterface )(
 244         /* [in] IShellLink*/ void *This,
 245         /* [in] */ const GUID * const riid,
 246         /* [out] */ void **ppvObject);
 247
 248     ULONG ( __stdcall *AddRef )(
 249         /* [in] IShellLink*/ void *This);
 250
 251     ULONG ( __stdcall *Release )(
 252         /* [in] IShellLink*/ void *This);
 253
 254     HRESULT ( __stdcall *GetCount )(
 255         /* [in] IShellLink*/ void *This,
 256         /* [out] */ UINT *pcObjects);
 257
 258     HRESULT ( __stdcall *GetAt )(
 259         /* [in] IShellLink*/ void *This,
 260         /* [in] */ UINT uiIndex,
 261         /* [in] */ const GUID * const riid,
 262         /* [iid_is][out] */ void **ppv);
 263
 264     HRESULT ( __stdcall *AddObject )(
 265         /* [in] IShellLink*/ void *This,
 266         /* [in] */ void *punk);
 267
 268     HRESULT ( __stdcall *AddFromArray )(
 269         /* [in] IShellLink*/ void *This,
 270         /* [in] */ IObjectArray *poaSource);
 271
 272     HRESULT ( __stdcall *RemoveObjectAt )(
 273         /* [in] IShellLink*/ void *This,
 274         /* [in] */ UINT uiIndex);
 275
 276     HRESULT ( __stdcall *Clear )(
 277         /* [in] IShellLink*/ void *This);
 278
 279 } IObjectCollectionVtbl;
 280
 281 typedef struct IObjectCollection
 282 {
 283     IObjectCollectionVtbl *lpVtbl;
 284 } IObjectCollection;
 285
 286 typedef struct IPropertyStoreVtbl
 287 {
 288     HRESULT ( __stdcall *QueryInterface )(
 289         /* [in] IPropertyStore*/ void *This,
 290         /* [in] */ const GUID * const riid,
 291         /* [iid_is][out] */ void **ppvObject);
 292
 293     ULONG ( __stdcall *AddRef )(
 294         /* [in] IPropertyStore*/ void *This);
 295
 296     ULONG ( __stdcall *Release )(
 297         /* [in] IPropertyStore*/ void *This);
 298
 299     HRESULT ( __stdcall *GetCount )(
 300         /* [in] IPropertyStore*/ void *This,
 301         /* [out] */ DWORD *cProps);
 302
 303     HRESULT ( __stdcall *GetAt )(
 304         /* [in] IPropertyStore*/ void *This,
 305         /* [in] */ DWORD iProp,
 306         /* [out] */ PROPERTYKEY *pkey);
 307
 308     HRESULT ( __stdcall *GetValue )(
 309         /* [in] IPropertyStore*/ void *This,
 310         /* [in] */ const PROPERTYKEY * const key,
 311         /* [out] */ PROPVARIANT *pv);
 312
 313     HRESULT ( __stdcall *SetValue )(
 314         /* [in] IPropertyStore*/ void *This,
 315         /* [in] */ const PROPERTYKEY * const key,
 316         /* [in] */ REFPROPVARIANT propvar);
 317
 318     HRESULT ( __stdcall *Commit )(
 319         /* [in] IPropertyStore*/ void *This);
 320 } IPropertyStoreVtbl;
 321
 322 typedef struct IPropertyStore
 323 {
 324     IPropertyStoreVtbl *lpVtbl;
 325 } IPropertyStore;
 326
 327 static const CLSID CLSID_DestinationList = {
 328     0x77f10cf0, 0x3db5, 0x4966, {0xb5,0x20,0xb7,0xc5,0x4f,0xd3,0x5e,0xd6}
 329 };
 330 static const CLSID CLSID_ShellLink = {
 331     0x00021401, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}
 332 };
 333 static const CLSID CLSID_EnumerableObjectCollection = {
 334     0x2d3468c1, 0x36a7, 0x43b6, {0xac,0x24,0xd3,0xf0,0x2f,0xd9,0x60,0x7a}
 335 };
 336 static const IID IID_IObjectCollection = {
 337     0x5632b1a4, 0xe38a, 0x400a, {0x92,0x8a,0xd4,0xcd,0x63,0x23,0x02,0x95}
 338 };
 339 static const IID IID_IShellLink = {
 340     0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}
 341 };
 342 static const IID IID_ICustomDestinationList = {
 343     0x6332debf, 0x87b5, 0x4670, {0x90,0xc0,0x5e,0x57,0xb4,0x08,0xa4,0x9e}
 344 };
 345 static const IID IID_IObjectArray = {
 346     0x92ca9dcd, 0x5622, 0x4bba, {0xa8,0x05,0x5e,0x9f,0x54,0x1b,0xd8,0xc9}
 347 };
 348 static const IID IID_IPropertyStore = {
 349     0x886d8eeb, 0x8cf2, 0x4446, {0x8d,0x02,0xcd,0xba,0x1d,0xbd,0xcf,0x99}
 350 };
 351 static const PROPERTYKEY PKEY_Title = {
 352     {0xf29f85e0, 0x4ff9, 0x1068, {0xab,0x91,0x08,0x00,0x2b,0x27,0xb3,0xd9}},
 353     0x00000002
 354 };
 355
 356 /* Type-checking macro to provide arguments for CoCreateInstance()
 357  * etc, ensuring that 'obj' really is a 'type **'. */
 358 #define typecheck(checkexpr, result) \
 359     (sizeof(checkexpr) ? (result) : (result))
 360 #define COMPTR(type, obj) &IID_##type, \
 361     typecheck((obj)-(type **)(obj), (void **)(void *)(obj))
 362
 363 static char putty_path[2048];
 364
 365 /*
 366  * Function to make an IShellLink describing a particular PuTTY
 367  * command. If 'appname' is null, the command run will be the one
 368  * returned by GetModuleFileName, i.e. our own executable; if it's
 369  * non-null then it will be assumed to be a filename in the same
 370  * directory as our own executable, and the return value will be NULL
 371  * if that file doesn't exist.
 372  *
 373  * If 'sessionname' is null then no command line will be passed to the
 374  * program. If it's non-null, the command line will be that text
 375  * prefixed with an @ (to load a PuTTY saved session).
 376  *
 377  * Hence, you can launch a saved session using make_shell_link(NULL,
 378  * sessionname), and launch another app using e.g.
 379  * make_shell_link("puttygen.exe", NULL).
 380  */
 381 static IShellLink *make_shell_link(const char *appname,
 382                                    const char *sessionname)
 383 {
 384     IShellLink *ret;
 385     char *app_path, *param_string, *desc_string;
 386     void *psettings_tmp;
 387     IPropertyStore *pPS;
 388     PROPVARIANT pv;
 389
 390     /* Retrieve path to executable. */
 391     if (!putty_path[0])
 392         GetModuleFileName(NULL, putty_path, sizeof(putty_path) - 1);
 393     if (appname) {
 394         char *p, *q = putty_path;
 395         FILE *fp;
 396
 397         if ((p = strrchr(q, '\\')) != NULL) q = p+1;
 398         if ((p = strrchr(q, ':')) != NULL) q = p+1;
 399         app_path = dupprintf("%.*s%s", (int)(q - putty_path), putty_path,
 400                              appname);
 401         if ((fp = fopen(app_path, "r")) == NULL) {
 402             sfree(app_path);
 403             return NULL;
 404         }
 405         fclose(fp);
 406     } else {
 407         app_path = dupstr(putty_path);
 408     }
 409
 410     /* Check if this is a valid session, otherwise don't add. */
 411     if (sessionname) {
 412         psettings_tmp = open_settings_r(sessionname);
 413         if (!psettings_tmp) {
 414             sfree(app_path);
 415             return NULL;
 416         }
 417         close_settings_r(psettings_tmp);
 418     }
 419
 420     /* Create the new item. */
 421     if (!SUCCEEDED(CoCreateInstance(&CLSID_ShellLink, NULL,
 422                                     CLSCTX_INPROC_SERVER,
 423                                     COMPTR(IShellLink, &ret)))) {
 424         sfree(app_path);
 425         return NULL;
 426     }
 427
 428     /* Set path, parameters, icon and description. */
 429     ret->lpVtbl->SetPath(ret, app_path);
 430
 431     if (sessionname) {
 432         /* The leading space is reported to work around a Windows 10
 433          * behaviour change in which an argument string starting with
 434          * '@' causes the SetArguments method to silently do the wrong
 435          * thing. */
 436         param_string = dupcat(" @", sessionname, NULL);
 437     } else {
 438         param_string = dupstr("");
 439     }
 440     ret->lpVtbl->SetArguments(ret, param_string);
 441     sfree(param_string);
 442
 443     if (sessionname) {
 444         desc_string = dupcat("Connect to PuTTY session '",
 445                              sessionname, "'", NULL);
 446     } else {
 447         assert(appname);
 448         desc_string = dupprintf("Run %.*s", strcspn(appname, "."), appname);
 449     }
 450     ret->lpVtbl->SetDescription(ret, desc_string);
 451     sfree(desc_string);
 452
 453     ret->lpVtbl->SetIconLocation(ret, app_path, 0);
 454
 455     /* To set the link title, we require the property store of the link. */
 456     if (SUCCEEDED(ret->lpVtbl->QueryInterface(ret,
 457                                               COMPTR(IPropertyStore, &pPS)))) {
 458         PropVariantInit(&pv);
 459         pv.vt = VT_LPSTR;
 460         if (sessionname) {
 461             pv.pszVal = dupstr(sessionname);
 462         } else {
 463             assert(appname);
 464             pv.pszVal = dupprintf("Run %.*s", strcspn(appname, "."), appname);
 465         }
 466         pPS->lpVtbl->SetValue(pPS, &PKEY_Title, &pv);
 467         sfree(pv.pszVal);
 468         pPS->lpVtbl->Commit(pPS);
 469         pPS->lpVtbl->Release(pPS);
 470     }
 471
 472     sfree(app_path);
 473
 474     return ret;
 475 }
 476
 477 /* Updates jumplist from registry. */
 478 static void update_jumplist_from_registry(void)
 479 {
 480     const char *piterator;
 481     UINT num_items;
 482     int jumplist_counter;
 483     UINT nremoved;
 484
 485     /* Variables used by the cleanup code must be initialised to NULL,
 486      * so that we don't try to free or release them if they were never
 487      * set up. */
 488     ICustomDestinationList *pCDL = NULL;
 489     char *pjumplist_reg_entries = NULL;
 490     IObjectCollection *collection = NULL;
 491     IObjectArray *array = NULL;
 492     IShellLink *link = NULL;
 493     IObjectArray *pRemoved = NULL;
 494     int need_abort = FALSE;
 495
 496     /*
 497      * Create an ICustomDestinationList: the top-level object which
 498      * deals with jump list management.
 499      */
 500     if (!SUCCEEDED(CoCreateInstance(&CLSID_DestinationList, NULL,
 501                                     CLSCTX_INPROC_SERVER,
 502                                     COMPTR(ICustomDestinationList, &pCDL))))
 503         goto cleanup;
 504
 505     /*
 506      * Call its BeginList method to start compiling a list. This gives
 507      * us back 'num_items' (a hint derived from systemwide
 508      * configuration about how many things to put on the list) and
 509      * 'pRemoved' (user configuration about things to leave off the
 510      * list).
 511      */
 512     if (!SUCCEEDED(pCDL->lpVtbl->BeginList(pCDL, &num_items,
 513                                            COMPTR(IObjectArray, &pRemoved))))
 514         goto cleanup;
 515     need_abort = TRUE;
 516     if (!SUCCEEDED(pRemoved->lpVtbl->GetCount(pRemoved, &nremoved)))
 517         nremoved = 0;
 518
 519     /*
 520      * Create an object collection to form the 'Recent Sessions'
 521      * category on the jump list.
 522      */
 523     if (!SUCCEEDED(CoCreateInstance(&CLSID_EnumerableObjectCollection,
 524                                     NULL, CLSCTX_INPROC_SERVER,
 525                                     COMPTR(IObjectCollection, &collection))))
 526         goto cleanup;
 527
 528     /*
 529      * Go through the jump list entries from the registry and add each
 530      * one to the collection.
 531      */
 532     pjumplist_reg_entries = get_jumplist_registry_entries();
 533     piterator = pjumplist_reg_entries;
 534     jumplist_counter = 0;
 535     while (*piterator != '\0' &&
 536            (jumplist_counter < min(MAX_JUMPLIST_ITEMS, (int) num_items))) {
 537         link = make_shell_link(NULL, piterator);
 538         if (link) {
 539             UINT i;
 540             int found;
 541
 542             /*
 543              * Check that the link isn't in the user-removed list.
 544              */
 545             for (i = 0, found = FALSE; i < nremoved && !found; i++) {
 546                 IShellLink *rlink;
 547                 if (SUCCEEDED(pRemoved->lpVtbl->GetAt
 548                               (pRemoved, i, COMPTR(IShellLink, &rlink)))) {
 549                     char desc1[2048], desc2[2048];
 550                     if (SUCCEEDED(link->lpVtbl->GetDescription
 551                                   (link, desc1, sizeof(desc1)-1)) &&
 552                         SUCCEEDED(rlink->lpVtbl->GetDescription
 553                                   (rlink, desc2, sizeof(desc2)-1)) &&
 554                         !strcmp(desc1, desc2)) {
 555                         found = TRUE;
 556                     }
 557                     rlink->lpVtbl->Release(rlink);
 558                 }
 559             }
 560
 561             if (!found) {
 562                 collection->lpVtbl->AddObject(collection, link);
 563                 jumplist_counter++;
 564             }
 565
 566             link->lpVtbl->Release(link);
 567             link = NULL;
 568         }
 569         piterator += strlen(piterator) + 1;
 570     }
 571     sfree(pjumplist_reg_entries);
 572     pjumplist_reg_entries = NULL;
 573
 574     /*
 575      * Get the array form of the collection we've just constructed,
 576      * and put it in the jump list.
 577      */
 578     if (!SUCCEEDED(collection->lpVtbl->QueryInterface
 579                    (collection, COMPTR(IObjectArray, &array))))
 580         goto cleanup;
 581
 582     pCDL->lpVtbl->AppendCategory(pCDL, L"Recent Sessions", array);
 583
 584     /*
 585      * Create an object collection to form the 'Tasks' category on the
 586      * jump list.
 587      */
 588     if (!SUCCEEDED(CoCreateInstance(&CLSID_EnumerableObjectCollection,
 589                                     NULL, CLSCTX_INPROC_SERVER,
 590                                     COMPTR(IObjectCollection, &collection))))
 591         goto cleanup;
 592
 593     /*
 594      * Add task entries for PuTTYgen and Pageant.
 595      */
 596     piterator = "Pageant.exe\0PuTTYgen.exe\0\0";
 597     while (*piterator != '\0') {
 598         link = make_shell_link(piterator, NULL);
 599         if (link) {
 600             collection->lpVtbl->AddObject(collection, link);
 601             link->lpVtbl->Release(link);
 602             link = NULL;
 603         }
 604         piterator += strlen(piterator) + 1;
 605     }
 606
 607     /*
 608      * Get the array form of the collection we've just constructed,
 609      * and put it in the jump list.
 610      */
 611     if (!SUCCEEDED(collection->lpVtbl->QueryInterface
 612                    (collection, COMPTR(IObjectArray, &array))))
 613         goto cleanup;
 614
 615     pCDL->lpVtbl->AddUserTasks(pCDL, array);
 616
 617     /*
 618      * Now we can clean up the array and collection variables, so as
 619      * to be able to reuse them.
 620      */
 621     array->lpVtbl->Release(array);
 622     array = NULL;
 623     collection->lpVtbl->Release(collection);
 624     collection = NULL;
 625
 626     /*
 627      * Create another object collection to form the user tasks
 628      * category.
 629      */
 630     if (!SUCCEEDED(CoCreateInstance(&CLSID_EnumerableObjectCollection,
 631                                     NULL, CLSCTX_INPROC_SERVER,
 632                                     COMPTR(IObjectCollection, &collection))))
 633         goto cleanup;
 634
 635     /*
 636      * Get the array form of the collection we've just constructed,
 637      * and put it in the jump list.
 638      */
 639     if (!SUCCEEDED(collection->lpVtbl->QueryInterface
 640                    (collection, COMPTR(IObjectArray, &array))))
 641         goto cleanup;
 642
 643     pCDL->lpVtbl->AddUserTasks(pCDL, array);
 644
 645     /*
 646      * Now we can clean up the array and collection variables, so as
 647      * to be able to reuse them.
 648      */
 649     array->lpVtbl->Release(array);
 650     array = NULL;
 651     collection->lpVtbl->Release(collection);
 652     collection = NULL;
 653
 654     /*
 655      * Commit the jump list.
 656      */
 657     pCDL->lpVtbl->CommitList(pCDL);
 658     need_abort = FALSE;
 659
 660     /*
 661      * Clean up.
 662      */
 663   cleanup:
 664     if (pRemoved) pRemoved->lpVtbl->Release(pRemoved);
 665     if (pCDL && need_abort) pCDL->lpVtbl->AbortList(pCDL);
 666     if (pCDL) pCDL->lpVtbl->Release(pCDL);
 667     if (collection) collection->lpVtbl->Release(collection);
 668     if (array) array->lpVtbl->Release(array);
 669     if (link) link->lpVtbl->Release(link);
 670     sfree(pjumplist_reg_entries);
 671 }
 672
 673 /* Clears the entire jumplist. */
 674 void clear_jumplist(void)
 675 {
 676     ICustomDestinationList *pCDL;
 677
 678     if (CoCreateInstance(&CLSID_DestinationList, NULL, CLSCTX_INPROC_SERVER,
 679                          COMPTR(ICustomDestinationList, &pCDL)) == S_OK) {
 680         pCDL->lpVtbl->DeleteList(pCDL, NULL);
 681         pCDL->lpVtbl->Release(pCDL);
 682     }
 683
 684 }
 685
 686 /* Adds a saved session to the Windows 7 jumplist. */
 687 void add_session_to_jumplist(const char * const sessionname)
 688 {
 689     if ((osVersion.dwMajorVersion < 6) ||
 690         (osVersion.dwMajorVersion == 6 && osVersion.dwMinorVersion < 1))
 691         return;                        /* do nothing on pre-Win7 systems */
 692
 693     if (add_to_jumplist_registry(sessionname) == JUMPLISTREG_OK) {
 694         update_jumplist_from_registry();
 695     } else {
 696         /* Make sure we don't leave the jumplist dangling. */
 697         clear_jumplist();
 698     }
 699 }
 700
 701 /* Removes a saved session from the Windows jumplist. */
 702 void remove_session_from_jumplist(const char * const sessionname)
 703 {
 704     if ((osVersion.dwMajorVersion < 6) ||
 705         (osVersion.dwMajorVersion == 6 && osVersion.dwMinorVersion < 1))
 706         return;                        /* do nothing on pre-Win7 systems */
 707
 708     if (remove_from_jumplist_registry(sessionname) == JUMPLISTREG_OK) {
 709         update_jumplist_from_registry();
 710     } else {
 711         /* Make sure we don't leave the jumplist dangling. */
 712         clear_jumplist();
 713     }
 714 }