Moved undocshell.h to dlls/shell32. Removed shell16.h.
[wine] / dlls / shell32 / shell.c
1 /*
2  *                              Shell Library Functions
3  *
4  *  1998 Marcus Meissner
5  */
6
7 #include "config.h"
8
9 #include <stdlib.h>
10 #include <string.h>
11 #include <unistd.h>
12 #include <ctype.h>
13
14 #include "dlgs.h"
15 #include "shellapi.h"
16 #include "shlobj.h"
17 #include "shlwapi.h"
18 #include "windef.h"
19 #include "winerror.h"
20 #include "winreg.h"
21
22 #include "wine/winbase16.h"
23 #include "wine/winuser16.h"
24 #include "shell32_main.h"
25
26 #include "debugtools.h"
27
28 DEFAULT_DEBUG_CHANNEL(shell);
29 DECLARE_DEBUG_CHANNEL(exec);
30
31
32 typedef struct {     /* structure for dropped files */
33  WORD     wSize;
34  POINT16  ptMousePos;
35  BOOL16   fInNonClientArea;
36  /* memory block with filenames follows */
37 } DROPFILESTRUCT16, *LPDROPFILESTRUCT16;
38
39 static const char*      lpstrMsgWndCreated = "OTHERWINDOWCREATED";
40 static const char*      lpstrMsgWndDestroyed = "OTHERWINDOWDESTROYED";
41 static const char*      lpstrMsgShellActivate = "ACTIVATESHELLWINDOW";
42
43 static HWND16   SHELL_hWnd = 0;
44 static HHOOK    SHELL_hHook = 0;
45 static UINT16   uMsgWndCreated = 0;
46 static UINT16   uMsgWndDestroyed = 0;
47 static UINT16   uMsgShellActivate = 0;
48 HINSTANCE16     SHELL_hInstance = 0;
49 HINSTANCE SHELL_hInstance32;
50 static int SHELL_Attach = 0;
51
52 /***********************************************************************
53  * DllEntryPoint [SHELL.101]
54  *
55  * Initialization code for shell.dll. Automatically loads the
56  * 32-bit shell32.dll to allow thunking up to 32-bit code.
57  *
58  * RETURNS:
59  */
60 BOOL WINAPI SHELL_DllEntryPoint(DWORD Reason, HINSTANCE16 hInst,
61                                 WORD ds, WORD HeapSize, DWORD res1, WORD res2)
62 {
63     TRACE("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n",
64           Reason, hInst, ds, HeapSize, res1, res2);
65
66     switch(Reason)
67     {
68     case DLL_PROCESS_ATTACH:
69         if (SHELL_Attach++) break;
70         SHELL_hInstance = hInst;
71         if(!SHELL_hInstance32)
72         {
73             if(!(SHELL_hInstance32 = LoadLibraryA("shell32.dll")))
74             {
75                 ERR("Could not load sibling shell32.dll\n");
76                 return FALSE;
77             }
78         }
79         break;
80
81     case DLL_PROCESS_DETACH:
82         if(!--SHELL_Attach)
83         {
84             SHELL_hInstance = 0;
85             if(SHELL_hInstance32)
86                 FreeLibrary(SHELL_hInstance32);
87         }
88         break;
89     }
90     return TRUE;
91 }
92
93 /*************************************************************************
94  *                              DragAcceptFiles         [SHELL.9]
95  */
96 void WINAPI DragAcceptFiles16(HWND16 hWnd, BOOL16 b)
97 {
98   DragAcceptFiles(hWnd, b);
99 }
100
101 /*************************************************************************
102  *                              DragQueryFile           [SHELL.11]
103  */
104 UINT16 WINAPI DragQueryFile16(
105         HDROP16 hDrop,
106         WORD wFile,
107         LPSTR lpszFile,
108         WORD wLength)
109 {
110         LPSTR lpDrop;
111         UINT i = 0;
112         LPDROPFILESTRUCT16 lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop); 
113    
114         TRACE("(%04x, %x, %p, %u)\n", hDrop,wFile,lpszFile,wLength);
115     
116         if(!lpDropFileStruct) goto end;
117     
118         lpDrop = (LPSTR) lpDropFileStruct + lpDropFileStruct->wSize;
119         wFile = (wFile==0xffff) ? 0xffffffff : wFile;
120
121         while (i++ < wFile)
122         {
123           while (*lpDrop++); /* skip filename */
124           if (!*lpDrop) 
125           {
126             i = (wFile == 0xFFFFFFFF) ? i : 0; 
127             goto end;
128           }
129         }
130     
131         i = strlen(lpDrop);
132         i++;
133         if (!lpszFile ) goto end;   /* needed buffer size */
134         i = (wLength > i) ? i : wLength;
135         lstrcpynA (lpszFile,  lpDrop,  i);
136 end:
137         GlobalUnlock16(hDrop);
138         return i;
139 }
140
141 /*************************************************************************
142  *                              DragFinish              [SHELL.12]
143  */
144 void WINAPI DragFinish16(HDROP16 h)
145 {
146     TRACE("\n");
147     GlobalFree16((HGLOBAL16)h);
148 }
149
150
151 /*************************************************************************
152  *                              DragQueryPoint          [SHELL.13]
153  */
154 BOOL16 WINAPI DragQueryPoint16(HDROP16 hDrop, POINT16 *p)
155 {
156   LPDROPFILESTRUCT16 lpDropFileStruct;  
157   BOOL16           bRet;
158   TRACE("\n");
159   lpDropFileStruct = (LPDROPFILESTRUCT16) GlobalLock16(hDrop);
160   
161   memcpy(p,&lpDropFileStruct->ptMousePos,sizeof(POINT16));
162   bRet = lpDropFileStruct->fInNonClientArea;
163   
164   GlobalUnlock16(hDrop);
165   return bRet;
166 }
167
168 /*************************************************************************
169  *      SHELL_FindExecutable [Internal]
170  *
171  * Utility for code sharing between FindExecutable and ShellExecute
172  */
173 HINSTANCE SHELL_FindExecutable( LPCSTR lpFile, 
174                                          LPCSTR lpOperation,
175                                          LPSTR lpResult)
176 { char *extension = NULL; /* pointer to file extension */
177     char tmpext[5];         /* local copy to mung as we please */
178     char filetype[256];     /* registry name for this filetype */
179     LONG filetypelen=256;   /* length of above */
180     char command[256];      /* command from registry */
181     LONG commandlen=256;    /* This is the most DOS can handle :) */
182     char buffer[256];       /* Used to GetProfileString */
183     HINSTANCE retval=31;  /* default - 'No association was found' */
184     char *tok;              /* token pointer */
185     int i;                  /* random counter */
186     char xlpFile[256] = ""; /* result of SearchPath */
187
188   TRACE("%s\n", (lpFile != NULL?lpFile:"-") );
189
190     lpResult[0]='\0'; /* Start off with an empty return string */
191
192     /* trap NULL parameters on entry */
193     if (( lpFile == NULL ) || ( lpResult == NULL ) || ( lpOperation == NULL ))
194   { WARN_(exec)("(lpFile=%s,lpResult=%s,lpOperation=%s): NULL parameter\n",
195            lpFile, lpOperation, lpResult);
196         return 2; /* File not found. Close enough, I guess. */
197     }
198
199     if (SearchPathA( NULL, lpFile,".exe",sizeof(xlpFile),xlpFile,NULL))
200   { TRACE("SearchPathA returned non-zero\n");
201         lpFile = xlpFile;
202     }
203
204     /* First thing we need is the file's extension */
205     extension = strrchr( xlpFile, '.' ); /* Assume last "." is the one; */
206                                         /* File->Run in progman uses */
207                                         /* .\FILE.EXE :( */
208   TRACE("xlpFile=%s,extension=%s\n", xlpFile, extension);
209
210     if ((extension == NULL) || (extension == &xlpFile[strlen(xlpFile)]))
211   { WARN("Returning 31 - No association\n");
212         return 31; /* no association */
213     }
214
215     /* Make local copy & lowercase it for reg & 'programs=' lookup */
216     lstrcpynA( tmpext, extension, 5 );
217     CharLowerA( tmpext );
218   TRACE("%s file\n", tmpext);
219     
220     /* Three places to check: */
221     /* 1. win.ini, [windows], programs (NB no leading '.') */
222     /* 2. Registry, HKEY_CLASS_ROOT\<filetype>\shell\open\command */
223     /* 3. win.ini, [extensions], extension (NB no leading '.' */
224     /* All I know of the order is that registry is checked before */
225     /* extensions; however, it'd make sense to check the programs */
226     /* section first, so that's what happens here. */
227
228     /* See if it's a program - if GetProfileString fails, we skip this
229      * section. Actually, if GetProfileString fails, we've probably
230      * got a lot more to worry about than running a program... */
231     if ( GetProfileStringA("windows", "programs", "exe pif bat com",
232                                                   buffer, sizeof(buffer)) > 0 )
233   { for (i=0;i<strlen(buffer); i++) buffer[i]=tolower(buffer[i]);
234
235                 tok = strtok(buffer, " \t"); /* ? */
236                 while( tok!= NULL)
237                   {
238                         if (strcmp(tok, &tmpext[1])==0) /* have to skip the leading "." */
239                           {
240                                 strcpy(lpResult, xlpFile);
241                                 /* Need to perhaps check that the file has a path
242                                  * attached */
243         TRACE("found %s\n", lpResult);
244         return 33;
245
246                 /* Greater than 32 to indicate success FIXME According to the
247                  * docs, I should be returning a handle for the
248                  * executable. Does this mean I'm supposed to open the
249                  * executable file or something? More RTFM, I guess... */
250                           }
251                         tok=strtok(NULL, " \t");
252                   }
253           }
254
255     /* Check registry */
256     if (RegQueryValue16( HKEY_CLASSES_ROOT, tmpext, filetype,
257                          &filetypelen ) == ERROR_SUCCESS )
258     {
259         filetype[filetypelen]='\0';
260         TRACE("File type: %s\n", filetype);
261
262         /* Looking for ...buffer\shell\lpOperation\command */
263         strcat( filetype, "\\shell\\" );
264         strcat( filetype, lpOperation );
265         strcat( filetype, "\\command" );
266         
267         if (RegQueryValue16( HKEY_CLASSES_ROOT, filetype, command,
268                              &commandlen ) == ERROR_SUCCESS )
269         {
270             LPSTR tmp;
271             char param[256];
272             LONG paramlen = 256;
273
274
275             /* Get the parameters needed by the application 
276                from the associated ddeexec key */ 
277             tmp = strstr(filetype,"command");
278             tmp[0] = '\0';
279             strcat(filetype,"ddeexec");
280
281             if(RegQueryValue16( HKEY_CLASSES_ROOT, filetype, param,&paramlen ) == ERROR_SUCCESS)
282             {
283               strcat(command," ");
284               strcat(command,param);
285               commandlen += paramlen;
286             }
287
288             /* Is there a replace() function anywhere? */
289             command[commandlen]='\0';
290             strcpy( lpResult, command );
291             tok=strstr( lpResult, "%1" );
292             if (tok != NULL)
293             {
294                 tok[0]='\0'; /* truncate string at the percent */
295                 strcat( lpResult, xlpFile ); /* what if no dir in xlpFile? */
296                 tok=strstr( command, "%1" );
297                 if ((tok!=NULL) && (strlen(tok)>2))
298                 {
299                     strcat( lpResult, &tok[2] );
300                 }
301             }
302             retval=33; /* FIXME see above */
303         }
304     }
305     else /* Check win.ini */
306     {
307         /* Toss the leading dot */
308         extension++;
309         if ( GetProfileStringA( "extensions", extension, "", command,
310                                   sizeof(command)) > 0)
311           {
312                 if (strlen(command)!=0)
313                   {
314                         strcpy( lpResult, command );
315                         tok=strstr( lpResult, "^" ); /* should be ^.extension? */
316                         if (tok != NULL)
317                           {
318                                 tok[0]='\0';
319                                 strcat( lpResult, xlpFile ); /* what if no dir in xlpFile? */
320                                 tok=strstr( command, "^" ); /* see above */
321                                 if ((tok != NULL) && (strlen(tok)>5))
322                                   {
323                                         strcat( lpResult, &tok[5]);
324                                   }
325                           }
326                         retval=33; /* FIXME - see above */
327                   }
328           }
329         }
330
331     TRACE("returning %s\n", lpResult);
332     return retval;
333 }
334
335 /*************************************************************************
336  *                              ShellExecute            [SHELL.20]
337  */
338 HINSTANCE16 WINAPI ShellExecute16( HWND16 hWnd, LPCSTR lpOperation,
339                                    LPCSTR lpFile, LPCSTR lpParameters,
340                                    LPCSTR lpDirectory, INT16 iShowCmd )
341 {   HINSTANCE16 retval=31;
342     char old_dir[1024];
343     char cmd[1024] = "";
344
345     TRACE("(%04x,'%s','%s','%s','%s',%x)\n",
346                 hWnd, lpOperation ? lpOperation:"<null>", lpFile ? lpFile:"<null>",
347                 lpParameters ? lpParameters : "<null>", 
348                 lpDirectory ? lpDirectory : "<null>", iShowCmd);
349
350     if (lpFile==NULL) return 0; /* should not happen */
351     if (lpOperation==NULL) /* default is open */
352       lpOperation="open";
353
354     if (lpDirectory)
355     { GetCurrentDirectoryA( sizeof(old_dir), old_dir );
356         SetCurrentDirectoryA( lpDirectory );
357     }
358
359     /* First try to execute lpFile with lpParameters directly */ 
360     strcpy(cmd,lpFile);
361     strcat(cmd,lpParameters ? lpParameters : "");
362
363     retval = WinExec16( cmd, iShowCmd );
364
365     /* Unable to execute lpFile directly
366        Check if we can match an application to lpFile */
367     if(retval < 32)
368     { 
369       cmd[0] = '\0';
370       retval = SHELL_FindExecutable( lpFile, lpOperation, cmd );
371
372       if (retval > 32)  /* Found */
373       {
374         if (lpParameters)
375         {
376             strcat(cmd," ");
377             strcat(cmd,lpParameters);
378         }
379         retval = WinExec16( cmd, iShowCmd );
380       }
381       else if(PathIsURLA((LPSTR)lpFile))    /* File not found, check for URL */
382       {
383         char lpstrProtocol[256];
384         LONG cmdlen = 512;
385         LPSTR lpstrRes;
386         INT iSize;
387       
388         lpstrRes = strchr(lpFile,':');
389         iSize = lpstrRes - lpFile;
390         
391         /* Looking for ...protocol\shell\lpOperation\command */
392         strncpy(lpstrProtocol,lpFile,iSize);
393         lpstrProtocol[iSize]='\0';
394         strcat( lpstrProtocol, "\\shell\\" );
395         strcat( lpstrProtocol, lpOperation );
396         strcat( lpstrProtocol, "\\command" );
397         
398         /* Remove File Protocol from lpFile */
399         /* In the case file://path/file     */
400         if(!strncasecmp(lpFile,"file",iSize))
401         {
402           lpFile += iSize;
403           while(*lpFile == ':') lpFile++;
404         }
405         
406
407         /* Get the application for the protocol and execute it */
408         if (RegQueryValue16( HKEY_CLASSES_ROOT, lpstrProtocol, cmd,
409                              &cmdlen ) == ERROR_SUCCESS )
410         {
411             LPSTR tok;
412             LPSTR tmp;
413             char param[256] = "";
414             LONG paramlen = 256;
415
416             /* Get the parameters needed by the application 
417                from the associated ddeexec key */ 
418             tmp = strstr(lpstrProtocol,"command");
419             tmp[0] = '\0';
420             strcat(lpstrProtocol,"ddeexec");
421
422             if(RegQueryValue16( HKEY_CLASSES_ROOT, lpstrProtocol, param,&paramlen ) == ERROR_SUCCESS)
423             {
424               strcat(cmd," ");
425               strcat(cmd,param);
426               cmdlen += paramlen;
427             }
428             
429             /* Is there a replace() function anywhere? */
430             cmd[cmdlen]='\0';
431
432             tok=strstr( cmd, "%1" );
433             if (tok != NULL)
434             {
435                 tok[0]='\0'; /* truncate string at the percent */
436                 strcat( cmd, lpFile ); /* what if no dir in xlpFile? */
437                 tok=strstr( cmd, "%1" );
438                 if ((tok!=NULL) && (strlen(tok)>2))
439                 {
440                     strcat( cmd, &tok[2] );
441                 }
442             }
443  
444             retval = WinExec16( cmd, iShowCmd );
445         }
446       }
447     /* Check if file specified is in the form www.??????.*** */
448       else if(!strncasecmp(lpFile,"www",3))
449       {
450         /* if so, append lpFile http:// and call ShellExecute */ 
451         char lpstrTmpFile[256] = "http://" ;
452         strcat(lpstrTmpFile,lpFile);
453         retval = ShellExecuteA(hWnd,lpOperation,lpstrTmpFile,NULL,NULL,0);
454       }
455     }
456     if (lpDirectory)
457       SetCurrentDirectoryA( old_dir );
458     return retval;
459 }
460
461 /*************************************************************************
462  *             FindExecutable   (SHELL.21)
463  */
464 HINSTANCE16 WINAPI FindExecutable16( LPCSTR lpFile, LPCSTR lpDirectory,
465                                      LPSTR lpResult )
466 { return (HINSTANCE16)FindExecutableA( lpFile, lpDirectory, lpResult );
467 }
468
469
470 /*************************************************************************
471  *             AboutDlgProc   (SHELL.33)
472  */
473 BOOL16 WINAPI AboutDlgProc16( HWND16 hWnd, UINT16 msg, WPARAM16 wParam,
474                                LPARAM lParam )
475 { return AboutDlgProc( hWnd, msg, wParam, lParam );
476 }
477
478
479 /*************************************************************************
480  *             ShellAbout   (SHELL.22)
481  */
482 BOOL16 WINAPI ShellAbout16( HWND16 hWnd, LPCSTR szApp, LPCSTR szOtherStuff,
483                             HICON16 hIcon )
484 { return ShellAboutA( hWnd, szApp, szOtherStuff, hIcon );
485 }
486
487 /*************************************************************************
488  *                      InternalExtractIcon             [SHELL.39]
489  *
490  * This abortion is called directly by Progman
491  */
492 HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16 hInstance,
493                                      LPCSTR lpszExeFileName, UINT16 nIconIndex, WORD n )
494 {
495     HGLOBAL16 hRet = 0;
496     HICON16 *RetPtr = NULL;
497     OFSTRUCT ofs;
498     HFILE hFile;
499
500         TRACE("(%04x,file %s,start %d,extract %d\n", 
501                        hInstance, lpszExeFileName, nIconIndex, n);
502
503         if( !n )
504           return 0;
505
506         hFile = OpenFile( lpszExeFileName, &ofs, OF_READ );
507
508         hRet = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, sizeof(HICON16)*n);
509         RetPtr = (HICON16*)GlobalLock16(hRet);
510
511         if (hFile == HFILE_ERROR)
512         { /* not found - load from builtin module if available */
513           HINSTANCE hInst = (HINSTANCE)LoadLibrary16(lpszExeFileName);
514
515           if (hInst < 32) /* hmm, no Win16 module - try Win32 :-) */
516             hInst = LoadLibraryA(lpszExeFileName);
517           if (hInst)
518           {
519             int i;
520             for (i=nIconIndex; i < nIconIndex + n; i++)
521               RetPtr[i-nIconIndex] =
522                       (HICON16)LoadIconA(hInst, (LPCSTR)(DWORD)i);
523             FreeLibrary(hInst);
524             return hRet;
525           }
526           GlobalFree16( hRet );
527           return 0;
528         }
529
530         if (nIconIndex == (UINT16)-1)  /* get number of icons */
531         {
532             RetPtr[0] = PrivateExtractIconsA( ofs.szPathName, -1, 0, 0, NULL, 0, 0, 0 );
533         }
534         else
535         {
536             HRESULT res;
537             HICON *icons;
538             icons = HeapAlloc( GetProcessHeap(), 0, n * sizeof(*icons) );
539             res = PrivateExtractIconsA( ofs.szPathName, nIconIndex,
540                                         GetSystemMetrics(SM_CXICON),
541                                         GetSystemMetrics(SM_CYICON),
542                                         icons, 0, n, 0 );
543             if (!res)
544             {
545                 int i;
546                 for (i = 0; i < n; i++) RetPtr[i] = (HICON16)icons[i];
547             }
548             else
549             {
550                 GlobalFree16( hRet );
551                 hRet = 0;
552             }
553             HeapFree( GetProcessHeap(), 0, icons );
554         }
555         return hRet;
556 }
557
558 /*************************************************************************
559  *             ExtractIcon   (SHELL.34)
560  */
561 HICON16 WINAPI ExtractIcon16( HINSTANCE16 hInstance, LPCSTR lpszExeFileName,
562         UINT16 nIconIndex )
563 {   TRACE("\n");
564     return ExtractIconA( hInstance, lpszExeFileName, nIconIndex );
565 }
566
567 /*************************************************************************
568  *             ExtractIconEx   (SHELL.40)
569  */
570 HICON16 WINAPI ExtractIconEx16(
571         LPCSTR lpszFile, INT16 nIconIndex, HICON16 *phiconLarge,
572         HICON16 *phiconSmall, UINT16 nIcons
573 ) {
574     HICON       *ilarge,*ismall;
575     UINT16      ret;
576     int         i;
577
578     if (phiconLarge)
579         ilarge = (HICON*)HeapAlloc(GetProcessHeap(),0,nIcons*sizeof(HICON));
580     else
581         ilarge = NULL;
582     if (phiconSmall)
583         ismall = (HICON*)HeapAlloc(GetProcessHeap(),0,nIcons*sizeof(HICON));
584     else
585         ismall = NULL;
586     ret = ExtractIconExA(lpszFile,nIconIndex,ilarge,ismall,nIcons);
587     if (ilarge) {
588         for (i=0;i<nIcons;i++)
589             phiconLarge[i]=ilarge[i];
590         HeapFree(GetProcessHeap(),0,ilarge);
591     }
592     if (ismall) {
593         for (i=0;i<nIcons;i++)
594             phiconSmall[i]=ismall[i];
595         HeapFree(GetProcessHeap(),0,ismall);
596     }
597     return ret;
598 }
599
600 /*************************************************************************
601  *                              ExtractAssociatedIcon   [SHELL.36]
602  * 
603  * Return icon for given file (either from file itself or from associated
604  * executable) and patch parameters if needed.
605  */
606 HICON16 WINAPI ExtractAssociatedIcon16(HINSTANCE16 hInst, LPSTR lpIconPath, LPWORD lpiIcon)
607 {       HICON16 hIcon;
608         WORD wDummyIcon = 0;
609
610         TRACE("\n");
611
612         if(lpiIcon == NULL)
613             lpiIcon = &wDummyIcon;
614
615         hIcon = ExtractIcon16(hInst, lpIconPath, *lpiIcon);
616
617         if( hIcon < 2 )
618         { if( hIcon == 1 ) /* no icons found in given file */
619           { char  tempPath[0x80];
620             UINT16  uRet = FindExecutable16(lpIconPath,NULL,tempPath);
621
622             if( uRet > 32 && tempPath[0] )
623             { strcpy(lpIconPath,tempPath);
624               hIcon = ExtractIcon16(hInst, lpIconPath, *lpiIcon);
625               if( hIcon > 2 ) 
626                 return hIcon;
627             }
628             else hIcon = 0;
629           }
630
631           if( hIcon == 1 ) 
632             *lpiIcon = 2;   /* MSDOS icon - we found .exe but no icons in it */
633           else
634             *lpiIcon = 6;   /* generic icon - found nothing */
635
636           GetModuleFileName16(hInst, lpIconPath, 0x80);
637           hIcon = LoadIconA( hInst, MAKEINTRESOURCEA(*lpiIcon));
638         }
639         return hIcon;
640 }
641
642 /*************************************************************************
643  *                              ExtractAssociatedIconA (SHELL32.@)
644  * 
645  * Return icon for given file (either from file itself or from associated
646  * executable) and patch parameters if needed.
647  */
648 HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
649 {       TRACE("\n");
650         return ExtractAssociatedIcon16(hInst,lpIconPath,lpiIcon);
651 }
652
653 /*************************************************************************
654  *                              FindEnvironmentString   [SHELL.38]
655  *
656  * Returns a pointer into the DOS environment... Ugh.
657  */
658 LPSTR SHELL_FindString(LPSTR lpEnv, LPCSTR entry)
659 { UINT16 l;
660
661   TRACE("\n");
662
663   l = strlen(entry); 
664   for( ; *lpEnv ; lpEnv+=strlen(lpEnv)+1 )
665   { if( strncasecmp(lpEnv, entry, l) ) 
666       continue;
667         if( !*(lpEnv+l) )
668             return (lpEnv + l);                 /* empty entry */
669         else if ( *(lpEnv+l)== '=' )
670             return (lpEnv + l + 1);
671     }
672     return NULL;
673 }
674
675 /**********************************************************************/
676
677 SEGPTR WINAPI FindEnvironmentString16(LPSTR str)
678 { SEGPTR  spEnv;
679   LPSTR lpEnv,lpString;
680   TRACE("\n");
681     
682   spEnv = GetDOSEnvironment16();
683
684   lpEnv = MapSL(spEnv);
685   lpString = (spEnv)?SHELL_FindString(lpEnv, str):NULL; 
686
687     if( lpString )              /*  offset should be small enough */
688         return spEnv + (lpString - lpEnv);
689     return (SEGPTR)NULL;
690 }
691
692 /*************************************************************************
693  *                              DoEnvironmentSubst      [SHELL.37]
694  *
695  * Replace %KEYWORD% in the str with the value of variable KEYWORD
696  * from "DOS" environment.
697  */
698 DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
699 {
700   LPSTR   lpEnv = MapSL(GetDOSEnvironment16());
701   LPSTR   lpBuffer = (LPSTR)HeapAlloc( GetProcessHeap(), 0, length);
702   LPSTR   lpstr = str;
703   LPSTR   lpbstr = lpBuffer;
704
705   CharToOemA(str,str);
706
707   TRACE("accept %s\n", str);
708
709   while( *lpstr && lpbstr - lpBuffer < length )
710    {
711      LPSTR lpend = lpstr;
712
713      if( *lpstr == '%' )
714        {
715           do { lpend++; } while( *lpend && *lpend != '%' );
716           if( *lpend == '%' && lpend - lpstr > 1 )      /* found key */
717             {
718                LPSTR lpKey;
719               *lpend = '\0';  
720                lpKey = SHELL_FindString(lpEnv, lpstr+1);
721                if( lpKey )                              /* found key value */
722                  {
723                    int l = strlen(lpKey);
724
725                    if( l > length - (lpbstr - lpBuffer) - 1 )
726                      {
727            WARN("-- Env subst aborted - string too short\n");
728                       *lpend = '%';
729                        break;
730                      }
731                    strcpy(lpbstr, lpKey);
732                    lpbstr += l;
733                  }
734                else break;
735               *lpend = '%';
736                lpstr = lpend + 1;
737             }
738           else break;                                   /* back off and whine */
739
740           continue;
741        } 
742
743      *lpbstr++ = *lpstr++;
744    }
745
746  *lpbstr = '\0';
747   if( lpstr - str == strlen(str) )
748     {
749       strncpy(str, lpBuffer, length);
750       length = 1;
751     }
752   else
753       length = 0;
754
755   TRACE("-- return %s\n", str);
756
757   OemToCharA(str,str);
758   HeapFree( GetProcessHeap(), 0, lpBuffer);
759
760   /*  Return str length in the LOWORD
761    *  and 1 in HIWORD if subst was successful.
762    */
763  return (DWORD)MAKELONG(strlen(str), length);
764 }
765
766 /*************************************************************************
767  *                              ShellHookProc           [SHELL.103]
768  * System-wide WH_SHELL hook.
769  */
770 LRESULT WINAPI ShellHookProc16(INT16 code, WPARAM16 wParam, LPARAM lParam)
771 {
772     TRACE("%i, %04x, %08x\n", code, wParam, 
773                                                       (unsigned)lParam );
774     if( SHELL_hHook && SHELL_hWnd )
775     {
776         UINT16  uMsg = 0;
777         switch( code )
778         {
779             case HSHELL_WINDOWCREATED:          uMsg = uMsgWndCreated;   break;
780             case HSHELL_WINDOWDESTROYED:        uMsg = uMsgWndDestroyed; break;
781             case HSHELL_ACTIVATESHELLWINDOW:    uMsg = uMsgShellActivate;
782         }
783         PostMessageA( SHELL_hWnd, uMsg, wParam, 0 );
784     }
785     return CallNextHookEx16( WH_SHELL, code, wParam, lParam );
786 }
787
788 /*************************************************************************
789  *                              RegisterShellHook       [SHELL.102]
790  */
791 BOOL WINAPI RegisterShellHook16(HWND16 hWnd, UINT16 uAction)
792
793     TRACE("%04x [%u]\n", hWnd, uAction );
794
795     switch( uAction )
796     { 
797     case 2:  /* register hWnd as a shell window */
798         if( !SHELL_hHook )
799         { 
800             HMODULE16 hShell = GetModuleHandle16( "SHELL" );
801             HOOKPROC16 hookProc = (HOOKPROC16)GetProcAddress16( hShell, (LPCSTR)103 );
802             SHELL_hHook = SetWindowsHookEx16( WH_SHELL, hookProc, hShell, 0 );
803             if ( SHELL_hHook )
804             { 
805                 uMsgWndCreated = RegisterWindowMessageA( lpstrMsgWndCreated );
806                 uMsgWndDestroyed = RegisterWindowMessageA( lpstrMsgWndDestroyed );
807                 uMsgShellActivate = RegisterWindowMessageA( lpstrMsgShellActivate );
808             } 
809             else 
810                 WARN("-- unable to install ShellHookProc()!\n");
811         }
812
813         if ( SHELL_hHook )
814             return ((SHELL_hWnd = hWnd) != 0);
815         break;
816
817     default:
818         WARN("-- unknown code %i\n", uAction );
819         SHELL_hWnd = 0; /* just in case */
820     }
821     return FALSE;
822 }
823
824
825 /***********************************************************************
826  *           DriveType   (SHELL.262)
827  */
828 UINT16 WINAPI DriveType16( UINT16 drive )
829 {
830     UINT ret;
831     char path[] = "A:\\";
832     path[0] += drive;
833     ret = GetDriveTypeA(path);
834     switch(ret)  /* some values are not supported in Win16 */
835     {
836     case DRIVE_CDROM:
837         ret = DRIVE_REMOTE;
838         break;
839     case DRIVE_NO_ROOT_DIR:
840         ret = DRIVE_UNKNOWN;
841         break;
842     }
843     return ret;
844 }