Context Navigation

source: trunk/src/win32k/ldr/myldrOpen.cpp@ 6496

Visit:

Last change on this file since 6496 was 6009, checked in by bird, 24 years ago
Close file on error.
File size: 43.1 KB

Line
1	/* $Id: myldrOpen.cpp,v 1.16 2001-06-14 12:19:41 bird Exp $
2	*
3	* myldrOpen - ldrOpen.
4	*
5	* Copyright (c) 1998-2001 knut st. osmundsen <knut.stange.osmundsen@mynd.no>
6	*
7	* Project Odin Software License can be found in LICENSE.TXT
8	*
9	*/
10
11
12	/*******************************************************************************
13	* Defined Constants And Macros *
14	*******************************************************************************/
15	#define INCL_DOSERRORS
16	#define INCL_NOPMAPI
17
18	#define INCL_OS2KRNL_IO
19	#define INCL_OS2KRNL_TCB
20	#define INCL_OS2KRNL_SEM
21	#define INCL_OS2KRNL_SEC
22	#define INCL_OS2KRNL_LDR
23
24	/*******************************************************************************
25	* Header Files *
26	*******************************************************************************/
27	#include <os2.h>
28
29	#include "devSegDf.h" /* Win32k segment definitions. */
30	#include "rmalloc.h"
31	#include "malloc.h"
32	#include <memory.h>
33	#include <stdlib.h>
34	#include <string.h>
35	#include <stdarg.h>
36
37	#include "log.h"
38	#include "avl.h"
39	#include "options.h"
40	#include <peexe.h>
41	#include <exe386.h>
42	#include "elf.h"
43	#include "OS2Krnl.h"
44	#include "dev32.h"
45	#include "ldr.h"
46	#include "ModuleBase.h"
47	#include "pe2lx.h"
48	#include "myExecPgm.h"
49	#include "env.h"
50	#include "vprintf.h" /* Make 100% sure we have va_start. */
51
52
53
54	/*******************************************************************************
55	* Internal Functions *
56	*******************************************************************************/
57	/* static */ APIRET AddArgsToFront(int cArgs, ...);
58	/* static / APIRET SetExecName(const char pszExeName);
59	/* static / APIRET OpenPATH(PSFN phFile, char pszFilename, PULONG pfl);
60
61
62	/**
63	* ldrOpen override.
64	* @returns Return code.
65	* @param phFile Pointer to file handler. Holds filehandle on output.
66	* @param pszFilename Pointer to filename.
67	* @parma pfl Pointer to some flags.
68	*/
69	ULONG LDRCALL myldrOpen(PSFN phFile, PSZ pszFilename, PULONG pfl)
70	{
71	static int cNesting = 0; /* This is an variable which hold the nesting */
72	/* level of this function. This is useful */
73	/* when we call it recurcively. */
74	/* The maximum nesting level is currently 3. */
75	/* When the maximum depth has been reached */
76	/* we'll not intercept loading any longer! */
77	ULONG rc; /* Return value. */
78
79	/** @sketch
80	* Try open the file (that's why this function is called)
81	* Apply Extention fix if this is requested.
82	*/
83	if (fldrOpenExtentionFix)
84	{
85	int cchFilename = strlen(pszFilename);
86	pszFilename[cchFilename - 4] = '\0';
87	rc = ldrOpen(phFile, pszFilename, pfl);
88	if (rc != NO_ERROR)
89	{
90	pszFilename[cchFilename - 4] = '.';
91	rc = ldrOpen(phFile, pszFilename, pfl);
92	}
93	}
94	else
95	rc = ldrOpen(phFile, pszFilename, pfl);
96
97	if (rc == NO_ERROR)
98	kprintf(("myldrOpen-%d: phFile=%#.4x, flags=%#.8x, pszFn=%s\n", cNesting, *phFile, pfl, pszFilename));
99
100
101	/** @sketch
102	* Are we to intercept the loading?
103	* - If open were successful.
104	* - And Not too deep nesting.
105	* - And that this isn't an unsupported load.
106	* - And one of the loaders are enabled.
107	*/
108	if (rc == NO_ERROR
109	&& cNesting < 3
110	&& !isLdrStateLoadingUnsupported()
111	&& isAnyLoaderEnabled()
112	)
113	{
114	union _u_ReadBufferPointers /* Read buffer pointer(s). */
115	{
116	char pach; / Pointer to the buffer as char. */
117	unsigned long pul; / Pointer to the buffer as unsigned long. */
118	PIMAGE_DOS_HEADER pMzHdr; /* Use the buffer as a dosheader. */
119	PIMAGE_NT_HEADERS pNtHdrs; /* Use the buffer as a NT header. */
120	} u1;
121	unsigned cbFile; /* Filesize (0xffffffff if call to SftFileSize failed - should _never_ happen though) */
122	unsigned cbRead; /* Amount of the buffer which contains valid data. */
123	char * psz; /* Multipurpose string pointer no.1. */
124	char * psz2; /* Multipurpose string pointer no.2. */
125	char * psz3; /* Multipurpose string pointer no.3. */
126
127	/** @sketch
128	* Allocate read buffer from resident heap.
129	* IF this fails THEN we'll simply return NO_ERROR.
130	*/
131	u1.pach = (char*)rmalloc(640);
132	if (u1.pach == NULL)
133	{
134	kprintf(("myldrOpen-%d: rmalloc(640) failed\n", cNesting));
135	goto ret;
136	}
137
138
139	/** @sketch
140	* Increment nesting level.
141	*/
142	cNesting++;
143
144
145	/** @sketch
146	* Get the filesize. On failure filesize is set to ~0.
147	*/
148	rc = SftFileSize(*phFile, (PULONG)SSToDS(&cbFile));
149	if (rc != NO_ERROR)
150	{
151	kprintf(("myldrOpen-%d: SftFileSize failed with rc=%d\n", cNesting, rc));
152	cbFile = (unsigned)~0;
153	}
154
155
156	/** @sketch
157	* Read the size of a DOS (ie. MZ) header.
158	* IF successful and more stuff in file THEN
159	* See if this is an recognizable module binary format:
160	*/
161	cbRead = min(sizeof(IMAGE_DOS_HEADER), cbFile);
162	rc = ldrRead(*phFile, 0UL, u1.pMzHdr, 0UL, cbRead, NULL);
163	if (rc == NO_ERROR && cbRead < cbFile)
164	{
165	/** @sketch
166	* If LX header just give up at once.
167	*/
168	if (u1.pMzHdr->e_magic == E32MAGIC)
169	goto cleanup;
170
171	/** @sketch
172	* IF PE or MZ header THEN
173	*/
174	if (u1.pMzHdr->e_magic == IMAGE_DOS_SIGNATURE
175	\|\| u1.pNtHdrs->Signature == IMAGE_NT_SIGNATURE)
176	{
177	ULONG offPe; /* Offset to PE header. */
178
179	/** @sketch
180	* ---
181	* We now known that this is file has a MZ or a PE header. If it's
182	* a MZ header, we might end up with no "New" header or the "New"
183	* header might turn out to be a NE, LE, or LX header. I any of
184	* these non PE headers occur OS/2 will take care of it, we'll do nothing.
185	* ---
186	* IF PE loading is disable or MZ header and e_lfanew is invalid THEN
187	* return (successfully) to the caller.
188	* ENDIF
189	* (Find the offset of the PE header while testing (offPe).)
190	*/
191	if (isPELoaderDisabled())
192	goto cleanup;
193	if (u1.pMzHdr->e_magic == IMAGE_DOS_SIGNATURE)
194	{
195	offPe = u1.pMzHdr->e_lfanew;
196	if (offPe < sizeof(IMAGE_DOS_HEADER) \|\| offPe > 0x04000000UL)
197	goto cleanup;
198	}
199	else
200	offPe = 0;
201
202
203	/** @sketch
204	* Read the PE header.
205	* If the read failes or not PE signature, there isn't anything for us to do.
206	*/
207	rc = ldrRead(*phFile, offPe, u1.pach, 0UL, sizeof(IMAGE_NT_HEADERS), NULL);
208	if (rc != NO_ERROR \|\| u1.pNtHdrs->Signature != IMAGE_NT_SIGNATURE)
209	goto cleanup_noerror;
210
211
212	/** @sketch
213	* PE signature found!
214	*/
215	kprintf(("myldrOpen-%d: PE executable...\n", cNesting));
216
217
218	/** @sketch
219	* Use Pe2Lx?
220	* - When Pe2Lx flag is set
221	* - When the MIXED flag is set and the image isn't an executable
222	* above the first 64MB private limit without relocations
223	*/
224	if (isPe2LxLoaderEnabled()
225	\|\| (isMixedPeLoaderEnabled()
226	&& ((u1.pNtHdrs->FileHeader.Characteristics & IMAGE_FILE_DLL)
227	\|\| !(u1.pNtHdrs->FileHeader.Characteristics & IMAGE_FILE_RELOCS_STRIPPED)
228	\|\| u1.pNtHdrs->OptionalHeader.ImageBase < 0x04000000UL /* 64MB */
229	)
230	)
231	)
232	{ /** @sketch
233	* Pe2Lx (Ring0 of course)
234	* - Create a Pe2Lx class,
235	* - initiate it
236	* - Add the module to the module tree so we may find it later...
237	* - Set the (file)handle state to 'our'.
238	* - Set pExeModule to module pointer and loaderstate to our exe.
239	*/
240	Pe2Lx * pPe2Lx = new Pe2Lx(*phFile);
241	if (pPe2Lx != NULL)
242	{
243	rc = pPe2Lx->init(pszFilename);
244	if (rc == NO_ERROR)
245	{
246	kprintf(("myldrOpen-%d: Successfully init of Pe2Lx object.\n", cNesting));
247	rc = addModule(*phFile, NULL, MOD_TYPE_PE2LX, pPe2Lx);
248	if (rc == NO_ERROR)
249	{
250	#pragma info(notrd)
251	SetState(*phFile, HSTATE_OUR);
252	#pragma info(restore)
253	if (pPe2Lx->isExe())
254	{
255	setLdrStateLoadingOurEXE();
256	pExeModule = getModuleBySFN(*phFile);
257	#ifdef DEBUG
258	if (pExeModule == NULL)
259	kprintf(("myldrOpen-%d: getModuleBySFN failed when setting pExeModule! FATAL!\n", cNesting));
260	#endif
261	}
262	}
263	else
264	kprintf(("myldrOpen-%d: Failed to add the module. rc=%d\n", cNesting));
265	}
266	else
267	kprintf(("myldrOpen-%d: Failed to init Pe2Lx object. rc=%d\n", cNesting));
268	if (rc != NO_ERROR)
269	delete pPe2Lx;
270	}
271	else
272	{
273	kprintf(("myldrOpen-%d: Failed to allocate Pe2Lx object.\n", cNesting));
274	rc = ERROR_NOT_ENOUGH_MEMORY;
275	}
276
277	goto cleanup;
278	}
279
280
281	/** @sketch
282	* Using PE.EXE to start EXE?
283	* - When the file is an EXE file and PE.EXE is enabled.
284	*/
285	if ((u1.pNtHdrs->FileHeader.Characteristics & IMAGE_FILE_DLL) == 0UL
286	&& (options.fPE == FLAGS_PE_PE \|\| options.fPE == FLAGS_PE_MIXED)
287	&& (isLdrStateExecPgm() \|\| isLdrStateQAppType())
288	)
289	{
290	/** @sketch
291	* PE.EXE:
292	* Find pe.exe - look in current directory and thru the PATH.
293	* Note! We use the read buffer (u1.p*) as a storage for the
294	* pe.exe filename and path.
295	*/
296	kprintf(("myldrOpen-%d: pe.exe - opening\n", cNesting));
297	ldrClose(*phFile);
298	*phFile = 0xFFFF;
299	strcpy(u1.pach, "PE.EXE");
300	rc = ldrOpen(phFile, u1.pach, pfl); /* This isn't recusive! */
301	if (rc != NO_ERROR)
302	rc = OpenPATH(phFile, u1.pach, pfl);
303	if (rc == NO_ERROR)
304	{
305	/** @sketch
306	* If we're in tkExecPgm state we'll have to shuffle the parameters
307	* and executable filename tkExecPgm were called with.
308	* If not tkExecPgm we can't do anything about parameters (and there is
309	* probably nothing to do either).
310	* We'll always enclose the PE executable name in quotes.
311	*/
312	kprintf(("myldrOpen-%d: pe.exe - %s\n", cNesting, u1.pach));
313	if (isLdrStateExecPgm() && fTkExecPgm)
314	{
315	u1.pach[0] = '"';
316	strcpy(&u1.pach[1], achTkExecPgmFilename);
317	u1.pach[strlen(u1.pach)] = '\0';
318	rc = AddArgsToFront(2, ldrpFileNameBuf, u1.pach);
319	if (rc == NO_ERROR)
320	{
321	rc = SetExecName(ldrpFileNameBuf);
322	if (rc != NO_ERROR)
323	kprintf(("myldrOpen-%d: pe.exe - failed to set pe.exe as execname. rc=%d\n", cNesting));
324	}
325	else
326	kprintf(("myldrOpen-%d: pe.exe - failed to add programname as argument. rc=%d\n", cNesting, rc));
327	goto cleanup_noerror;
328	}
329	}
330	else
331	kprintf(("myldrOpen-%d: pe.exe - couldn't find/open pe.exe\n", cNesting));
332	}
333	goto cleanup;
334	}
335	/** @sketch End of PE Loading. */
336
337
338	/** @sketch
339	* ELF image?
340	*/
341	if (*u1.pul == ELFMAGICLSB)
342	{
343	if (isELFDisabled())
344	goto cleanup_noerror;
345
346	/*
347	* ELF signature found.
348	*/
349	kprintf(("myldrOpen-%d: ELF image! - not implemented yet!\n", cNesting));
350
351	/*
352	* Do nothing more yet. NEED AN ELF LOADER!!!
353	*/
354	goto cleanup;
355	}
356
357
358	/** @sketch
359	* Java image?
360	*/
361	if (*u1.pul == 0xBEBAFECAUL) //CAh FEh BAh BEh
362	{
363	char *pszName = NULL;
364	int cchName;
365
366	if (isJAVADisabled())
367	goto cleanup_noerror;
368
369	/** @sketch
370	* Java signature found.
371	* Copy the name to a temporary buffer. (only if necessary)
372	* Remove the extention (.class) and insert a space between the name and the path.
373	* (This is the needed processing of the class filename to make it a classpath
374	* entry (path) and a class name (filename).)
375	* Try find the java executor in current dir or PATH: java.exe
376	*/
377	kprintf(("myldrOpen-%d: Jave image!\n", cNesting));
378
379	if (isLdrStateExecPgm() && fTkExecPgm)
380	{
381	/* Ooops we had to get the file name from the MFT. ldrpFileNameBuf is allways uppercased... */
382	/* MFT seems to hold uppercased filenames! ARG! But (by pure luck?) achTkExecPgmArguments is
383	* not uppercased (yet). Nothing could be simpler!
384	*/
385	#if 1
386	psz3 = achTkExecPgmArguments;
387	#elif 0
388	psz3 = SecPathFromSFN(*phFile);
389	if (psz3 == NULL)
390	psz3 = ldrpFileNameBuf;
391	#else
392	psz3 = ldrpFileNameBuf;
393	#endif
394	cchName = strlen(psz3);
395	pszName = (char*)rmalloc(cchName + 2);
396	if (pszName == NULL)
397	{
398	rc = ERROR_NOT_ENOUGH_MEMORY;
399	goto cleanup;
400	}
401	memcpy(pszName, psz3, cchName+1);
402
403	psz = pszName + strlen(pszName) - 1;
404	while (psz > pszName && psz != '.' && psz != '\\' && *psz != '/')
405	psz--;
406	if (*psz == '.')
407	{
408	cchName = psz - pszName;
409	*psz-- = '\0';
410	while (psz > pszName && psz != '\\' && psz != '/')
411	psz--;
412
413	/* check for root and evt. make room for an extra slash. */
414	if (psz - pszName == 2)
415	{
416	memmove(psz + 1, psz, cchName - 1);
417	*psz++ = '\\';
418	}
419	}
420	/* check if no path */
421	if (psz == pszName)
422	memmove(pszName + 1, pszName, cchName + 1);
423	*psz = ' ';
424	}
425
426	ldrClose(*phFile);
427	*phFile = 0xFFFF;
428	rc = ldrOpen(phFile, ".\\JAVA.EXE", pfl);
429	if (rc != NO_ERROR)
430	rc = OpenPATH(phFile, "JAVA.EXE", pfl);
431	if (rc == NO_ERROR)
432	{
433	kprintf(("myldrOpen-%d: java - %s\n", cNesting, ldrpFileNameBuf));
434
435	/** @sketch
436	* To be able to execute any given class name we'll have to pass in the
437	* directory as -classpath. But -classpath seems to override the default
438	* and environmental CLASSPATHs. So, we'll have to pass in the value of
439	* the CLASSPATH env.var. or generate the default class path (what ever that is).
440	*
441	* TODO: spaces in class path.
442	*/
443	if (isLdrStateExecPgm() && fTkExecPgm)
444	{
445	psz = u1.pach;
446
447	/*
448	* Get classpath and add it as a parameter
449	*/
450	strcpy(u1.pach, "-classpath ");
451	psz = u1.pach + strlen(u1.pach);
452
453	psz3 = (char*)ScanEnv(GetEnv(TRUE), "CLASSPATH");
454	if (psz3 != NULL)
455	{ /* environment variable set */
456	if (strlen(psz3) > 640 - 11 - 1 - cchName) //check for overflow
457	{ // TODO? should reallocate...
458	memcpy(psz, psz3, 640 - 11 - 1 - cchName);
459	psz[640 - 11 - 1 - cchName] = '\0';
460	}
461	else
462	strcpy(psz, psz3);
463	psz += strlen(psz);
464	}
465	else
466	{
467	/* Make default classpath by taking the java.exe path + '..\lib\classes.zip' */
468	strcpy(psz, ldrpFileNameBuf);
469	psz3 = psz + strlen(psz) - 1;
470	while (psz3 > psz && psz3 != '\\' && psz3 != '/')
471	psz3--;
472	strcpy(++psz3, "..\\lib\\classes.zip");
473	psz = psz3 + strlen(psz3);
474	}
475
476	/*
477	* Add the class directory (as the last classpath entry) and the class name.
478	* (Note. I may happen that there is no directory, but that don't matter
479	* a space is allways preceding the class name.)
480	*/
481	*psz++ = ';';
482	strcpy(psz, pszName);
483	if (pszName != NULL)
484	rfree(pszName);
485
486	/*
487	* Setup JAVA.EXE as executable with the parameters we've build.
488	*/
489	rc = AddArgsToFront(2, ldrpFileNameBuf, u1.pach);
490	kprintf(("myldrOpen-%d: java - Exe: %s Args: %s\n", cNesting, ldrpFileNameBuf, u1.pach));
491	if (rc == NO_ERROR)
492	{
493	rc = SetExecName(ldrpFileNameBuf);
494	if (rc != NO_ERROR)
495	kprintf(("myldrOpen-%d: java - failed to set java.exe as execname. rc=%d\n", cNesting, rc));
496	}
497	else
498	kprintf(("myldrOpen-%d: java - failed to setup the parameters. rc=%d\n", cNesting, rc));
499
500	goto cleanup_noerror;
501	}
502	}
503	else
504	kprintf(("myldrOpen-%d: java - couldn't find/open java.exe\n", cNesting));
505
506
507	/** @sketch
508	* End of Java loading. (return)
509	*/
510	if (pszName != NULL)
511	rfree(pszName);
512	goto cleanup;
513	}
514
515	}
516	else
517	{
518	/** @sketch
519	* ELSE - the reading size of a DOS header failed or file is smaller than the dos header.
520	* IF read failed or filesize is less than 4 bytes THEN
521	* return no_error to the caller.
522	* ENDIF
523	*/
524	#ifdef DEBUG
525	if (rc != NO_ERROR)
526	{
527	kprintf(("myldrOpen-%d: ldrRead failed cbRead=%d, cbFile=%d, rc=%d\n", cNesting, cbRead, cbFile, rc));
528	goto cleanup_noerror;
529	}
530	if (cbRead < 4)
531	{
532	kprintf(("myldrOpen-%d: File too small! cbFile=%d\n", cNesting, cbFile));
533	goto cleanup_noerror;
534	}
535	#else
536	if (rc != NO_ERROR \|\| cbRead < 4) //just forget files less than 4 bytes!
537	goto cleanup_noerror;
538	#endif
539	}
540	/** @sketch ENDIF (dos header read) */
541
542
543
544	/*
545	* Only unreconized files passes this point!
546	*
547	* * Fileformats with lower priority should reside here. *
548	*
549	*/
550
551	/** @sketch
552	* UNIX styled script?
553	* - Starts with a hash (#)
554	* - And we're loading an EXE
555	* - And we're either in QAppType or ExecPgm state.
556	* - And that a bang (!) is the first char after the hash (ignoring blanks).
557	*
558	* FIXME: spaces script name.
559	*/
560	if (*u1.pach == '#'
561	&& isLdrStateLoadingEXE()
562	&& (isLdrStateQAppType() \|\| isLdrStateExecPgm())
563	)
564	{
565	if (isUNIXScriptDisabled())
566	goto cleanup_noerror;
567	/*
568	* Look for a bang (!). Tabs and spaces are skipped, anything else result in error.
569	*/
570	psz = u1.pach + 1;
571	while ((psz == ' ' \|\| psz == '\t') && psz - u1.pach < cbRead)
572	psz++;
573	if (*psz == '!')
574	{
575	/** @sketch Found UNIX styled script! */
576
577	/** @sketch
578	* Read more of the script if necessary. (max is 256 chars (- Linux max is 127))
579	* Terminate the string read from the file to make sure with stop somewhere!
580	*/
581	if (cbRead < cbFile /&& cbRead != 256/)
582	{
583	cbRead = min(256, cbFile);
584	rc = ldrRead(*phFile, 0UL, u1.pach, 0UL, cbRead, NULL);
585	}
586	u1.pach[cbRead] = '\0';
587
588	if (rc == NO_ERROR)
589	{
590	/** @sketch
591	* Parse out filename and optional arguments (if any).
592	* The result of the parsing is that:
593	* psz will point at the executable name.
594	* psz2 will point at the arguments.
595	* Both strings are trimmed.
596	*/
597	psz++; /* psz points to the bang, skip it. */
598	while (psz == ' ' \|\| psz == '\t') /* skip blanks after bang */
599	psz++;
600	if (psz == '\r' \|\| psz == '\n' \|\| psz == '\0') / End-of-line? */
601	{
602	kprintf(("myldrOpen-%d: script no executable name.\n", cNesting));
603	goto cleanup_noerror; /* other error code? */
604	}
605	psz2 = psz + 1; /* Not end-of-line, so add 1 before searching for args. */
606	while (psz2 != '\0' && psz2 != '\n' && psz2 != '\r' / skip executable name. */
607	&& psz2 != ' ' && psz2 != '\t')
608	psz2++;
609	while (psz2 == ' ' \|\| psz2 == '\t') /* skip blanks after executable - pad them with '\0'! */
610	*psz2++ = '\0';
611
612	psz3 = psz2;
613	while (psz3 != '\n' && psz3 != '\r' && psz3 != '\0') / find end of parameters and terminate the string. */
614	psz3++;
615	*psz3 = '\0';
616	while (psz3 >= psz2 && (psz3 == '\0' \|\| psz3 == ' ' \|\| psz3 == '\t')) / trim args */
617	*psz3-- = '\0';
618
619
620	/** @sketch
621	* IF tkExecPgm THEN
622	* Correct parameters - ie. add exec name (as argv[0]),
623	* arguments (psz2) as argv[1+], old exec name, and finally
624	* the existing parameters (current argv[1+]).
625	* Set the executable name.
626	* ENDIF
627	* Open the new executable file recursively. (psz)
628	*/
629	if (isLdrStateExecPgm())
630	{
631	if (*psz2)
632	rc = AddArgsToFront(3, psz, psz2, achTkExecPgmFilename);
633	else
634	rc = AddArgsToFront(2, psz, achTkExecPgmFilename);
635	if (rc != NO_ERROR)
636	{
637	kprintf(("myldrOpen-%d: AddArgsToFront failed with rc=%d\n", cNesting));
638	goto cleanup_noerror;
639	}
640	rc = SetExecName(psz);
641	if (rc != NO_ERROR)
642	kprintf(("myldrOpen-%d: SetExecName failed with rc=%d\n", cNesting));
643	}
644	ldrClose(*phFile);
645	*phFile = 0xFFFF;
646	rc = myldrOpen(phFile, psz, pfl);
647	if (rc != NO_ERROR)
648	{
649	psz2 = psz + strlen(psz);
650	if (psz + 4 >= psz2 \|\| strcmp(psz2 - 4, ".EXE") != 0)
651	{
652	strcpy(psz2, ".EXE");
653	rc = myldrOpen(phFile, psz, pfl);
654	*psz2 = '\0';
655	}
656	else
657	psz2 = NULL;
658
659	//should we search the PATH??? For a starting, we'll do it.
660	if (rc != NO_ERROR
661	&& (rc = OpenPATH(phFile, psz, pfl)) != NO_ERROR
662	&& psz2 != NULL)
663	{
664	*psz2 = '.';
665	rc = OpenPATH(phFile, psz, pfl);
666	}
667	}
668	}
669	else
670	{
671	kprintf(("myldrOpen-%d: script - failed to read more of the script!, rc=%d cbRead=%d cbFile=%d.\n",
672	cNesting, rc, cbRead, cbFile));
673	}
674
675	goto cleanup;
676	}
677	else
678	{
679	kprintf(("myldrOpen-%d: script - hash found but no bang (!).\n", cNesting));
680	}
681	} /*@sketch ENDIF - UNIX styled script. /
682
683
684
685	/** @sketch
686	* REXX script?
687	* - Starts with a REXX start comment ('/','*')
688	* - And we're loading an EXE
689	* - And we're either in QAppType or ExecPgm state.
690	* - Extention:
691	* .RX and .REX are known to be pure REXX scripts.
692	* While .CMD has to invoked used the commandline OS2_SHELL or COMSPEC variable.
693	*
694	* FIXME: spaces script name.
695	*/
696	psz2 = pszFilename + strlen(pszFilename) - 1;
697	while (psz2 > pszFilename && *psz2 != '.')
698	psz2--;
699	if (*psz2 == '.'
700	&& u1.pach == '/' && u1.pach[1] == ''
701	&& isLdrStateLoadingEXE()
702	&& (isLdrStateQAppType() \|\| isLdrStateExecPgm())
703	&& (stricmp(psz2, ".RX") == 0 \|\| stricmp(psz2, ".REX") == 0)
704	)
705	{
706	if (isREXXScriptDisabled())
707	goto cleanup_noerror;
708
709	/** @sketch
710	* Found REXX styled script!
711	* Find the REXX interpreter. We'll use kRx.exe to execute the REXX scripts.
712	* (This interpreter could be embedded as a child of ModuleBase as it turned out
713	* to be quite small about 700 bytes.)
714	*/
715	kprintf(("myldrOpen-%d: Found REXX script\n", cNesting));
716	ldrClose(*phFile);
717	*phFile = 0xFFFF;
718	psz = "KRX.EXE";
719	rc = ldrOpen(phFile, psz, pfl);
720	if (rc != NO_ERROR)
721	rc = OpenPATH(phFile, psz, pfl);
722
723	/** @sketch
724	* IF tkExecPgm THEN
725	* Correct parameters - ie. add exec name (as argv[0]), old exec name,
726	* and finally the existing parameters (current argv[1+]).
727	* Set the executable name.
728	* ENDIF
729	*/
730	if (rc == NO_ERROR && isLdrStateExecPgm())
731	{
732	rc = AddArgsToFront(2, ldrpFileNameBuf, achTkExecPgmFilename);
733	if (rc != NO_ERROR)
734	{
735	kprintf(("myldrOpen-%d: AddArgsToFront failed with rc=%d\n", cNesting));
736	goto cleanup_noerror;
737	}
738	rc = SetExecName(ldrpFileNameBuf);
739	if (rc != NO_ERROR)
740	kprintf(("myldrOpen-%d: SetExecName failed with rc=%d\n", cNesting));
741
742	goto cleanup_noerror;
743	}
744	goto cleanup;
745	} /*@sketch ENDIF - REXX styled script. /
746
747
748	/*
749	* Cleanup with rc set to NO_ERROR.
750	*/
751	cleanup_noerror:
752	rc = NO_ERROR;
753
754	/*
755	* Cleanup without having rc set to NO_ERROR.
756	* Decrement the nesting count.
757	*/
758	cleanup:
759	if (rc && *phFile != 0xFFFF)
760	{
761	ldrClose(*phFile);
762	*phFile = 0xFFFF;
763	}
764	rfree(u1.pach);
765	cNesting--;
766	}
767	#ifdef DEBUG
768	else if (cNesting >= 3)
769	kprintf(("myldrOpen-%d: cNesting = %d, which is too deep!\n", cNesting, cNesting));
770	#endif
771
772	ret:
773	/** @sketch
774	* If successful and force preload enabled and media flag pointer valid Then
775	* Set removable media.
776	* Return rc.
777	*/
778	if (rc == NO_ERROR && isForcePreloadEnabled() && pfl)
779	pfl &= ~0x1000UL; / 0x1000 is the fixed media flag. */
780
781	return rc;
782	}
783
784
785	/**
786	* Adds new arguments to the front of the startup arguments for the program about to be
787	* executed.
788	*
789	* @returns OS/2 return code.
790	* @param cArgs Count of arguments to add. At least 1!!!
791	* @param ... Pointers to the arguments to add.
792	* The first argument have to be the executable name. This have to the
793	* the only argument in the first string.
794	* The other arguements are space separated, so you could add a bunch
795	* of arguments in a single string!
796	* The last argument should be the old first parameter if this is to be
797	* preserved. The old first parameter is overwritten since it's
798	* normally the executable name.
799	*
800	* @status completly implemented.
801	* @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
802	* @remark Implementation note:
803	* The arguments convention is as follows:
804	* First argument, which should be the executable name, is terminated with a '\0'.
805	* It starts at offset 0 into the argument buffer, of course.
806	* All other arguemnts are separated by a space and follows the immediately after the
807	* first argument.
808	* The arguments are terminated by a double nulltermination: '\0\0'.
809	*/
810	APIRET AddArgsToFront(int cArgs, ...)
811	{
812	va_list vaarg; /* Variable length argument list. */
813	int cchOldArgs; /* Length of the old arguments (including the first argument). */
814	/* cchOldArgs = 1 means no arguments. It don't include the very last '\0' */
815	/* (remember argumets are terminated with two '\0's). */
816	int iSecondArg; /* Index of the second argument. (Used to skip the first argument.) */
817	/* Used first on the original arguments and them when adding the first */
818	/* new argument. */
819	int cchNewArgs; /* Length of the new arguments to be inserted. */
820	int i; /* Loop variable. Current function argument. */
821	char * psz; /* General string pointer. */
822
823
824	/** @sketch
825	* Assert that we're in the right state.
826	* Calc the length of the existing parameters.
827	* Calc the length of the new arguments to determin.
828	* Assert that the new arguments have length > 0.
829	*/
830	#ifdef DEBUG
831	if (!isLdrStateExecPgm())
832	{
833	kprintf(("AddArgsToFront: not in tkExecPgm state.\n"));
834	return ERROR_INVALID_PARAMETER;
835	}
836	#endif
837	if (!fTkExecPgm)
838	{
839	kprintf(("AddArgsToFront: called when not in tkExecPgm data is invalid!\n"));
840	return ERROR_INVALID_PARAMETER;
841	}
842
843	iSecondArg = strlen(&achTkExecPgmArguments[0]) + 1;
844	psz = &achTkExecPgmArguments[iSecondArg];
845	while (*psz != '\0')
846	psz += strlen(psz) + 1;
847	cchOldArgs = psz - &achTkExecPgmArguments[iSecondArg];
848
849	va_start(vaarg, cArgs);
850	for (cchNewArgs = i = 0; i < cArgs; i++)
851	cchNewArgs += strlen(va_arg(vaarg, char )) + 1; / 1 is for space or '\0'. */
852	va_end(vaarg);
853	#ifdef DEBUG
854	if (cchNewArgs == 0)
855	{
856	kprintf(("AddArgsToFront: the size of the arguments to add is zero!\n"));
857	return ERROR_INVALID_PARAMETER;
858	}
859	#endif
860
861
862	/** @sketch
863	* Check if we have enough room for the new arguments. Fail if not enough.
864	* Move the existing arguments to make room for the new ones.
865	* !IMPORTANT! The first existing arguments (executable name) is skipped !IMPORTANT!
866	* !IMPORTANT! in this move as this have to be re-added in this call! !IMPORTANT!
867	*/
868	if (cchOldArgs + cchNewArgs + 1 > CCHARGUMENTS)
869	{
870	kprintf(("AddArgsToFront: argument buffer is too small to hold the arguments to add, cchOldArgs=%d, cchNewArgs=%d\n",
871	cchOldArgs, cchNewArgs));
872	return ERROR_BAD_ARGUMENTS;
873	}
874
875	if (cchOldArgs > 0)
876	{
877	memmove(&achTkExecPgmArguments[cchNewArgs], &achTkExecPgmArguments[iSecondArg],
878	cchOldArgs + 1);
879	}
880	else
881	achTkExecPgmArguments[cchNewArgs] = '\0';
882
883
884	/** @sketch
885	* Copy new arguments.
886	* Since the first argument is special case we'll do it separately. (Uses '\0' as separator.)
887	* We assume that the entire first argument passed into this function should be the first argument!
888	* (This don't have to be true for the other arguments since these are space separated. You could
889	* pass in more than argument in a single string.)
890	* Loop thru the rest of the new arguments and add them with space as separator.
891	*/
892	va_start(vaarg, cArgs);
893	psz = va_arg(vaarg, char *);
894	memcpy(&achTkExecPgmArguments[0], psz, (i = strlen(psz) + 1));
895	psz = &achTkExecPgmArguments[i];
896
897	for (i = 1; i < cArgs; i++)
898	{
899	if (i > 1) *psz++ = ' '; //Add space if not second argument.
900	strcpy(psz, va_arg(vaarg, char *));
901	psz += strlen(psz);
902	}
903	va_end(vaarg);
904	if (cchOldArgs > 0) *psz++ = ' '; //Add space if old arguments
905
906	#ifdef DEBUG /* assertion */
907	if (psz != &achTkExecPgmArguments[cchNewArgs])
908	{
909	kprintf(("AddArgsToFront: !Assertion failed! psz didn't end up where it should! (psz -> %d should be %d)\n",
910	psz - &achTkExecPgmArguments[0], cchNewArgs));
911	if (cchOldArgs <= 1)
912	psz[0] = psz[1] = '\0';
913	}
914	#endif
915
916	return NO_ERROR;
917	}
918
919
920	/**
921	* Sets the executable name of the module.
922	* This function is normally invoked after a different executable than the one requested was
923	* opened. It does _NOT_ set the new executable name as the first argument, since it is more
924	* convenient to this while calling AddArgsToFront to add other arguments.
925	*
926	* @returns OS/2 return code.
927	* @param pszExecName Pointer to new executable name.
928	* @status completly implemented.
929	* @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
930	* @remark .
931	*/
932	APIRET SetExecName(const char *pszExecName)
933	{
934	#ifdef DEBUG
935	int cch;
936	cch = strlen(pszExecName);
937	if (cch > CCHMAXPATH)
938	{
939	kprintf(("ChangeExecName: filename is too long! cch=%d. name=%s\n", cch, pszExecName));
940	return ERROR_FILENAME_EXCED_RANGE;
941	}
942	if (!isLdrStateExecPgm())
943	{
944	kprintf(("ChangeExecName: called when not in tkExecPgm state!!! FATAL ERROR!\n"));
945	return ERROR_INVALID_PARAMETER;
946	}
947	#endif
948	if (!fTkExecPgm)
949	{
950	kprintf(("ChangeExecName: called when not in tkExecPgm data is invalid!!! FATAL ERROR!\n"));
951	return ERROR_INVALID_PARAMETER;
952	}
953
954	strcpy(achTkExecPgmFilename, pszExecName);
955
956	return 0;
957	}
958
959
960	/**
961	* Opens a file using the PATH environment variable of the current process.
962	* @returns OS2 return code.
963	* @param phFile Pointer to filehandle. The filehandle is set to the SFN for the opened
964	* file on successful return.
965	* The filehandle is 0 on failure.
966	* @param pszFilename Pointer to filename buffer. This will hold the filename on input.
967	* On successful return it holds the filepath found.
968	* On failiure it's undefined.
969	* @param pfl Some flags set by ldrOpen.
970	* @sketch stub
971	* @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
972	* @remark
973	*/
974	APIRET OpenPATH(PSFN phFile, char *pszFilename, PULONG pfl)
975	{
976	APIRET rc;
977	USHORT TCBFailErr_save;
978	int cchFile; /* Filename length + 1. */
979	const char pszFile; / Pointer to filename portion. */
980	const char pszPath = ScanEnv(GetEnv(FALSE), "PATH"); / Current Process environment? */
981
982	/**@sketch
983	* No PATH environment.
984	*/
985	if (pszPath == NULL)
986	return ERROR_FILE_NOT_FOUND;
987
988	/**@sketch
989	* Skip any paths in the filename.
990	*/
991	pszFile = pszFilename + (cchFile = strlen(pszFilename));
992	while (pszFile >= pszFilename && pszFile != '\\' && pszFile != '/')
993	pszFile--;
994	cchFile -= pszFile - pszFilename;
995	pszFile++;
996
997	/**@sketch
998	* We'll have to save the TCBFailErr since we don't want to cause
999	* Hard Errors while searching invalid paths, etc. (ldrOpenPath does this!)
1000	*/
1001	TCBFailErr_save = tcbGetTCBFailErr(tcbGetCur());
1002
1003	/**@ sketch
1004	* Loop thru the PATH trying to open the specified file in each
1005	* directory.
1006	*/
1007	while (*pszPath != '\0')
1008	{
1009	const char * pszNext;
1010	int cchPath;
1011	char chEnd;
1012	register char ch;
1013
1014	/*
1015	* Find end of this path.
1016	*/
1017	while (*pszPath == ' ') pszPath++; //skip leading spaces.
1018	if (*pszPath == '"')
1019	{
1020	chEnd = '"';
1021	pszPath++;
1022	}
1023	else
1024	chEnd = ';';
1025	pszNext = pszPath;
1026	while ((ch = *pszNext) != chEnd && ch != '\0')
1027	pszNext++;
1028
1029	cchPath = pszNext - pszPath;
1030	if (chEnd == '"')
1031	{
1032	/* Skip anything between the " and the ; or string end. */
1033	while ((ch = *pszNext) != ';' && ch != '\0')
1034	pszNext++;
1035	}
1036	else
1037	{
1038	/* Trim the string. */
1039	while (cchPath > 0 && pszPath[cchPath-1] == ' ') //??
1040	cchPath--;
1041	}
1042
1043	/*
1044	* No length? No Path! Or path'\'filename too long? => Next
1045	*/
1046	if (cchPath > 0 && cchPath + cchFile + 1 < CCHMAXPATH)
1047	{
1048	static char achFilename[CCHMAXPATH];
1049	/*
1050	* Build filename
1051	*/
1052	memcpy(achFilename, pszPath, cchPath);
1053	if ((ch = achFilename[cchPath - 1]) == '\\' \|\| ch == '/')
1054	cchPath--;
1055	else
1056	achFilename[cchPath] = '\\';
1057	memcpy(&achFilename[cchPath + 1], pszFile, cchFile); /* cchFile = length + 1; hence we copy the terminator too. */
1058
1059	/*
1060	* Try open the file.
1061	*/
1062	rc = myldrOpen(phFile, achFilename, pfl);
1063	switch (rc)
1064	{
1065	case ERROR_FILE_NOT_FOUND: case ERROR_PATH_NOT_FOUND: case ERROR_ACCESS_DENIED: case ERROR_INVALID_ACCESS:
1066	case ERROR_INVALID_DRIVE: case ERROR_NOT_DOS_DISK: case ERROR_REM_NOT_LIST: case ERROR_BAD_NETPATH:
1067	case ERROR_NETWORK_BUSY: case ERROR_DEV_NOT_EXIST: case ERROR_TOO_MANY_CMDS: case ERROR_ADAP_HDW_ERR:
1068	case ERROR_UNEXP_NET_ERR: case ERROR_BAD_REM_ADAP: case ERROR_NETNAME_DELETED: case ERROR_BAD_DEV_TYPE:
1069	case ERROR_NETWORK_ACCESS_DENIED: case ERROR_BAD_NET_NAME: case ERROR_TOO_MANY_SESS: case ERROR_REQ_NOT_ACCEP:
1070	case ERROR_INVALID_PASSWORD: case ERROR_OPEN_FAILED: case ERROR_INVALID_NAME: case ERROR_FILENAME_EXCED_RANGE:
1071	case ERROR_VC_DISCONNECTED:
1072	break;
1073
1074	case NO_ERROR:
1075	strcpy(pszFilename, achFilename);
1076	default:
1077	tcbSetTCBFailErr(tcbGetCur(), TCBFailErr_save);
1078	return rc;
1079	}
1080	}
1081	#ifdef DEBUG
1082	else if (cchPath > 0) kprintf(("OpenPATH: Path component is too long\n"));
1083	#endif
1084
1085	/*
1086	* Next
1087	*/
1088	if (*pszNext == '\0')
1089	break;
1090	pszPath = pszNext + 1;
1091	}
1092
1093
1094	/*
1095	* File is not found.
1096	*/
1097	*phFile = 0;
1098	tcbSetTCBFailErr(tcbGetCur(), TCBFailErr_save);
1099	return ERROR_FILE_NOT_FOUND;
1100	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: