path: root/private/crt32/dllstuff/crtdll.c

#ifdef  CRTDLL
/***
*crtdll.c - CRT initialization for a DLL using the CRTDLL model of C run-time
*
*	Copyright (c) 1991-1994, Microsoft Corporation. All rights reserved.
*
*Purpose:
*       This module contains the initialization entry point for the C run-time
*       stub in this DLL.  All C run-time code is located in the C Run-Time
*       Library DLL "CRTDLL.DLL", except for a little bit of start-up code in
*       the EXE, and this code in each DLL.  This code is necessary to invoke
*       the C++ constructors for the C++ code in this DLL.
*
*       This entry point should either be specified as the DLL initialization
*       entry point, or else it must be called by the DLL initialization entry
*       point of the DLL with the same arguments that the entry point receives.
*
*Revision History:
*       05-19-92  SKS   Initial version
*       08-01-92  SRW   winxcpt.h replaced bu excpt.h which is included by oscalls.h
*       09-16-92  SKS   Prepare for C8 C++ for MIPS by calling C++ constructors
*       09-29-92  SKS   _CRT_DLL must be a WINAPI function!
*       05-11-93  SKS   Add _DllMainCRTStartup as an alternative to _CRT_INIT
*       06-05-93  SRW   Pin CRTDLL.DLL in memory once loaded.
*       06-07-93  GJF   Added __proc_attached flag.
*       06-07-93  GJF   Backed out SteveWo's change of 06-05 and put it into
*                       crtlib.c
*       06-08-93  SKS   Clean up failure handling in _CRT_INIT
*       07-16-93  SRW   ALPHA Merge
*	12-02-93  SKS	Add atexit/_onexit support.  These routines must be
*			defined here so that DLL's that are linked with
*			CRTDLL.LIB will get these versions (suitable for DLLs),
*			not the versions of atexit/_onexit from CRTDLL.DLL,
*			which are only suitable for an EXE file.
*	07-18-94  GJF	Moved over Win32s support from VC 2.0 tree.
*
*******************************************************************************/

/*
 * SPECIAL BUILD MACRO! Note that crtexe.c (and crtexew.c) is linked in with
 * the client's code. It does not go into crtdll.dll! Therefore, it must be
 * built under the _DLL switch (like user code) and CRTDLL must be undefined.
 */
#undef  CRTDLL
#define _DLL

#include <cruntime.h>
#include <oscalls.h>
#include <internal.h>
#include <stdlib.h>
#define _DECL_DLLMAIN   /* enable prototypes for DllMain and _CRT_INIT */
#include <process.h>

/*
 * routine in DLL to do initialization (in this case, C++ constructors)
 */
typedef void (_CALLTYPE1 *PF)(void);

extern void _CALLTYPE4 _initterm(PF *, PF *);

/*
 * pointers to initialization sections
 */
extern PF __xc_a[], __xc_z[];	/* C++ initializers */

/*
 * Flag identifying the host as Win32s or not-Win32s.
 */
int __win32sflag = 0;

static int onexitflag = 0;

/*
 * flag set iff _CRTDLL_INIT was called with DLL_PROCESS_ATTACH
 */
static int __proc_attached = 0;

/*
 * Pointers to beginning and end of the table of function pointers manipulated
 * by _onexit()/atexit().  The atexit/_onexit code is shared for both EXE's and
 * DLL's but different behavior is required.  These values are initialized to
 * 0 by default and will be set to point to a malloc-ed memory block to mark
 * this module as an DLL.
 */

PF *__onexitbegin;
PF *__onexitend;


/*
 * User routine DllMain is called on all notifications
 */

extern BOOL WINAPI DllMain(
        HANDLE  hDllHandle,
        DWORD   dwReason,
        LPVOID  lpreserved
        ) ;

