misc/shellord.c

   1 /*
   2  *                              Shell Ordinal Functions
   3  *
   4  * These are completely undocumented. The meaning of the functions changes
   5  * between different OS versions (NT uses Unicode strings, 95 uses ASCII
   6  * strings, etc. etc.)
   7  *
   8  * They are just here so that explorer.exe and iexplore.exe can be tested.
   9  *
  10  * Copyright 1997 Marcus Meissner
  11  */
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <unistd.h>
  16 #include <ctype.h>
  17 #include "windows.h"
  18 #include "file.h"
  19 #include "shell.h"
  20 #include "heap.h"
  21 #include "module.h"
  22 #include "neexe.h"
  23 #include "resource.h"
  24 #include "dlgs.h"
  25 #include "win.h"
  26 #include "graphics.h"
  27 #include "cursoricon.h"
  28 #include "interfaces.h"
  29 #include "shlobj.h"
  30 #include "debug.h"
  31 #include "winreg.h"
  32
  33 /*************************************************************************
  34  *                       SHELL32_2                      [SHELL32.2]
  35  */
  36 DWORD WINAPI SHELL32_2(HWND32 hwnd,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6) {
  37         fprintf(stderr,"SHELL32_2(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub!\n",
  38                 hwnd,x2,x3,x4,x5,x6
  39         );
  40         return 0;
  41 }
  42 /*************************************************************************
  43  *                       SHELL32_16                     [SHELL32.16]
  44  * find_lastitem_in_itemidlist()
  45  */
  46 LPSHITEMID WINAPI SHELL32_16(LPITEMIDLIST iil) {
  47         LPSHITEMID      lastsii,sii;
  48
  49         if (!iil)
  50                 return NULL;
  51         sii = &(iil->mkid);
  52         lastsii = sii;
  53         while (sii->cb) {
  54                 lastsii = sii;
  55                 sii = (LPSHITEMID)(((char*)sii)+sii->cb);
  56         }
  57         return lastsii;
  58 }
  59 /*************************************************************************
  60  *                       SHELL32_29                     [SHELL32.29]
  61  * is_rootdir(const char*path)
  62  */
  63 BOOL32 WINAPI SHELL32_29(LPCSTR x) {
  64         if (!lstrcmp32A(x+1,":\\"))             /* "X:\" */
  65                 return 1;
  66         if (!lstrcmp32A(x,"\\"))                /* "\" */
  67                 return 1;
  68         if (x[0]=='\\' && x[1]=='\\') {         /* UNC "\\<xx>\" */
  69                 int     foundbackslash = 0;
  70                 x=x+2;
  71                 while (*x) {
  72                         if (*x++=='\\')
  73                                 foundbackslash++;
  74                 }
  75                 if (foundbackslash<=1)  /* max 1 \ more ... */
  76                         return 1;
  77         }
  78         return 0;
  79 }
  80
  81 /*************************************************************************
  82  *                       SHELL32_30                     [SHELL32.30]
  83  * get_rootdir(char*path,int drive)
  84  */
  85 LPSTR WINAPI SHELL32_30(LPSTR root,BYTE drive) {
  86         strcpy(root,"A:\\");
  87         root[0]+=drive;
  88         return root;
  89 }
  90
  91 /*************************************************************************
  92  *                                      SHELL32_31      [SHELL32.31]
  93  * returns pointer to last . in last pathcomponent or at \0.
  94  */
  95 LPSTR WINAPI SHELL32_31(LPSTR path) {
  96     LPSTR   lastpoint = NULL;
  97
  98     while (*path) {
  99         if (*path=='\\'||*path==' ')
 100             lastpoint=NULL;
 101         if (*path=='.')
 102             lastpoint=path;
 103         path++;
 104     }
 105     return lastpoint?lastpoint:path;
 106 }
 107
 108 /*************************************************************************
 109  *                              SHELL32_32      [SHELL32.32]
 110  * append \ if there is none
 111  */
 112 LPSTR WINAPI SHELL32_32(LPSTR path) {
 113     int len;
 114
 115     len = lstrlen32A(path);
 116     if (len && path[len-1]!='\\') {
 117         path[len+0]='\\';
 118         path[len+1]='\0';
 119         return path+len+1;
 120     } else
 121         return path+len;
 122 }
 123
 124 /*************************************************************************
 125  *                              SHELL32_33      [SHELL32.33]
 126  * remove spaces from beginning and end of passed string
 127  */
 128 LPSTR WINAPI SHELL32_33(LPSTR str) {
 129     LPSTR x = str;
 130
 131     while (*x==' ') x++;
 132     if (x!=str)
 133         lstrcpy32A(str,x);
 134     if (!*str)
 135         return str;
 136     x=str+strlen(str)-1;
 137     while (*x==' ')
 138         x--;
 139     if (*x==' ')
 140         *x='\0';
 141     return x;
 142 }
 143
 144
 145 /*************************************************************************
 146  *                              SHELL32_34      [SHELL32.34]
 147  * basename(char *fn);
 148  */
 149 LPSTR WINAPI SHELL32_34(LPSTR fn) {
 150     LPSTR basefn;
 151
 152     basefn = fn;
 153     while (fn[0]) {
 154         if (((fn[0]=='\\') || (fn[0]==':')) && fn[1] && fn[1]!='\\')
 155             basefn = fn+1;
 156         fn++;
 157     }
 158     return basefn;
 159 }
 160
 161 /*************************************************************************
 162  *                       SHELL32_35                     [SHELL32.35]
 163  * bool getpath(char *pathname); truncates passed argument to a valid path
 164  * returns if the string was modified or not.
 165  * "\foo\xx\foo"-> "\foo\xx"
 166  * "\"          -> "\"
 167  * "a:\foo"     -> "a:\"
 168  */
 169 DWORD WINAPI SHELL32_35(LPSTR fn) {
 170         LPSTR   x,cutplace;
 171
 172         if (!fn[0])
 173                 return 0;
 174         x=fn;
 175         cutplace = fn;
 176         while (*x) {
 177                 if (*x=='\\') {
 178                         cutplace=x++;
 179                         continue;
 180                 }
 181                 if (*x==':') {
 182                         x++;
 183                         if (*x=='\\')
 184                                 cutplace=++x;
 185                         continue; /* already x++ed */
 186                 }
 187                 x++;
 188         }
 189         if (!*cutplace)
 190                 return 0;
 191         if (cutplace==fn) {
 192                 if (fn[0]=='\\') {
 193                         if (!fn[1])
 194                                 return 0;
 195                         fn[0]='\0';
 196                         return 1;
 197                 }
 198         }
 199         *cutplace='\0';
 200         return 1;
 201 }
 202
 203 /*************************************************************************
 204  *                              SHELL32_37      [SHELL32.37]
 205  * concat_paths(char*target,const char*add);
 206  * concats "target\\add" and writes them to target
 207  */
 208 LPSTR WINAPI SHELL32_37(LPSTR target,LPSTR x1,LPSTR x2) {
 209         char    buf[260];
 210
 211         if (!x2 || !x2[0]) {
 212                 lstrcpy32A(target,x1);
 213                 return target;
 214         }
 215         lstrcpy32A(buf,x1);
 216         SHELL32_32(buf); /* append \ if not there */
 217         lstrcat32A(buf,x2);
 218         lstrcpy32A(target,buf);
 219         return target;
 220 }
 221
 222 /*************************************************************************
 223  *                              SHELL32_36      [SHELL32.36]
 224  * concat_paths(char*target,const char*add);
 225  * concats "target\\add" and writes them to target
 226  */
 227 LPSTR WINAPI SHELL32_36(LPSTR x1,LPSTR x2) {
 228         while (x2[0]=='\\') x2++;
 229         return SHELL32_37(x1,x1,x2);
 230 }
 231
 232 /*************************************************************************
 233  *                              SHELL32_39      [SHELL32.39]
 234  * isUNC(const char*path);
 235  */
 236 BOOL32 WINAPI SHELL32_39(LPCSTR path) {
 237         if ((path[0]=='\\') && (path[1]=='\\'))
 238                 return TRUE;
 239         return FALSE;
 240 }
 241
 242 /*************************************************************************
 243  *                              SHELL32_45      [SHELL32.45]
 244  * file_exists(char *fn);
 245  */
 246 BOOL32 WINAPI SHELL32_45(LPSTR fn) {
 247     if (GetFileAttributes32A(fn)==-1)
 248         return FALSE;
 249     else
 250         return TRUE;
 251 }
 252
 253 /*************************************************************************
 254  *                              SHELL32_52      [SHELL32.52]
 255  * look for next arg in string. handle "quoted" strings
 256  * returns pointer to argument *AFTER* the space. Or to the \0.
 257  */
 258 LPSTR WINAPI SHELL32_52(LPSTR cmdline) {
 259     BOOL32      qflag = FALSE;
 260
 261     while (*cmdline) {
 262         if ((*cmdline==' ') && !qflag)
 263                 return cmdline+1;
 264         if (*cmdline=='"')
 265                 qflag=!qflag;
 266         cmdline++;
 267     }
 268     return cmdline;
 269 }
 270
 271 /*************************************************************************
 272  *                              SHELL32_56      [SHELL32.56]
 273  * unquote string (remove ")
 274  */
 275 VOID WINAPI SHELL32_56(LPSTR str) {
 276     DWORD      len = lstrlen32A(str);
 277
 278     if (*str!='"') return;
 279     if (str[len-1]!='"') return;
 280     str[len-1]='\0';
 281     lstrcpy32A(str,str+1);
 282     return;
 283 }
 284
 285 /*************************************************************************
 286  *                       SHELL32_58                     [SHELL32.58]
 287  */
 288 DWORD WINAPI SHELL32_58(LPCSTR src,DWORD x2,LPSTR target,DWORD pathlen) {
 289         fprintf(stderr,"SHELL32_58(%s,0x%08lx,%p,%ld),STUB!\n",
 290                 src,x2,target,pathlen
 291         );
 292         if (!src)
 293                 return 0;
 294         return 0;
 295 }
 296
 297 /*************************************************************************
 298  *                       SHELL32_62                     [SHELL32.62]
 299  */
 300 DWORD WINAPI SHELL32_62(DWORD x,DWORD y,DWORD z,DWORD a) {
 301         fprintf(stderr,"SHELL32_62(%08lx,%08lx,%08lx,%08lx),stub!\n",x,y,z,a);
 302         return 0xffffffff;
 303 }
 304
 305 /*************************************************************************
 306  *                      SHELL32_63                     [SHELL32.63]
 307  */
 308 DWORD WINAPI SHELL32_63(HWND32 howner, LPSTR targetbuf, DWORD len, DWORD x, LPCSTR suffix, LPCSTR y, LPCSTR cmd) {
 309     fprintf(stderr,"SHELL32_63(%04x,%p,%ld,%08lx,%s,%s,%s),stub!\n",
 310             howner,targetbuf,len,x,suffix,y,cmd
 311     );
 312     /* puts up a Open Dialog and requests input into targetbuf */
 313     /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
 314     lstrcpy32A(targetbuf,"x:\\s3.exe");
 315     return 1;
 316 }
 317
 318 /*************************************************************************
 319  *                      SHELL32_68                     [SHELL32.68]
 320  */
 321 DWORD WINAPI SHELL32_68(DWORD x,DWORD y,DWORD z) {
 322         fprintf(stderr,"SHELL32_68(0x%08lx,0x%08lx,0x%08lx),stub!\n",
 323                 x,y,z
 324         );
 325         return 0;
 326 }
 327 /*************************************************************************
 328  *                       SHELL32_71                     [SHELL32.71]
 329  * returns internal shell values in the passed pointers
 330  */
 331 BOOL32 WINAPI SHELL32_71(LPDWORD x,LPDWORD y) {
 332
 333         fprintf(stderr,"SHELL32_71(%p,%p),stub!\n",x,y);
 334         return TRUE;
 335 }
 336
 337 /*************************************************************************
 338  *                       SHELL32_72                     [SHELL32.72]
 339  * dunno. something with icons
 340  */
 341 void WINAPI SHELL32_72(LPSTR x,DWORD y,DWORD z) {
 342         fprintf(stderr,"SHELL32_72(%s,%08lx,%08lx),stub!\n",x,y,z);
 343 }
 344
 345 /*************************************************************************
 346  *                       SHELL32_89                     [SHELL32.89]
 347  */
 348 DWORD WINAPI SHELL32_89(DWORD x1,DWORD x2,DWORD x3) {
 349         fprintf(stderr,"SHELL32_89(0x%08lx,0x%08lx,0x%08lx),stub!\n",
 350                 x1,x2,x3
 351         );
 352         return 0;
 353 }
 354
 355 /*************************************************************************
 356  *                              SHELL32_119     [SHELL32.119]
 357  * unknown
 358  */
 359 void WINAPI SHELL32_119(LPVOID x) {
 360     fprintf(stderr,"SHELL32_119(%p(%s)),stub\n",x,(char *)x);
 361 }
 362
 363 /*************************************************************************
 364  *                              SHELL32_175     [SHELL32.175]
 365  * unknown
 366  */
 367 void WINAPI SHELL32_175(DWORD x1,DWORD x2,DWORD x3,DWORD x4) {
 368     fprintf(stderr,"SHELL32_175(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub\n",
 369         x1,x2,x3,x4
 370     );
 371 }
 372
 373 /*************************************************************************
 374  *                              SHELL32_181     [SHELL32.181]
 375  * unknown
 376  */
 377 void WINAPI SHELL32_181(DWORD x,DWORD y) {
 378     fprintf(stderr,"SHELL32_181(0x%08lx,0x%08lx)\n",x,y);
 379 }
 380
 381 /*************************************************************************
 382  *                              SHELL32_75      [SHELL32.75]
 383  * unknown
 384  */
 385 BOOL32 WINAPI SHELL32_75(LPDWORD x,LPDWORD y) {
 386     fprintf(stderr,"SHELL32_75(%p,%p),stub\n",x,y);
 387     return TRUE;
 388 }
 389
 390 /*************************************************************************
 391  *                       SHELL32_77                     [SHELL32.77]
 392  */
 393 DWORD WINAPI SHELL32_77(DWORD x,DWORD y,DWORD z) {
 394         fprintf(stderr,"SHELL32_77(%08lx,%08lx,%08lx),stub!\n",x,y,z);
 395         return 0;
 396 }
 397
 398 /*************************************************************************
 399  *                       SHELL32_79                     [SHELL32.79]
 400  * create_directory_and_notify(...)
 401  */
 402 DWORD WINAPI SHELL32_79(LPCSTR dir,LPVOID xvoid) {
 403         fprintf(stderr,"mkdir %s,%p\n",dir,xvoid);
 404         if (!CreateDirectory32A(dir,xvoid))
 405                 return FALSE;
 406         /* SHChangeNotify(8,1,dir,0); */
 407         return TRUE;
 408 }
 409
 410 static FARPROC32 _find_moduleproc(LPSTR dllname,HMODULE32 *xhmod,LPSTR name) {
 411         HMODULE32       hmod;
 412         FARPROC32       dllunload,nameproc;
 413
 414         if (xhmod) *xhmod = 0;
 415         if (!lstrcmpi32A(SHELL32_34(dllname),"shell32.dll"))
 416                 return (FARPROC32)SHELL32_DllGetClassObject;
 417
 418         hmod = LoadLibraryEx32A(dllname,0,LOAD_WITH_ALTERED_SEARCH_PATH);
 419         if (!hmod)
 420                 return NULL;
 421         dllunload = GetProcAddress32(hmod,"DllCanUnloadNow");
 422         if (!dllunload)
 423                 if (xhmod) *xhmod = hmod;
 424         nameproc = GetProcAddress32(hmod,name);
 425         if (!nameproc) {
 426                 FreeLibrary32(hmod);
 427                 return NULL;
 428         }
 429         /* register unloadable dll with unloadproc ... */
 430         return nameproc;
 431 }
 432
 433 static DWORD _get_instance(REFCLSID clsid,LPSTR dllname,
 434         LPVOID  unknownouter,REFIID refiid,LPVOID inst
 435 ) {
 436         DWORD   WINAPI  (*dllgetclassob)(REFCLSID,REFIID,LPVOID);
 437         DWORD           hres;
 438         LPCLASSFACTORY  classfac;
 439
 440         dllgetclassob = (DWORD(*)(REFCLSID,REFIID,LPVOID))_find_moduleproc(dllname,NULL,"DllGetClassObject");
 441         if (!dllgetclassob)
 442                 return 0x80070000|GetLastError();
 443
 444 /* FIXME */
 445 /*
 446         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,inst);
 447         if (hres<0)
 448                 return hres;
 449
 450  */
 451         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,&classfac);
 452         if (hres<0)
 453                 return hres;
 454         classfac->lpvtbl->fnCreateInstance(classfac,unknownouter,refiid,inst);
 455         classfac->lpvtbl->fnRelease(classfac);
 456         return 0;
 457 }
 458 /*************************************************************************
 459  *                              SHELL32_102     [SHELL32.102]
 460  * unknown
 461  */
 462 LRESULT WINAPI SHELL32_102(
 463         LPSTR aclsid,CLSID *clsid,LPUNKNOWN unknownouter,REFIID refiid,LPVOID inst
 464 ) {
 465         char    buffer[256],xclsid[48],xiid[48],path[260],tmodel[100];
 466         HKEY    inprockey;
 467         DWORD   pathlen,type,tmodellen;
 468         DWORD   hres;
 469
 470         WINE_StringFromCLSID(refiid,xiid);
 471
 472         if (clsid)
 473                 WINE_StringFromCLSID(clsid,xclsid);
 474         else {
 475                 if (!aclsid)
 476                     return 0x80040154;
 477                 strcpy(xclsid,aclsid);
 478         }
 479         fprintf(stderr,"SHELL32_102(%p,%s,%p,%s,%p)\n",
 480                 aclsid,xclsid,unknownouter,xiid,inst
 481         );
 482
 483         sprintf(buffer,"CLSID\\%s\\InProcServer32",xclsid);
 484         if (RegOpenKeyEx32A(HKEY_CLASSES_ROOT,buffer,0,0x02000000,&inprockey))
 485                 return _get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 486         pathlen=sizeof(path);
 487         if (RegQueryValue32A(inprockey,NULL,path,&pathlen)) {
 488                 RegCloseKey(inprockey);
 489                 return _get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 490         }
 491         fprintf(stderr,"        -> server dll is %s\n",path);
 492         tmodellen=sizeof(tmodel);
 493         type=REG_SZ;
 494         if (RegQueryValueEx32A(inprockey,"ThreadingModel",NULL,&type,tmodel,&tmodellen)) {
 495                 RegCloseKey(inprockey);
 496                 return _get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 497         }
 498         fprintf(stderr,"        -> threading model is %s\n",tmodel);
 499         hres=_get_instance(clsid,path,unknownouter,refiid,inst);
 500         if (hres<0)
 501                 hres=_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 502         RegCloseKey(inprockey);
 503         return hres;
 504 }
 505
 506
 507 /*************************************************************************
 508  *                       SHELL32_183                    [SHELL32.183]
 509  * Format and output errormessage.
 510  */
 511 void __cdecl SHELL32_183(HMODULE32 hmod,HWND32 hwnd,DWORD id,DWORD x,DWORD type,LPVOID arglist) {
 512         char    buf[100],buf2[100],*buf3;
 513         LPVOID  args = &arglist;
 514
 515         if (!LoadString32A(hmod,x,buf,100))
 516                 strcpy(buf,"Desktop");
 517         LoadString32A(hmod,id,buf2,100);
 518         /* FIXME: the varargs handling doesn't. */
 519         FormatMessage32A(0x500,buf2,0,0,&buf3,256,&args);
 520
 521         fprintf(stderr,"SHELL32_183(%08lx,%08lx,%08lx(%s),%08lx(%s),%08lx,%p),stub!\n",
 522                 (DWORD)hmod,(DWORD)hwnd,id,buf2,x,buf,type,arglist
 523         );
 524         /*MessageBox32A(hwnd,buf3,buf,id|0x10000);*/
 525 }
 526
 527
 528 /*************************************************************************
 529  *                       SHELL32_100                    [SHELL32.100]
 530  * walks through policy table, queries <app> key, <type> value, returns
 531  * queried (DWORD) value.
 532  * {0x00001,Explorer,NoRun}
 533  * {0x00002,Explorer,NoClose}
 534  * {0x00004,Explorer,NoSaveSettings}
 535  * {0x00008,Explorer,NoFileMenu}
 536  * {0x00010,Explorer,NoSetFolders}
 537  * {0x00020,Explorer,NoSetTaskbar}
 538  * {0x00040,Explorer,NoDesktop}
 539  * {0x00080,Explorer,NoFind}
 540  * {0x00100,Explorer,NoDrives}
 541  * {0x00200,Explorer,NoDriveAutoRun}
 542  * {0x00400,Explorer,NoDriveTypeAutoRun}
 543  * {0x00800,Explorer,NoNetHood}
 544  * {0x01000,Explorer,NoStartBanner}
 545  * {0x02000,Explorer,RestrictRun}
 546  * {0x04000,Explorer,NoPrinterTabs}
 547  * {0x08000,Explorer,NoDeletePrinter}
 548  * {0x10000,Explorer,NoAddPrinter}
 549  * {0x20000,Explorer,NoStartMenuSubFolders}
 550  * {0x40000,Explorer,MyDocsOnNet}
 551  * {0x80000,WinOldApp,NoRealMode}
 552  */
 553 DWORD WINAPI SHELL32_100(DWORD pol) {
 554         HKEY    xhkey;
 555
 556         fprintf(stderr,"SHELL32_100(%08lx),stub!\n",pol);
 557         if (RegOpenKey32A(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey))
 558                 return 0;
 559         /* FIXME: do nothing for now, just return 0 (== "allowed") */
 560         RegCloseKey(xhkey);
 561         return 0;
 562
 563 }
 564
 565 /*************************************************************************
 566  *                       SHELL32_152                    [SHELL32.152]
 567  * itemlist_length
 568  */
 569 DWORD WINAPI SHELL32_152(LPITEMIDLIST iil) {
 570         LPSHITEMID      si;
 571         DWORD           len;
 572
 573         si = &(iil->mkid);
 574         len = 2;
 575         while (si->cb) {
 576                 len     += si->cb;
 577                 si       = (LPSHITEMID)(((char*)si)+si->cb);
 578         }
 579         return len;
 580 }
 581
 582 /*************************************************************************
 583  *                      SHELL32_158                    [SHELL32.158]
 584  */
 585 LPSTR WINAPI SHELL32_158(LPSTR path,DWORD y,DWORD z) {
 586     fprintf(stderr,"SHELL32_158(%s,%08lx,%08lx)\n",path,y,z);
 587     path = SHELL32_31(path);
 588     return *path?(path+1):path;
 589 }
 590
 591 /*************************************************************************
 592  *                       SHELL32_165                    [SHELL32.165]
 593  * create_path_and_notify(...)
 594  */
 595 DWORD WINAPI SHELL32_165(DWORD x,LPCSTR path) {
 596         if (SHELL32_79(path,(LPVOID)x))
 597                 return 0;
 598         fprintf(stderr,"SHELL32_165(%08lx,%s),stub!\n",x,path);
 599         return 0;
 600 }
 601
 602 /*************************************************************************
 603  *                       SHELL32_195                    [SHELL32.195]
 604  * free_ptr() - frees memory using IMalloc
 605  */
 606 DWORD WINAPI SHELL32_195(LPVOID x) {
 607         return LocalFree32((HANDLE32)x);
 608 }
 609
 610 /*************************************************************************
 611  *                       SHELL32_196                    [SHELL32.196]
 612  * void *task_alloc(DWORD len), uses SHMalloc allocator
 613  */
 614 LPVOID WINAPI SHELL32_196(DWORD len) {
 615         return (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT); /* FIXME */
 616 }
 617
 618 /*************************************************************************
 619  *                       SHELL32_18                     [SHELL32.18]
 620  * copy_itemidlist()
 621  */
 622 LPITEMIDLIST WINAPI SHELL32_18(LPITEMIDLIST iil) {
 623         DWORD           len;
 624         LPITEMIDLIST    newiil;
 625
 626         len = SHELL32_152(iil);
 627         newiil = (LPITEMIDLIST)SHELL32_196(len);
 628         memcpy(newiil,iil,len);
 629         return newiil;
 630 }
 631
 632 /*************************************************************************
 633  *                       SHELL32_25                     [SHELL32.25]
 634  * merge_itemidlist()
 635  */
 636 LPITEMIDLIST WINAPI SHELL32_25(LPITEMIDLIST iil1,LPITEMIDLIST iil2) {
 637         DWORD           len1,len2;
 638         LPITEMIDLIST    newiil;
 639
 640         len1    = SHELL32_152(iil1)-2;
 641         len2    = SHELL32_152(iil2);
 642         newiil  = SHELL32_196(len1+len2);
 643         memcpy(newiil,iil1,len1);
 644         memcpy(((char*)newiil)+len1,iil2,len2);
 645         return newiil;
 646 }
 647
 648 /*************************************************************************
 649  *                       SHELL32_155                    [SHELL32.155]
 650  * free_check_ptr - frees memory (if not NULL) allocated by SHMalloc allocator
 651  */
 652 DWORD WINAPI SHELL32_155(LPVOID x) {
 653         if (!x)
 654                 return 0;
 655         return SHELL32_195(x);
 656 }