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         FIXME(shell,"(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         FIXME(shell,"(%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         FIXME(shell,"(%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     FIXME(shell,"(%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         FIXME(shell,"(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         FIXME(shell,"(%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         FIXME(shell,"(%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         FIXME(shell,"(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     FIXME(shell,"(%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     FIXME(shell,"(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     FIXME(shell,"(0x%08lx,0x%08lx):stub.\n",x,y);
 379 }
 380
 381 /*************************************************************************
 382  *                              SHELL32_75      [SHELL32.75]
 383  * unknown
 384  */
 385 BOOL32 WINAPI SHELL32_75(LPDWORD x,LPDWORD y) {
 386     FIXME(shell,"(%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         FIXME(shell,"(%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         TRACE(shell,"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 typedef DWORD (* WINAPI GetClassPtr)(REFCLSID,REFIID,LPVOID);
 411
 412 static GetClassPtr SH_find_moduleproc(LPSTR dllname,HMODULE32 *xhmod,
 413                                       LPSTR name)
 414 {
 415         HMODULE32       hmod;
 416         FARPROC32       dllunload,nameproc;
 417
 418         if (xhmod) *xhmod = 0;
 419         if (!lstrcmpi32A(SHELL32_34(dllname),"shell32.dll"))
 420                 return (GetClassPtr)SHELL32_DllGetClassObject;
 421
 422         hmod = LoadLibraryEx32A(dllname,0,LOAD_WITH_ALTERED_SEARCH_PATH);
 423         if (!hmod)
 424                 return NULL;
 425         dllunload = GetProcAddress32(hmod,"DllCanUnloadNow");
 426         if (!dllunload)
 427                 if (xhmod) *xhmod = hmod;
 428         nameproc = GetProcAddress32(hmod,name);
 429         if (!nameproc) {
 430                 FreeLibrary32(hmod);
 431                 return NULL;
 432         }
 433         /* register unloadable dll with unloadproc ... */
 434         return (GetClassPtr)nameproc;
 435 }
 436
 437 static DWORD SH_get_instance(REFCLSID clsid,LPSTR dllname,
 438         LPVOID  unknownouter,REFIID refiid,LPVOID inst
 439 ) {
 440         GetClassPtr     dllgetclassob;
 441         DWORD           hres;
 442         LPCLASSFACTORY  classfac;
 443
 444         dllgetclassob = SH_find_moduleproc(dllname,NULL,"DllGetClassObject");
 445         if (!dllgetclassob)
 446                 return 0x80070000|GetLastError();
 447
 448 /* FIXME */
 449 /*
 450         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,inst);
 451         if (hres<0)
 452                 return hres;
 453
 454  */
 455         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,&classfac);
 456         if (hres<0)
 457                 return hres;
 458         classfac->lpvtbl->fnCreateInstance(classfac,unknownouter,refiid,inst);
 459         classfac->lpvtbl->fnRelease(classfac);
 460         return 0;
 461 }
 462
 463 /*************************************************************************
 464  *                              SHELL32_102     [SHELL32.102]
 465  * unknown
 466  */
 467 LRESULT WINAPI SHELL32_102(
 468         LPSTR aclsid,CLSID *clsid,LPUNKNOWN unknownouter,REFIID refiid,LPVOID inst
 469 ) {
 470         char    buffer[256],xclsid[48],xiid[48],path[260],tmodel[100];
 471         HKEY    inprockey;
 472         DWORD   pathlen,type,tmodellen;
 473         DWORD   hres;
 474
 475         WINE_StringFromCLSID(refiid,xiid);
 476
 477         if (clsid)
 478                 WINE_StringFromCLSID(clsid,xclsid);
 479         else {
 480                 if (!aclsid)
 481                     return 0x80040154;
 482                 strcpy(xclsid,aclsid);
 483         }
 484         TRACE(shell,"(%p,%s,%p,%s,%p)\n",
 485                 aclsid,xclsid,unknownouter,xiid,inst
 486         );
 487
 488         sprintf(buffer,"CLSID\\%s\\InProcServer32",xclsid);
 489         if (RegOpenKeyEx32A(HKEY_CLASSES_ROOT,buffer,0,0x02000000,&inprockey))
 490                 return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 491         pathlen=sizeof(path);
 492         if (RegQueryValue32A(inprockey,NULL,path,&pathlen)) {
 493                 RegCloseKey(inprockey);
 494                 return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 495         }
 496         TRACE(shell, "Server dll is %s\n",path);
 497         tmodellen=sizeof(tmodel);
 498         type=REG_SZ;
 499         if (RegQueryValueEx32A(inprockey,"ThreadingModel",NULL,&type,tmodel,&tmodellen)) {
 500                 RegCloseKey(inprockey);
 501                 return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 502         }
 503         TRACE(shell, "Threading model is %s\n",tmodel);
 504         hres=SH_get_instance(clsid,path,unknownouter,refiid,inst);
 505         if (hres<0)
 506                 hres=SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 507         RegCloseKey(inprockey);
 508         return hres;
 509 }
 510
 511
 512 /*************************************************************************
 513  *                       SHELL32_183                    [SHELL32.183]
 514  * Format and output errormessage.
 515  */
 516 void __cdecl SHELL32_183(HMODULE32 hmod,HWND32 hwnd,DWORD id,DWORD x,DWORD type,LPVOID arglist) {
 517         char    buf[100],buf2[100],*buf3;
 518         LPVOID  args = &arglist;
 519
 520         if (!LoadString32A(hmod,x,buf,100))
 521                 strcpy(buf,"Desktop");
 522         LoadString32A(hmod,id,buf2,100);
 523         /* FIXME: the varargs handling doesn't. */
 524         FormatMessage32A(0x500,buf2,0,0,&buf3,256,&args);
 525
 526         FIXME(shell,"(%08lx,%08lx,%08lx(%s),%08lx(%s),%08lx,%p):stub.\n",
 527                 (DWORD)hmod,(DWORD)hwnd,id,buf2,x,buf,type,arglist
 528         );
 529         /*MessageBox32A(hwnd,buf3,buf,id|0x10000);*/
 530 }
 531
 532
 533 /*************************************************************************
 534  *                       SHELL32_100                    [SHELL32.100]
 535  * walks through policy table, queries <app> key, <type> value, returns
 536  * queried (DWORD) value.
 537  * {0x00001,Explorer,NoRun}
 538  * {0x00002,Explorer,NoClose}
 539  * {0x00004,Explorer,NoSaveSettings}
 540  * {0x00008,Explorer,NoFileMenu}
 541  * {0x00010,Explorer,NoSetFolders}
 542  * {0x00020,Explorer,NoSetTaskbar}
 543  * {0x00040,Explorer,NoDesktop}
 544  * {0x00080,Explorer,NoFind}
 545  * {0x00100,Explorer,NoDrives}
 546  * {0x00200,Explorer,NoDriveAutoRun}
 547  * {0x00400,Explorer,NoDriveTypeAutoRun}
 548  * {0x00800,Explorer,NoNetHood}
 549  * {0x01000,Explorer,NoStartBanner}
 550  * {0x02000,Explorer,RestrictRun}
 551  * {0x04000,Explorer,NoPrinterTabs}
 552  * {0x08000,Explorer,NoDeletePrinter}
 553  * {0x10000,Explorer,NoAddPrinter}
 554  * {0x20000,Explorer,NoStartMenuSubFolders}
 555  * {0x40000,Explorer,MyDocsOnNet}
 556  * {0x80000,WinOldApp,NoRealMode}
 557  */
 558 DWORD WINAPI SHELL32_100(DWORD pol) {
 559         HKEY    xhkey;
 560
 561         FIXME(shell,"(%08lx):stub.\n",pol);
 562         if (RegOpenKey32A(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey))
 563                 return 0;
 564         /* FIXME: do nothing for now, just return 0 (== "allowed") */
 565         RegCloseKey(xhkey);
 566         return 0;
 567
 568 }
 569
 570 /*************************************************************************
 571  *                       SHELL32_152                    [SHELL32.152]
 572  * itemlist_length
 573  */
 574 DWORD WINAPI SHELL32_152(LPITEMIDLIST iil) {
 575         LPSHITEMID      si;
 576         DWORD           len;
 577
 578         si = &(iil->mkid);
 579         len = 2;
 580         while (si->cb) {
 581                 len     += si->cb;
 582                 si       = (LPSHITEMID)(((char*)si)+si->cb);
 583         }
 584         return len;
 585 }
 586
 587 /*************************************************************************
 588  *                      SHELL32_158                    [SHELL32.158]
 589  */
 590 LPSTR WINAPI SHELL32_158(LPSTR path,DWORD y,DWORD z) {
 591     TRACE(shell,"(%s,%08lx,%08lx)\n",path,y,z);
 592     path = SHELL32_31(path);
 593     return *path?(path+1):path;
 594 }
 595
 596 /*************************************************************************
 597  *                       SHELL32_165                    [SHELL32.165]
 598  * create_path_and_notify(...)
 599  */
 600 DWORD WINAPI SHELL32_165(DWORD x,LPCSTR path) {
 601         if (SHELL32_79(path,(LPVOID)x))
 602                 return 0;
 603         FIXME(shell,"(%08lx,%s):stub.\n",x,path);
 604         return 0;
 605 }
 606
 607 /*************************************************************************
 608  *                       SHELL32_195                    [SHELL32.195]
 609  * free_ptr() - frees memory using IMalloc
 610  */
 611 DWORD WINAPI SHELL32_195(LPVOID x) {
 612         return LocalFree32((HANDLE32)x);
 613 }
 614
 615 /*************************************************************************
 616  *                       SHELL32_196                    [SHELL32.196]
 617  * void *task_alloc(DWORD len), uses SHMalloc allocator
 618  */
 619 LPVOID WINAPI SHELL32_196(DWORD len) {
 620         return (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT); /* FIXME */
 621 }
 622
 623 /*************************************************************************
 624  *                       SHELL32_18                     [SHELL32.18]
 625  * copy_itemidlist()
 626  */
 627 LPITEMIDLIST WINAPI SHELL32_18(LPITEMIDLIST iil) {
 628         DWORD           len;
 629         LPITEMIDLIST    newiil;
 630
 631         len = SHELL32_152(iil);
 632         newiil = (LPITEMIDLIST)SHELL32_196(len);
 633         memcpy(newiil,iil,len);
 634         return newiil;
 635 }
 636
 637 /*************************************************************************
 638  *                       SHELL32_25                     [SHELL32.25]
 639  * merge_itemidlist()
 640  */
 641 LPITEMIDLIST WINAPI SHELL32_25(LPITEMIDLIST iil1,LPITEMIDLIST iil2) {
 642         DWORD           len1,len2;
 643         LPITEMIDLIST    newiil;
 644
 645         len1    = SHELL32_152(iil1)-2;
 646         len2    = SHELL32_152(iil2);
 647         newiil  = SHELL32_196(len1+len2);
 648         memcpy(newiil,iil1,len1);
 649         memcpy(((char*)newiil)+len1,iil2,len2);
 650         return newiil;
 651 }
 652
 653 /*************************************************************************
 654  *                       SHELL32_155                    [SHELL32.155]
 655  * free_check_ptr - frees memory (if not NULL) allocated by SHMalloc allocator
 656  */
 657 DWORD WINAPI SHELL32_155(LPVOID x) {
 658         if (!x)
 659                 return 0;
 660         return SHELL32_195(x);
 661 }
 662