/***
*BOOL WINAPI _CRT_INIT(hDllHandle, dwReason, lpreserved) - C++ DLL initialization.
*
*Purpose:
*       This routine does the C runtime initialization for a DLL using CRTDLL.
*       It may be specified as the entry point for the DLL, or it may be
*       called by the routine that is the DLL entry point.
*
*	On DLL_PROCESS_ATTACH, the C++ constructors for the DLL will be called.
*
*	On DLL_PROCESS_DETACH, the C++ destructors and _onexit/atexit routines
*	will be called.
*
*Entry:
*
*Exit:
*
*******************************************************************************/

BOOL WINAPI _CRT_INIT(
        HANDLE  hDllHandle,
        DWORD   dwReason,
        LPVOID  lpreserved
        )
{
	unsigned osver;

	/*
	 * First, set the __proc_attached flag
	 */
	if ( dwReason == DLL_PROCESS_ATTACH )
		__proc_attached++;
	else if ( dwReason == DLL_PROCESS_DETACH ) {
		if ( __proc_attached > 0 )
			__proc_attached--;
		else
			/*
			 * no prior process attach. just return failure.
			 */
			return FALSE;
	}

	/*
	 * Get the host version (on first call).
	 */
	if ( __win32sflag == 0 ) {
	    osver = GetVersion();
	    if ( ((osver & 0x00ff) == 3) && ((osver >> 31) & 1) )
		__win32sflag++;
	    else
		__win32sflag--;
	}


	/*
         * do C++ constructors (initializers) specific to this DLL
         */

        if ( dwReason == DLL_PROCESS_ATTACH ) {

		/*
		 * If the host is Win32s, create the onexit table and do C++
		 * constructors only for the first connecting process.
		 */
		if  ( (__win32sflag < 0) || (__proc_attached == 1) ) {

			if ( __win32sflag < 0 ) {
				/*
				 * not Win32s! just malloc the table.
				 */
				if ( (__onexitbegin = (PF *)malloc(32 *
				    sizeof(PF))) == NULL )
					/*
					 * cannot allocate minimal required
					 * size. generate failure to load DLL
					 */
					return FALSE;
			}
			else if ( __proc_attached == 1 ) {
				if ( (__onexitbegin =
				    (PF *)GlobalAlloc( GMEM_FIXED |
				    GMEM_SHARE, 32 * sizeof(PF) )) ==
				    NULL )
					/*
					 * cannot allocate minimal required
					 * size. generate failure to load DLL
					 */
					return FALSE;
			}

			*(__onexitbegin) = (PF) NULL;

			__onexitend = __onexitbegin;

			/*
			 * Invoke C++ constructors
			 */
			_initterm(__xc_a,__xc_z);

		}
	}
	else if ( dwReason == DLL_PROCESS_DETACH ) {

		if  ( (__win32sflag < 0) || (__proc_attached == 0) )
		{
			/*
			 * Any basic clean-up code that goes here must be
			 * duplicated below in _DllMainCRTStartup for the
			 * case where the user's DllMain() routine fails on a
			 * Process Attach notification. This does not include
			 * calling user C++ destructors, etc.
			 */

			/*
			 * do _onexit/atexit() terminators
			 * (if there are any)
			 *
			 * These terminators MUST be executed in
			 * reverse order (LIFO)!
			 *
			 * NOTE:
			 *	This code assumes that __onexitbegin
			 *	points to the first valid onexit()
			 *	entry and that __onexitend points
			 *	past the last valid entry. If
			 *	__onexitbegin == __onexitend, the
			 *	table is empty and there are no
			 *	routines to call.
			 */

			if (__onexitbegin) {
				PF * pfend = __onexitend;

				while ( -- pfend >= __onexitbegin )
					/*
					 * if current table entry is not
					 * NULL, call thru it.
					 */
					if ( *pfend != NULL )
						(**pfend)();

				/*
				 * just in case Win32s doesn't clean up after
				 * us (any bets?), free the block holding
				 * onexit table
				 */
				if ( __win32sflag > 0 )
					GlobalFree( (HGLOBAL)__onexitbegin );
                else
                    free(__onexitbegin);
			}
		}
	}

        return TRUE;
}

