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 <string.h>
  14 #include <unistd.h>
  15 #include <ctype.h>
  16 #include "windows.h"
  17 #include "winerror.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_51      [SHELL32.51]
 255  */
 256 DWORD WINAPI SHELL32_51(LPCSTR s,DWORD x2,DWORD x3) {
 257         FIXME(shell,"(%s,0x%08lx,0x%08lx),stub!\n",s,x2,x3);
 258         return 0;
 259 }
 260
 261 /*************************************************************************
 262  *                              SHELL32_52      [SHELL32.52]
 263  * look for next arg in string. handle "quoted" strings
 264  * returns pointer to argument *AFTER* the space. Or to the \0.
 265  */
 266 LPSTR WINAPI SHELL32_52(LPSTR cmdline) {
 267     BOOL32      qflag = FALSE;
 268
 269     while (*cmdline) {
 270         if ((*cmdline==' ') && !qflag)
 271                 return cmdline+1;
 272         if (*cmdline=='"')
 273                 qflag=!qflag;
 274         cmdline++;
 275     }
 276     return cmdline;
 277 }
 278
 279 /*************************************************************************
 280  *                              SHELL32_56      [SHELL32.56]
 281  * unquote string (remove ")
 282  */
 283 VOID WINAPI SHELL32_56(LPSTR str) {
 284     DWORD      len = lstrlen32A(str);
 285
 286     if (*str!='"') return;
 287     if (str[len-1]!='"') return;
 288     str[len-1]='\0';
 289     lstrcpy32A(str,str+1);
 290     return;
 291 }
 292
 293 /*************************************************************************
 294  *                       SHELL32_58                     [SHELL32.58]
 295  */
 296 DWORD WINAPI SHELL32_58(LPCSTR src,DWORD x2,LPSTR target,DWORD pathlen) {
 297         FIXME(shell,"(%s,0x%08lx,%p,%ld):stub.\n",
 298                 src,x2,target,pathlen
 299         );
 300         if (!src)
 301                 return 0;
 302         return 0;
 303 }
 304
 305 /*************************************************************************
 306  *                       SHELL32_62                     [SHELL32.62]
 307  */
 308 DWORD WINAPI SHELL32_62(DWORD x,DWORD y,DWORD z,DWORD a) {
 309         FIXME(shell,"(%08lx,%08lx,%08lx,%08lx):stub.\n",x,y,z,a);
 310         return 0xffffffff;
 311 }
 312
 313 /*************************************************************************
 314  *                      SHELL32_63                     [SHELL32.63]
 315  */
 316 DWORD WINAPI SHELL32_63(HWND32 howner, LPSTR targetbuf, DWORD len, DWORD x, LPCSTR suffix, LPCSTR y, LPCSTR cmd) {
 317     FIXME(shell,"(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n",
 318             howner,targetbuf,len,x,suffix,y,cmd
 319     );
 320     /* puts up a Open Dialog and requests input into targetbuf */
 321     /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
 322     lstrcpy32A(targetbuf,"x:\\s3.exe");
 323     return 1;
 324 }
 325
 326 /*************************************************************************
 327  *                      SHELL32_68                     [SHELL32.68]
 328  */
 329 DWORD WINAPI SHELL32_68(DWORD x,DWORD y,DWORD z) {
 330         FIXME(shell,"(0x%08lx,0x%08lx,0x%08lx):stub.\n",
 331                 x,y,z
 332         );
 333         return 0;
 334 }
 335 /*************************************************************************
 336  *                       SHELL32_71                     [SHELL32.71]
 337  * returns internal shell values in the passed pointers
 338  */
 339 BOOL32 WINAPI SHELL32_71(LPDWORD x,LPDWORD y) {
 340
 341         FIXME(shell,"(%p,%p):stub.\n",x,y);
 342         return TRUE;
 343 }
 344
 345 /*************************************************************************
 346  *                       SHELL32_72                     [SHELL32.72]
 347  * dunno. something with icons
 348  */
 349 void WINAPI SHELL32_72(LPSTR x,DWORD y,DWORD z) {
 350         FIXME(shell,"(%s,%08lx,%08lx):stub.\n",x,y,z);
 351 }
 352
 353 /*************************************************************************
 354  *                       SHELL32_89                     [SHELL32.89]
 355  */
 356 DWORD WINAPI SHELL32_89(DWORD x1,DWORD x2,DWORD x3) {
 357         FIXME(shell,"(0x%08lx,0x%08lx,0x%08lx):stub.\n",
 358                 x1,x2,x3
 359         );
 360         return 0;
 361 }
 362
 363 /*************************************************************************
 364  *                              SHELL32_119     [SHELL32.119]
 365  * unknown
 366  */
 367 void WINAPI SHELL32_119(LPVOID x) {
 368     FIXME(shell,"(%p(%s)):stub.\n",x,(char *)x);
 369 }
 370
 371 /*************************************************************************
 372  *                              SHELL32_175     [SHELL32.175]
 373  * unknown
 374  */
 375 void WINAPI SHELL32_175(DWORD x1,DWORD x2,DWORD x3,DWORD x4) {
 376     FIXME(shell,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub.\n",
 377         x1,x2,x3,x4
 378     );
 379 }
 380
 381 /*************************************************************************
 382  *                              SHELL32_181     [SHELL32.181]
 383  * unknown
 384  */
 385 void WINAPI SHELL32_181(DWORD x,DWORD y) {
 386     FIXME(shell,"(0x%08lx,0x%08lx):stub.\n",x,y);
 387 }
 388
 389 /*************************************************************************
 390  *                              SHELL32_75      [SHELL32.75]
 391  * unknown
 392  */
 393 BOOL32 WINAPI SHELL32_75(LPDWORD x,LPDWORD y) {
 394     FIXME(shell,"(%p,%p):stub.\n",x,y);
 395     return TRUE;
 396 }
 397
 398 /*************************************************************************
 399  *                       SHELL32_77                     [SHELL32.77]
 400  */
 401 DWORD WINAPI SHELL32_77(DWORD x,DWORD y,DWORD z) {
 402         FIXME(shell,"(%08lx,%08lx,%08lx):stub.\n",x,y,z);
 403         return 0;
 404 }
 405
 406 /*************************************************************************
 407  *                       SHELL32_79                     [SHELL32.79]
 408  * create_directory_and_notify(...)
 409  */
 410 DWORD WINAPI SHELL32_79(LPCSTR dir,LPVOID xvoid) {
 411         TRACE(shell,"mkdir %s,%p\n",dir,xvoid);
 412         if (!CreateDirectory32A(dir,xvoid))
 413                 return FALSE;
 414         /* SHChangeNotify(8,1,dir,0); */
 415         return TRUE;
 416 }
 417
 418 typedef DWORD (* WINAPI GetClassPtr)(REFCLSID,REFIID,LPVOID);
 419
 420 static GetClassPtr SH_find_moduleproc(LPSTR dllname,HMODULE32 *xhmod,
 421                                       LPSTR name)
 422 {
 423         HMODULE32       hmod;
 424         FARPROC32       dllunload,nameproc;
 425
 426         if (xhmod) *xhmod = 0;
 427         if (!lstrcmpi32A(SHELL32_34(dllname),"shell32.dll"))
 428                 return (GetClassPtr)SHELL32_DllGetClassObject;
 429
 430         hmod = LoadLibraryEx32A(dllname,0,LOAD_WITH_ALTERED_SEARCH_PATH);
 431         if (!hmod)
 432                 return NULL;
 433         dllunload = GetProcAddress32(hmod,"DllCanUnloadNow");
 434         if (!dllunload)
 435                 if (xhmod) *xhmod = hmod;
 436         nameproc = GetProcAddress32(hmod,name);
 437         if (!nameproc) {
 438                 FreeLibrary32(hmod);
 439                 return NULL;
 440         }
 441         /* register unloadable dll with unloadproc ... */
 442         return (GetClassPtr)nameproc;
 443 }
 444
 445 static DWORD SH_get_instance(REFCLSID clsid,LPSTR dllname,
 446         LPVOID  unknownouter,REFIID refiid,LPVOID inst
 447 ) {
 448         GetClassPtr     dllgetclassob;
 449         DWORD           hres;
 450         LPCLASSFACTORY  classfac;
 451
 452         dllgetclassob = SH_find_moduleproc(dllname,NULL,"DllGetClassObject");
 453         if (!dllgetclassob)
 454                 return 0x80070000|GetLastError();
 455
 456 /* FIXME */
 457 /*
 458         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,inst);
 459         if (hres<0)
 460                 return hres;
 461
 462  */
 463         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,&classfac);
 464         if (hres<0 || (hres>=0x80000000))
 465                 return hres;
 466         if (!classfac) {
 467                 FIXME(shell,"no classfactory, but hres is 0x%ld!\n",hres);
 468                 return E_FAIL;
 469         }
 470         classfac->lpvtbl->fnCreateInstance(classfac,unknownouter,refiid,inst);
 471         classfac->lpvtbl->fnRelease(classfac);
 472         return 0;
 473 }
 474
 475 /*************************************************************************
 476  *                              SHELL32_102     [SHELL32.102]
 477  * unknown
 478  */
 479 LRESULT WINAPI SHELL32_102(
 480         LPSTR aclsid,CLSID *clsid,LPUNKNOWN unknownouter,REFIID refiid,LPVOID inst
 481 ) {
 482         char    buffer[256],xclsid[48],xiid[48],path[260],tmodel[100];
 483         HKEY    inprockey;
 484         DWORD   pathlen,type,tmodellen;
 485         DWORD   hres;
 486
 487         WINE_StringFromCLSID(refiid,xiid);
 488
 489         if (clsid)
 490                 WINE_StringFromCLSID(clsid,xclsid);
 491         else {
 492                 if (!aclsid)
 493                     return 0x80040154;
 494                 strcpy(xclsid,aclsid);
 495         }
 496         TRACE(shell,"(%p,%s,%p,%s,%p)\n",
 497                 aclsid,xclsid,unknownouter,xiid,inst
 498         );
 499
 500         sprintf(buffer,"CLSID\\%s\\InProcServer32",xclsid);
 501         if (RegOpenKeyEx32A(HKEY_CLASSES_ROOT,buffer,0,0x02000000,&inprockey))
 502                 return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 503         pathlen=sizeof(path);
 504         if (RegQueryValue32A(inprockey,NULL,path,&pathlen)) {
 505                 RegCloseKey(inprockey);
 506                 return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 507         }
 508         TRACE(shell, "Server dll is %s\n",path);
 509         tmodellen=sizeof(tmodel);
 510         type=REG_SZ;
 511         if (RegQueryValueEx32A(inprockey,"ThreadingModel",NULL,&type,tmodel,&tmodellen)) {
 512                 RegCloseKey(inprockey);
 513                 return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 514         }
 515         TRACE(shell, "Threading model is %s\n",tmodel);
 516         hres=SH_get_instance(clsid,path,unknownouter,refiid,inst);
 517         if (hres<0)
 518                 hres=SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 519         RegCloseKey(inprockey);
 520         return hres;
 521 }
 522
 523
 524 /*************************************************************************
 525  *                       SHELL32_183                    [SHELL32.183]
 526  * Format and output errormessage.
 527  */
 528 void __cdecl SHELL32_183(HMODULE32 hmod,HWND32 hwnd,DWORD id,DWORD x,DWORD type,LPVOID arglist) {
 529         char    buf[100],buf2[100],*buf3;
 530         LPVOID  args = &arglist;
 531
 532         if (!LoadString32A(hmod,x,buf,100))
 533                 strcpy(buf,"Desktop");
 534         LoadString32A(hmod,id,buf2,100);
 535         /* FIXME: the varargs handling doesn't. */
 536         FormatMessage32A(0x500,buf2,0,0,(LPSTR)&buf3,256,(LPDWORD)&args);
 537
 538         FIXME(shell,"(%08lx,%08lx,%08lx(%s),%08lx(%s),%08lx,%p):stub.\n",
 539                 (DWORD)hmod,(DWORD)hwnd,id,buf2,x,buf,type,arglist
 540         );
 541         /*MessageBox32A(hwnd,buf3,buf,id|0x10000);*/
 542 }
 543
 544
 545 /*************************************************************************
 546  *                       SHELL32_100                    [SHELL32.100]
 547  * walks through policy table, queries <app> key, <type> value, returns
 548  * queried (DWORD) value.
 549  * {0x00001,Explorer,NoRun}
 550  * {0x00002,Explorer,NoClose}
 551  * {0x00004,Explorer,NoSaveSettings}
 552  * {0x00008,Explorer,NoFileMenu}
 553  * {0x00010,Explorer,NoSetFolders}
 554  * {0x00020,Explorer,NoSetTaskbar}
 555  * {0x00040,Explorer,NoDesktop}
 556  * {0x00080,Explorer,NoFind}
 557  * {0x00100,Explorer,NoDrives}
 558  * {0x00200,Explorer,NoDriveAutoRun}
 559  * {0x00400,Explorer,NoDriveTypeAutoRun}
 560  * {0x00800,Explorer,NoNetHood}
 561  * {0x01000,Explorer,NoStartBanner}
 562  * {0x02000,Explorer,RestrictRun}
 563  * {0x04000,Explorer,NoPrinterTabs}
 564  * {0x08000,Explorer,NoDeletePrinter}
 565  * {0x10000,Explorer,NoAddPrinter}
 566  * {0x20000,Explorer,NoStartMenuSubFolders}
 567  * {0x40000,Explorer,MyDocsOnNet}
 568  * {0x80000,WinOldApp,NoRealMode}
 569  */
 570 DWORD WINAPI SHELL32_100(DWORD pol) {
 571         HKEY    xhkey;
 572
 573         FIXME(shell,"(%08lx):stub.\n",pol);
 574         if (RegOpenKey32A(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey))
 575                 return 0;
 576         /* FIXME: do nothing for now, just return 0 (== "allowed") */
 577         RegCloseKey(xhkey);
 578         return 0;
 579
 580 }
 581
 582 /*************************************************************************
 583  *                       SHELL32_152                    [SHELL32.152]
 584  * itemlist_length
 585  */
 586 DWORD WINAPI SHELL32_152(LPITEMIDLIST iil) {
 587         LPSHITEMID      si;
 588         DWORD           len;
 589
 590         si = &(iil->mkid);
 591         len = 2;
 592         while (si->cb) {
 593                 len     += si->cb;
 594                 si       = (LPSHITEMID)(((char*)si)+si->cb);
 595         }
 596         return len;
 597 }
 598
 599 /*************************************************************************
 600  *                      SHELL32_158                    [SHELL32.158]
 601  */
 602 LPSTR WINAPI SHELL32_158(LPSTR path,DWORD y,DWORD z) {
 603     TRACE(shell,"(%s,%08lx,%08lx)\n",path,y,z);
 604     path = SHELL32_31(path);
 605     return *path?(path+1):path;
 606 }
 607
 608 /*************************************************************************
 609  *                       SHELL32_165                    [SHELL32.165]
 610  * create_path_and_notify(...)
 611  */
 612 DWORD WINAPI SHELL32_165(DWORD x,LPCSTR path) {
 613         if (SHELL32_79(path,(LPVOID)x))
 614                 return 0;
 615         FIXME(shell,"(%08lx,%s):stub.\n",x,path);
 616         return 0;
 617 }
 618
 619 /*************************************************************************
 620  *                       SHELL32_195                    [SHELL32.195]
 621  * free_ptr() - frees memory using IMalloc
 622  */
 623 DWORD WINAPI SHELL32_195(LPVOID x) {
 624         return LocalFree32((HANDLE32)x);
 625 }
 626
 627 /*************************************************************************
 628  *                       SHELL32_196                    [SHELL32.196]
 629  * void *task_alloc(DWORD len), uses SHMalloc allocator
 630  */
 631 LPVOID WINAPI SHELL32_196(DWORD len) {
 632         return (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT); /* FIXME */
 633 }
 634
 635 /*************************************************************************
 636  *                       SHELL32_18                     [SHELL32.18]
 637  * copy_itemidlist()
 638  */
 639 LPITEMIDLIST WINAPI SHELL32_18(LPITEMIDLIST iil) {
 640         DWORD           len;
 641         LPITEMIDLIST    newiil;
 642
 643         len = SHELL32_152(iil);
 644         newiil = (LPITEMIDLIST)SHELL32_196(len);
 645         memcpy(newiil,iil,len);
 646         return newiil;
 647 }
 648
 649 /*************************************************************************
 650  *                       SHELL32_25                     [SHELL32.25]
 651  * merge_itemidlist()
 652  */
 653 LPITEMIDLIST WINAPI SHELL32_25(LPITEMIDLIST iil1,LPITEMIDLIST iil2) {
 654         DWORD           len1,len2;
 655         LPITEMIDLIST    newiil;
 656
 657         len1    = SHELL32_152(iil1)-2;
 658         len2    = SHELL32_152(iil2);
 659         newiil  = SHELL32_196(len1+len2);
 660         memcpy(newiil,iil1,len1);
 661         memcpy(((char*)newiil)+len1,iil2,len2);
 662         return newiil;
 663 }
 664
 665 /*************************************************************************
 666  *                       SHELL32_155                    [SHELL32.155]
 667  * free_check_ptr - frees memory (if not NULL) allocated by SHMalloc allocator
 668  */
 669 DWORD WINAPI SHELL32_155(LPVOID x) {
 670         if (!x)
 671                 return 0;
 672         return SHELL32_195(x);
 673 }
 674
 675 /*************************************************************************
 676  * SHELL32_85 [SHELL32.85]
 677  * unknown
 678  */
 679 DWORD WINAPI SHELL32_85(DWORD x1,DWORD x2,DWORD x3,DWORD x4) {
 680     FIXME(shell,"(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub.\n",
 681         x1,x2,x3,x4
 682     );
 683     return 0;
 684 }
 685
 686 /*************************************************************************
 687  * SHELL32_86 [SHELL32.86]
 688  * unknown
 689  */
 690 DWORD WINAPI SHELL32_86(HWND32 hwnd,DWORD x2) {
 691     FIXME(shell,"(0x%08lx,0x%08lx):stub.\n",hwnd,x2);
 692     return 0;
 693 }
 694
 695 /*************************************************************************
 696  * SHELL32_87 [SHELL32.87]
 697  * unknown
 698  */
 699 DWORD WINAPI SHELL32_87(DWORD x) {
 700     FIXME(shell,"(0x%08lx):stub.\n",x);
 701     return 0;
 702 }
 703