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 "stddebug.h"
  31 #include "debug.h"
  32 #include "winreg.h"
  33
  34 /*************************************************************************
  35  *                              SHELL32_32      [SHELL32.32]
  36  * append \ if there is none
  37  */
  38 LPSTR WINAPI SHELL32_32(LPSTR path) {
  39     int len;
  40
  41     len = lstrlen32A(path);
  42     if (len && path[len-1]!='\\') {
  43         path[len+0]='\\';
  44         path[len+1]='\0';
  45         return path+len+1;
  46     } else
  47         return path+len;
  48 }
  49
  50 /*************************************************************************
  51  *                              SHELL32_34      [SHELL32.34]
  52  * basename(char *fn);
  53  */
  54 LPSTR WINAPI SHELL32_34(LPSTR fn) {
  55     LPSTR basefn;
  56
  57     basefn = fn;
  58     while (fn[0]) {
  59         if (((fn[0]=='\\') || (fn[0]==':')) && fn[1] && fn[1]!='\\')
  60             basefn = fn+1;
  61         fn++;
  62     }
  63     return basefn;
  64 }
  65
  66 /*************************************************************************
  67  *                       SHELL32_35                     [SHELL32.35]
  68  * bool getpath(char *pathname); truncates passed argument to a valid path
  69  * returns if the string was modified or not.
  70  * "\foo\xx\foo"-> "\foo\xx"
  71  * "\"          -> "\"
  72  * "a:\foo"     -> "a:\"
  73  */
  74 DWORD WINAPI SHELL32_35(LPSTR fn) {
  75         LPSTR   x,cutplace;
  76
  77         if (!fn[0])
  78                 return 0;
  79         x=fn;
  80         cutplace = fn;
  81         while (*x) {
  82                 if (*x=='\\') {
  83                         cutplace=x++;
  84                         continue;
  85                 }
  86                 if (*x==':') {
  87                         x++;
  88                         if (*x=='\\')
  89                                 cutplace=++x;
  90                         continue; /* already x++ed */
  91                 }
  92                 x++;
  93         }
  94         if (!*cutplace)
  95                 return 0;
  96         if (cutplace==fn) {
  97                 if (fn[0]=='\\') {
  98                         if (!fn[1])
  99                                 return 0;
 100                         fn[0]='\0';
 101                         return 1;
 102                 }
 103         }
 104         *cutplace='\0';
 105         return 1;
 106 }
 107
 108 /*************************************************************************
 109  *                              SHELL32_37      [SHELL32.37]
 110  * concat_paths(char*target,const char*add);
 111  * concats "target\\add" and writes them to target
 112  */
 113 LPSTR WINAPI SHELL32_37(LPSTR target,LPSTR x1,LPSTR x2) {
 114         char    buf[260];
 115
 116         if (!x2 || !x2[0]) {
 117                 lstrcpy32A(target,x1);
 118                 return target;
 119         }
 120         lstrcpy32A(buf,x1);
 121         SHELL32_32(buf); /* append \ if not there */
 122         lstrcat32A(buf,x2);
 123         lstrcpy32A(target,buf);
 124         return target;
 125 }
 126
 127 /*************************************************************************
 128  *                              SHELL32_36      [SHELL32.36]
 129  * concat_paths(char*target,const char*add);
 130  * concats "target\\add" and writes them to target
 131  */
 132 LPSTR WINAPI SHELL32_36(LPSTR x1,LPSTR x2) {
 133         while (x2[0]=='\\') x2++;
 134         return SHELL32_37(x1,x1,x2);
 135 }
 136
 137 /*************************************************************************
 138  *                              SHELL32_52      [SHELL32.52]
 139  * look for next arg in string. handle "quoted" strings
 140  * returns pointer to argument *AFTER* the space. Or to the \0.
 141  */
 142 LPSTR WINAPI SHELL32_52(LPSTR cmdline) {
 143     BOOL32      qflag = FALSE;
 144
 145     while (*cmdline) {
 146         if ((*cmdline==' ') && !qflag)
 147                 return cmdline+1;
 148         if (*cmdline=='"')
 149                 qflag=!qflag;
 150         cmdline++;
 151     }
 152     return cmdline;
 153 }
 154
 155 /*************************************************************************
 156  *                              SHELL32_45      [SHELL32.45]
 157  * file_exists(char *fn);
 158  */
 159 BOOL32 WINAPI SHELL32_45(LPSTR fn) {
 160     if (GetFileAttributes32A(fn)==-1)
 161         return FALSE;
 162     else
 163         return TRUE;
 164 }
 165
 166 /*************************************************************************
 167  *                              SHELL32_175     [SHELL32.175]
 168  * unknown
 169  */
 170 void WINAPI SHELL32_175(DWORD x1,DWORD x2,DWORD x3,DWORD x4) {
 171     fprintf(stdnimp,"SHELL32_175(0x%08lx,0x%08lx,0x%08lx,0x%08lx),stub\n",
 172         x1,x2,x3,x4
 173     );
 174 }
 175
 176 /*************************************************************************
 177  *                              SHELL32_181     [SHELL32.181]
 178  * unknown
 179  */
 180 void WINAPI SHELL32_181(DWORD x,DWORD y) {
 181     fprintf(stderr,"SHELL32_181(0x%08lx,0x%08lx)\n",x,y);
 182 }
 183
 184 /*************************************************************************
 185  *                              SHELL32_119     [SHELL32.119]
 186  * unknown
 187  */
 188 void WINAPI SHELL32_119(LPVOID x) {
 189     fprintf(stderr,"SHELL32_119(%p),stub\n",x);
 190 }
 191
 192 /*************************************************************************
 193  *                              SHELL32_75      [SHELL32.75]
 194  * unknown
 195  */
 196 BOOL32 WINAPI SHELL32_75(LPDWORD x,LPDWORD y) {
 197     fprintf(stderr,"SHELL32_75(%p,%p),stub\n",x,y);
 198     return TRUE;
 199 }
 200
 201 DWORD WINAPI
 202 SHELL32_DllGetClassObject(REFCLSID *clsid,REFIID *iid,LPVOID *x) {
 203         char    xclsid[50],xiid[50];
 204
 205         StringFromCLSID((LPCLSID)clsid,xclsid);
 206         StringFromCLSID((LPCLSID)iid,xiid);
 207         fprintf(stderr,"SHELL32_DllGetClassObject(%s,%s,%p), STUB\n",xclsid,xiid,x);
 208         return 0;
 209 }
 210
 211 static FARPROC32 _find_moduleproc(LPSTR dllname,HMODULE32 *xhmod,LPSTR name) {
 212         HMODULE32       hmod;
 213         FARPROC32       dllunload,nameproc;
 214
 215         if (xhmod) *xhmod = 0;
 216         if (!lstrcmpi32A(SHELL32_34(dllname),"shell32.dll"))
 217                 return (FARPROC32)SHELL32_DllGetClassObject;
 218
 219         hmod = LoadLibraryEx32A(dllname,0,LOAD_WITH_ALTERED_SEARCH_PATH);
 220         if (!hmod)
 221                 return NULL;
 222         dllunload = GetProcAddress32(hmod,"DllCanUnloadNow");
 223         if (!dllunload)
 224                 if (xhmod) *xhmod = hmod;
 225         nameproc = GetProcAddress32(hmod,name);
 226         if (!nameproc) {
 227                 FreeLibrary32(hmod);
 228                 return NULL;
 229         }
 230         /* register unloadable dll with unloadproc ... */
 231         return nameproc;
 232 }
 233
 234 static DWORD _get_instance(REFCLSID clsid,LPSTR dllname,
 235         LPVOID  unknownouter,REFIID refiid,LPVOID inst
 236 ) {
 237         DWORD   WINAPI  (*dllgetclassob)(REFCLSID,REFIID,LPVOID);
 238         DWORD           hres;
 239         LPCLASSFACTORY  classfac;
 240
 241         dllgetclassob = (DWORD(*)(REFCLSID,REFIID,LPVOID))_find_moduleproc(dllname,NULL,"DllGetClassObject");
 242         if (!dllgetclassob)
 243                 return 0x80070000|GetLastError();
 244
 245         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,&classfac);
 246         if (hres<0)
 247                 return hres;
 248
 249         classfac->lpvtbl->fnCreateInstance(classfac,unknownouter,refiid,inst);
 250         classfac->lpvtbl->fnRelease(classfac);
 251         return 0;
 252 }
 253 /*************************************************************************
 254  *                              SHELL32_102     [SHELL32.102]
 255  * unknown
 256  */
 257 LRESULT WINAPI SHELL32_102(
 258         LPSTR aclsid,CLSID *clsid,LPUNKNOWN unknownouter,REFIID refiid,LPVOID inst
 259 ) {
 260         char    buffer[256],xclsid[48],xiid[48],path[260],tmodel[100];
 261         HKEY    inprockey;
 262         DWORD   pathlen,type,tmodellen;
 263         DWORD   hres;
 264
 265         StringFromCLSID(refiid,xiid);
 266
 267         if (clsid)
 268                 StringFromCLSID(clsid,xclsid);
 269         else {
 270                 if (!aclsid)
 271                     return 0x80040154;
 272                 strcpy(xclsid,aclsid);
 273         }
 274         fprintf(stderr,"SHELL32_102(%p,%s,%p,%s,%p)\n",
 275                 aclsid,xclsid,unknownouter,xiid,inst
 276         );
 277
 278         sprintf(buffer,"CLSID\\%s\\InProcServer32",xclsid);
 279         if (RegOpenKeyEx32A(HKEY_CLASSES_ROOT,buffer,0,0x02000000,&inprockey))
 280                 return _get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 281         pathlen=sizeof(path);
 282         if (RegQueryValue32A(inprockey,NULL,path,&pathlen)) {
 283                 RegCloseKey(inprockey);
 284                 return _get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 285         }
 286         fprintf(stderr,"        -> server dll is %s\n",path);
 287         tmodellen=sizeof(tmodel);
 288         type=REG_SZ;
 289         if (RegQueryValueEx32A(inprockey,"ThreadingModel",NULL,&type,tmodel,&tmodellen)) {
 290                 RegCloseKey(inprockey);
 291                 return _get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 292         }
 293         fprintf(stderr,"        -> threading model is %s\n",tmodel);
 294         hres=_get_instance(clsid,path,unknownouter,refiid,inst);
 295         if (hres<0)
 296                 hres=_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 297         RegCloseKey(inprockey);
 298         return hres;
 299 }
 300
 301
 302 /*************************************************************************
 303  *                       SHELL32_183                    [SHELL32.183]
 304  * Format and output errormessage.
 305  */
 306 void __cdecl SHELL32_183(HMODULE32 hmod,HWND32 hwnd,DWORD id,DWORD x,DWORD type,LPVOID arglist) {
 307         char    buf[100],buf2[100],*buf3;
 308         LPVOID  args = &arglist;
 309
 310         if (!LoadString32A(hmod,x,buf,100))
 311                 strcpy(buf,"Desktop");
 312         LoadString32A(hmod,id,buf2,100);
 313         /* FIXME: the varargs handling doesn't. */
 314         FormatMessage32A(0x500,buf2,0,0,&buf3,256,&args);
 315
 316         fprintf(stderr,"SHELL32_183(%08lx,%08lx,%08lx(%s),%08lx(%s),%08lx,%p),stub!\n",
 317                 (DWORD)hmod,(DWORD)hwnd,id,buf2,x,buf,type,arglist
 318         );
 319         MessageBox32A(hwnd,buf3,buf,id|0x10000);
 320 }
 321
 322
 323 /*************************************************************************
 324  *                       SHELL32_71                     [SHELL32.71]
 325  * returns internal shell values in the passed pointers
 326  */
 327 BOOL32 WINAPI SHELL32_71(LPDWORD x,LPDWORD y) {
 328
 329         fprintf(stderr,"SHELL32_71(%p,%p),stub!\n",x,y);
 330         return TRUE;
 331 }
 332
 333 /*************************************************************************
 334  *                       SHELL32_72                     [SHELL32.72]
 335  * dunno. something with icons
 336  */
 337 void WINAPI SHELL32_72(LPSTR x,DWORD y,DWORD z) {
 338         fprintf(stderr,"SHELL32_72(%s,%08lx,%08lx),stub!\n",x,y,z);
 339 }
 340
 341 /*************************************************************************
 342  *                       SHELL32_100                    [SHELL32.100]
 343  * walks through policy table, queries <app> key, <type> value, returns
 344  * queried (DWORD) value.
 345  * {0x00001,Explorer,NoRun}
 346  * {0x00002,Explorer,NoClose}
 347  * {0x00004,Explorer,NoSaveSettings}
 348  * {0x00008,Explorer,NoFileMenu}
 349  * {0x00010,Explorer,NoSetFolders}
 350  * {0x00020,Explorer,NoSetTaskbar}
 351  * {0x00040,Explorer,NoDesktop}
 352  * {0x00080,Explorer,NoFind}
 353  * {0x00100,Explorer,NoDrives}
 354  * {0x00200,Explorer,NoDriveAutoRun}
 355  * {0x00400,Explorer,NoDriveTypeAutoRun}
 356  * {0x00800,Explorer,NoNetHood}
 357  * {0x01000,Explorer,NoStartBanner}
 358  * {0x02000,Explorer,RestrictRun}
 359  * {0x04000,Explorer,NoPrinterTabs}
 360  * {0x08000,Explorer,NoDeletePrinter}
 361  * {0x10000,Explorer,NoAddPrinter}
 362  * {0x20000,Explorer,NoStartMenuSubFolders}
 363  * {0x40000,Explorer,MyDocsOnNet}
 364  * {0x80000,WinOldApp,NoRealMode}
 365  */
 366 DWORD WINAPI SHELL32_100(DWORD pol) {
 367         HKEY    xhkey;
 368
 369         fprintf(stderr,"SHELL32_100(%08lx),stub!\n",pol);
 370         if (RegOpenKey32A(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",&xhkey))
 371                 return 0;
 372         /* FIXME: do nothing for now, just return 0 (== "allowed") */
 373         RegCloseKey(xhkey);
 374         return 0;
 375
 376 }
 377
 378 DWORD WINAPI SHELL32_77(DWORD x,DWORD y,DWORD z) {
 379         fprintf(stderr,"SHELL32_77(%08lx,%08lx,%08lx),stub!\n",x,y,z);
 380         return 0;
 381 }
 382
 383 /*************************************************************************
 384  *                       SHELL32_79                     [SHELL32.79]
 385  * create_directory_and_notify(...)
 386  */
 387 DWORD WINAPI SHELL32_79(LPCSTR dir,LPVOID xvoid) {
 388         fprintf(stderr,"mkdir %s,%p\n",dir,xvoid);
 389         if (!CreateDirectory32A(dir,xvoid))
 390                 return FALSE;
 391         /* SHChangeNotify(8,1,dir,0); */
 392         return TRUE;
 393 }
 394
 395 /*************************************************************************
 396  *                       SHELL32_165                    [SHELL32.165]
 397  * create_path_and_notify(...)
 398  */
 399 DWORD WINAPI SHELL32_165(DWORD x,LPCSTR path) {
 400         if (SHELL32_79(path,(LPVOID)x))
 401                 return 0;
 402         fprintf(stderr,"SHELL32_165(%08lx,%s),stub!\n",x,path);
 403         return 0;
 404 }
 405
 406 /*************************************************************************
 407  *                       SHELL32_29                     [SHELL32.29]
 408  * is_rootdir(const char*path)
 409  */
 410 BOOL32 WINAPI SHELL32_29(LPCSTR x) {
 411         if (!lstrcmp32A(x+1,":\\"))             /* "X:\" */
 412                 return 1;
 413         if (!lstrcmp32A(x,"\\"))                /* "\" */
 414                 return 1;
 415         if (x[0]=='\\' && x[1]=='\\') {         /* UNC "\\<xx>\" */
 416                 int     foundbackslash = 0;
 417                 x=x+2;
 418                 while (*x) {
 419                         if (*x++=='\\')
 420                                 foundbackslash++;
 421                 }
 422                 if (foundbackslash<=1)  /* max 1 \ more ... */
 423                         return 1;
 424         }
 425         return 0;
 426 }
 427
 428 /*************************************************************************
 429  *                       SHELL32_152                    [SHELL32.152]
 430  * itemlist_length
 431  */
 432 DWORD WINAPI SHELL32_152(LPITEMIDLIST iil) {
 433         LPSHITEMID      si;
 434         DWORD           len;
 435
 436         si = &(iil->mkid);
 437         len = 2;
 438         while (si->cb) {
 439                 len     += si->cb;
 440                 si       = (LPSHITEMID)(((char*)si)+si->cb);
 441         }
 442         return len;
 443 }
 444
 445 /*************************************************************************
 446  *                       SHELL32_196                    [SHELL32.196]
 447  * void *task_alloc(DWORD len), uses SHMalloc allocator
 448  */
 449 LPVOID WINAPI SHELL32_196(DWORD len) {
 450         return (LPVOID)LocalAlloc32(len,LMEM_ZEROINIT); /* FIXME */
 451 }
 452
 453 /*************************************************************************
 454  *                       SHELL32_18                     [SHELL32.18]
 455  * copy_itemidlist()
 456  */
 457 LPITEMIDLIST WINAPI SHELL32_18(LPITEMIDLIST iil) {
 458         DWORD           len;
 459         LPITEMIDLIST    newiil;
 460
 461         len = SHELL32_152(iil);
 462         newiil = (LPITEMIDLIST)SHELL32_196(len);
 463         memcpy(newiil,iil,len);
 464         return newiil;
 465 }
 466
 467 /*************************************************************************
 468  *                       SHELL32_25                     [SHELL32.25]
 469  * merge_itemidlist()
 470  */
 471 LPITEMIDLIST WINAPI SHELL32_25(LPITEMIDLIST iil1,LPITEMIDLIST iil2) {
 472         DWORD           len1,len2;
 473         LPITEMIDLIST    newiil;
 474
 475         len1    = SHELL32_152(iil1)-2;
 476         len2    = SHELL32_152(iil2);
 477         newiil  = SHELL32_196(len1+len2);
 478         memcpy(newiil,iil1,len1);
 479         memcpy(((char*)newiil)+len1,iil2,len2);
 480         return newiil;
 481 }
 482
 483 /*************************************************************************
 484  *                       SHELL32_16                     [SHELL32.16]
 485  * find_lastitem_in_itemidlist()
 486  */
 487 LPSHITEMID WINAPI SHELL32_16(LPITEMIDLIST iil) {
 488         LPSHITEMID      lastsii,sii;
 489
 490         if (!iil)
 491                 return NULL;
 492         sii = &(iil->mkid);
 493         lastsii = sii;
 494         while (sii->cb) {
 495                 lastsii = sii;
 496                 sii = (LPSHITEMID)(((char*)sii)+sii->cb);
 497         }
 498         return lastsii;
 499 }
 500
 501 /*************************************************************************
 502  *                       SHELL32_195                    [SHELL32.195]
 503  * free_ptr() - frees memory using IMalloc
 504  */
 505 DWORD WINAPI SHELL32_195(LPVOID x) {
 506         return LocalFree32((HANDLE32)x);
 507 }
 508
 509 /*************************************************************************
 510  *                       SHELL32_155                    [SHELL32.155]
 511  * free_check_ptr - frees memory (if not NULL) allocated by SHMalloc allocator
 512  */
 513 DWORD WINAPI SHELL32_155(LPVOID x) {
 514         if (!x)
 515                 return 0;
 516         return SHELL32_195(x);
 517 }
 518
 519 /*************************************************************************
 520  *                       SHELL32_62                     [SHELL32.62]
 521  */
 522 DWORD WINAPI SHELL32_62(DWORD x,DWORD y,DWORD z,DWORD a) {
 523         fprintf(stderr,"SHELL32_62(%08lx,%08lx,%08lx,%08lx),stub!\n",x,y,z,a);
 524         return 0xffffffff;
 525 }