/***
*BOOL WINAPI _DllMainCRTStartup(hDllHandle, dwReason, lpreserved) - C++ DLL initialization.
*
*Purpose:
*       This is an alternative entry point for DLL's linked with the C run-time
*       libs, rather than using _CRT_INIT.  The user should specify this routine
*       as the DLL entry point, and define his/her own routine DllMain to get
*       notifications in his/her code.  CRT initialization/termination will be
*       done before or after calling DllMain, as appropriate.
*
*Entry:
*
*Exit:
*
*******************************************************************************/
BOOL WINAPI _DllMainCRTStartup(
        HANDLE  hDllHandle,
        DWORD   dwReason,
        LPVOID  lpreserved
        )
{
        BOOL retcode = TRUE;

	/*
	 * If this is a process detach notification, check that there has
	 * been a prior process attach notification.
	 */
	if ( (dwReason == DLL_PROCESS_DETACH) && (__proc_attached == 0) )
		return FALSE;

        if ( dwReason == DLL_PROCESS_ATTACH || dwReason == DLL_THREAD_ATTACH )
                retcode = _CRT_INIT(hDllHandle, dwReason, lpreserved);

        if ( retcode )
                retcode = DllMain(hDllHandle, dwReason, lpreserved);

        /*
         * If _CRT_INIT successfully handles a Process Attach notification
         * but the user's DllMain routine returns failure, we need to do
         * clean-up of the C run-time similar to what _CRT_INIT does on a
         * Process Detach Notification.
         */

        if ( dwReason == DLL_PROCESS_DETACH || dwReason == DLL_THREAD_DETACH )
        {
                if ( _CRT_INIT(hDllHandle, dwReason, lpreserved) == FALSE )
                        retcode = FALSE ;
        }

        return retcode ;
}

/***
*_onexit, atexit - calls to DLL versioons of _onexit & atexit in CRTDLL.DLL
*
*Purpose:
*	A DLL linked with CRTDLL.LIB must not call the standard _onexit or
*	atexit exported from CRTDLL.DLL, but an EXE linked with CRTDLL.LIB
*	will call the standard versions of those two routines.	Since the
*	names are exported from CRTDLL.DLL, we must define them here for DLLs.
*	All DLLs linked with CRTDLL.LIB must pull in this startup object.
*
*Entry:
*	Same as the regular versions of _onexit, atexit.
*
*Exit:
*	Same as the regular versions of _onexit, atexit.
*
*Exceptions:
*
*******************************************************************************/

extern _onexit_t _CALLTYPE1 __dllonexit(_onexit_t, PF **, PF **);

_onexit_t _CALLTYPE1 _onexit (
	_onexit_t func
	)
{
	unsigned osver;
	_onexit_t retval;

	/*
	 * Get the host version (on first call).
	 */
	if ( __win32sflag == 0 ) {
	    osver = GetVersion();
	    if ( ((osver & 0x00ff) == 3) && ((osver >> 31) & 1) )
		__win32sflag++;
	    else
		__win32sflag--;
	}

	/*
	 * If we are running in Win32s, test and set the flag used to
	 * serialize access. Note that we assume no process switch can take
	 * place between a successful test of the flag and the setting of
	 * the flag.
	 */
	if ( __win32sflag > 0 ) {
	    while ( onexitflag > 0 )
		Sleep(0);
	    onexitflag++;
	}

	retval = __dllonexit(func, &__onexitbegin, &__onexitend);

	if ( __win32sflag > 0 )
	    onexitflag--;

	return retval;
}

int _CALLTYPE1 atexit (
	PF func
	)
{
	return (_onexit((_onexit_t)func) == NULL) ? -1 : 0;
}

#endif  /* CRTDLL */