details. */
#include "winsup.h"
-#include "autoload.h"
+#define USE_SYS_TYPES_FD_SET
+#include <winsock2.h>
+
+/* Macro for defining "auto-load" functions.
+ * Note that this is self-modifying code *gasp*.
+ * The first invocation of a routine will trigger the loading of
+ * the DLL. This will then be followed by the discovery of
+ * the procedure's entry point, which is placed into the location
+ * pointed to by the stack pointer. This code then changes
+ * the "call" operand which invoked it to a "jmp" which will
+ * transfer directly to the DLL function on the next invocation.
+ *
+ * Subsequent calls to routines whose transfer address has not been
+ * determined will skip the "load the dll" step, starting at the
+ * "discovery of the entry point" step.
+ *
+ * So, immediately following the the call to one of the above routines
+ * we have:
+ * DLL info (4 bytes) Pointer to a block of information concerning
+ * the DLL (see below).
+ * DLL args (4 bytes) The number of arguments pushed on the stack by
+ * the call. If this is an odd value then this
+ * is a flag that non-existence of this function
+ * is not a fatal error
+ * func name (n bytes) asciz string containing the name of the function
+ * to be loaded.
+ *
+ * The DLL info block consists of the following
+ * load_state (4 bytes) Pointer to a word containing the routine used
+ * to eventually invoke the function. Initially
+ * points to an init function which loads the
+ * DLL, gets the process's load address,
+ * changes the contents here to point to the
+ * function address, and changes the call *(%eax)
+ * to a jmp func. If the initialization has been
+ * done, only the load part is done.
+ * DLL handle (4 bytes) The handle to use when loading the DLL.
+ * DLL locker (4 bytes) Word to use to avoid multi-thread access during
+ * initialization.
+ * extra init (4 bytes) Extra initialization function.
+ * DLL name (n bytes) asciz string containing the name of the DLL.
+ */
+
+/* LoadDLLprime is used to prime the DLL info information, providing an
+ additional initialization routine to call prior to calling the first
+ function. */
+#define LoadDLLprime(dllname, init_also) __asm__ (" \n\
+ .section ." #dllname "_info,\"w\" \n\
+ .linkonce \n\
+ .long std_dll_init \n\
+ .long 0 \n\
+ .long -1 \n\
+ .long " #init_also " \n\
+ .asciz \"" #dllname "\" \n\
+ .text \n\
+");
+
+/* Create a "decorated" name */
+#define mangle(name, n) #name "@" #n
+
+/* Standard DLL load macro. Invokes a fatal warning if the function isn't
+ found. */
+#define LoadDLLfunc(name, n, dllname) LoadDLLfuncEx (name, n, dllname, 0)
+
+/* Main DLL setup stuff. */
+#define LoadDLLfuncEx(name, n, dllname, notimp) __asm__ ("\
+ .section ." #dllname "_info,\"w\" \n\
+ .linkonce \n\
+ .long std_dll_init \n\
+ .long 0 \n\
+ .long -1 \n\
+ .long dll_func_load \n\
+ .asciz \"" #dllname "\" \n\
+ \n\
+ .section ." #dllname "_text,\"wx\" \n\
+ .global _" mangle (name, n) " \n\
+ .global _win32_" mangle (name, n) " \n\
+ .align 8 \n\
+_" mangle (name, n) ": \n\
+_win32_" mangle (name, n) ": \n\
+ movl (1f),%eax \n\
+ call *(%eax) \n\
+1:.long ." #dllname "_info \n\
+ .long " #n "+" #notimp " \n\
+ .asciz \"" #name "\" \n\
+ .text \n\
+");
+
+/* DLL loader helper functions used during initialization. */
+
+/* The function which finds the address, given the name and overwrites
+ the call so that future invocations go straight to the function in
+ the DLL. */
+extern "C" void dll_func_load () __asm__ ("dll_func_load");
+
+/* Called by the primary initialization function "init_std_dll" to
+ setup the stack and eliminate future calls to init_std_dll for other
+ functions from this DLL. */
+extern "C" void dll_chain () __asm__ ("dll_chain");
+
+/* called by the secondary initialization function to call dll_func_load. */
+extern "C" void dll_chain1 () __asm__ ("dll_chain1");
extern "C" {
-/* This struct is unused, but it illustrates the layout of a DLL
- information block. */
-struct DLLinfo
+/* FIXME: This is not thread-safe? */
+__asm__ (" \n\
+msg1: \n\
+ .ascii \"couldn't dynamically determine load address for '%s' (handle %p), %E\\0\"\n\
+ \n\
+ .align 32 \n\
+noload: \n\
+ popl %edx # Get the address of the information block\n\
+ movl 4(%edx),%eax # Should we 'ignore' the lack \n\
+ test $1,%eax # of this function? \n\
+ jz 1f # Nope. \n\
+ decl %eax # Yes. This is the # of bytes + 1 \n\
+ popl %edx # Caller's caller \n\
+ addl %eax,%esp # Pop off bytes \n\
+ movl $127,%eax # ERROR_PROC_NOT_FOUND \n\
+ pushl %eax # First argument \n\
+ call _SetLastError@4 # Set it \n\
+ xor %eax,%eax # Zero functional return \n\
+ jmp *%edx # Return \n\
+1: \n\
+ movl (%edx),%eax # Handle value \n\
+ pushl 4(%eax) \n\
+ leal 8(%edx),%eax # Location of name of function \n\
+ push %eax \n\
+ push $msg1 # The message \n\
+ call ___api_fatal # Print message. Never returns \n\
+ \n\
+ .globl dll_func_load \n\
+dll_func_load: \n\
+ movl (%esp),%eax # 'Return address' contains load info \n\
+ addl $8,%eax # Address of name of function to load \n\
+ pushl %eax # Second argument \n\
+ movl -8(%eax),%eax # Where handle lives \n\
+ movl 4(%eax),%eax # Address of Handle to DLL \n\
+ pushl %eax # Handle to DLL \n\
+ call _GetProcAddress@8# Load it \n\
+ test %eax,%eax # Success? \n\
+ jne gotit # Yes \n\
+ jmp noload # Issue an error or return \n\
+gotit: \n\
+ popl %ecx # Pointer to 'return address' \n\
+ movb $0xe9,-7(%ecx) # Turn preceding call to a jmp *%eax \n\
+ movl %eax,%edx # Save \n\
+ subl %ecx,%eax # Make it relative \n\
+ addl $2,%eax # Tweak \n\
+ movl %eax,-6(%ecx) # Move relative address after jump \n\
+ jmp *%edx # Jump to actual function \n\
+ \n\
+ .global dll_chain \n\
+dll_chain: \n\
+ pushl %eax # Restore 'return address' \n\
+ movl (%eax),%eax # Get address of DLL info block \n\
+ movl $dll_func_load,(%eax) # Just load func now \n\
+ jmp *%edx # Jump to next init function \n\
+ \n\
+dll_chain1: \n\
+ pushl %eax # Restore 'return address' \n\
+ jmp *%edx # Jump to next init function \n\
+");
+
+/* C representations of the two info blocks described above.
+ FIXME: These structures confuse gdb for some reason. GDB can print
+ the whole structure but has problems with the name field? */
+struct dll_info
{
- char jmpinst[4];
- HANDLE h;
- DWORD flag;
- char name[0];
+ DWORD load_state;
+ HANDLE handle;
+ LONG here;
+ void (*init) ();
+ char name[];
};
-/* FIXME: This is not thread-safe! */
-__asm__ ("\n\
-msg1:\n\
- .ascii \"couldn't dynamically determine load address for '%s' (handle %p), %E\\0\"\n\
-\n\
- .align 32\n\
-noload:\n\
- popl %edx # Get the address of the information block\n\
- movl 8(%edx),%eax # Should we 'ignore' the lack\n\
- test $1,%eax # of this function?\n\
- jz 1f # Nope.\n\
- decl %eax # Yes. This is the # of bytes + 1\n\
- popl %edx # Caller's caller\n\
- addl %eax,%esp # Pop off bytes\n\
- xor %eax,%eax # Zero functional return\n\
- jmp *%edx # Return\n\
-1:\n\
- movl 4(%edx),%eax # Handle value\n\
- pushl (%eax)\n\
- leal 12(%edx),%eax # Location of name of function\n\
- push %eax\n\
- push $msg1 # The message\n\
- call ___api_fatal # Print message. Never returns\n\
-\n\
- .globl cygwin_dll_func_load\n\
-cygwin_dll_func_load:\n\
- movl (%esp),%eax # 'Return address' contains load info\n\
- addl $12,%eax # Address of name of function to load\n\
- pushl %eax # Second argument\n\
- movl -8(%eax),%eax # Address of Handle to DLL\n\
- pushl (%eax) # Handle to DLL\n\
- call _GetProcAddress@8# Load it\n\
- test %eax,%eax # Success?\n\
- jne gotit # Yes\n\
- jmp noload # Issue an error or return\n\
-gotit:\n\
- popl %ecx # Pointer to 'return address'\n\
- movb $0xe0,-1(%ecx) # Turn preceding call to a jmp *%eax\n\
- movl %eax,(%ecx) # Point dispatch to address loaded above\n\
- jmp *%eax\n\
-");
+struct func_info
+{
+ struct dll_info *dll;
+ LONG decoration;
+ char name[];
+};
-int
-std_dll_init (HANDLE &dll_handle, const char *dll_name, LONG &here)
+/* Mechanism for setting up info for passing to dll_chain routines. */
+union retchain
+{
+ struct {long high; long low;};
+ long long ll;
+};
+
+/* The standard DLL initialization routine. */
+static long long std_dll_init () __asm__ ("std_dll_init") __attribute__ ((unused));
+static long long
+std_dll_init ()
{
HANDLE h;
+ struct func_info *func = (struct func_info *) __builtin_return_address (0);
+ struct dll_info *dll = func->dll;
+ retchain ret;
+
+ if (InterlockedIncrement (&dll->here))
+ do
+ {
+ InterlockedDecrement (&dll->here);
+ Sleep (0);
+ }
+ while (InterlockedIncrement (&dll->here));
+ else if (!dll->handle)
+ {
+ if ((h = LoadLibrary (dll->name)) != NULL)
+ dll->handle = h;
+ else if (!(func->decoration & 1))
+ api_fatal ("could not load %s, %E", dll->name);
+ else
+ dll->handle = INVALID_HANDLE_VALUE;
+ }
+
+ InterlockedDecrement (&dll->here);
+
+ /* Kludge alert. Redirects the return address to dll_chain. */
+ __asm__ __volatile__ (" \n\
+ movl $dll_chain,4(%ebp) \n\
+ ");
+
+ /* Set "arguments for dll_chain. */
+ ret.low = (long) dll->init;
+ ret.high = (long) func;
+ return ret.ll;
+}
+
+/* Initialization function for winsock stuff. */
+static long long wsock_init () __asm__ ("wsock_init") __attribute__ ((unused, regparm(1)));
+bool NO_COPY wsock_started = 0;
+static long long
+wsock_init ()
+{
+ static LONG NO_COPY here = -1L;
+ extern WSADATA wsadata;
+ struct func_info *func = (struct func_info *) __builtin_return_address (0);
+ struct dll_info *dll = func->dll;
+ retchain ret;
+
+ __asm__ (" \n\
+ .section .ws2_32_info \n\
+ .equ _ws2_32_handle,.ws2_32_info + 4 \n\
+ .global _ws2_32_handle \n\
+ .section .wsock32_info \n\
+ .equ _wsock32_handle,.wsock32_info + 4 \n\
+ .global _wsock32_handle \n\
+ .text \n\
+ ");
while (InterlockedIncrement (&here))
{
Sleep (0);
}
- if (dll_handle)
- /* nothing to do */;
- else if ((h = LoadLibrary (dll_name)) != NULL)
- dll_handle = h;
- else
- api_fatal ("could not load %s, %E", dll_name);
+ if (!wsock_started && (wsock32_handle || ws2_32_handle))
+ {
+ /* Don't use autoload to load WSAStartup to eliminate recursion. */
+ int (*wsastartup) (int, WSADATA *);
- InterlockedDecrement (&here);
- return 0;
-}
+ wsastartup = (int (*)(int, WSADATA *))
+ GetProcAddress ((HMODULE) (dll->handle), "WSAStartup");
+ if (wsastartup)
+ {
+ int res = wsastartup ((2<<8) | 2, &wsadata);
-LoadDLLinitfunc (advapi32)
-LoadDLLinitfunc (netapi32)
-LoadDLLinitfunc (ntdll)
-LoadDLLinitfunc (secur32)
-LoadDLLinitfunc (user32)
-LoadDLLinitfunc (iphlpapi)
-LoadDLLinitfunc (ole32)
-LoadDLLinitfunc (kernel32)
-LoadDLLinitfunc (winmm)
+ debug_printf ("res %d", res);
+ debug_printf ("wVersion %d", wsadata.wVersion);
+ debug_printf ("wHighVersion %d", wsadata.wHighVersion);
+ debug_printf ("szDescription %s", wsadata.szDescription);
+ debug_printf ("szSystemStatus %s", wsadata.szSystemStatus);
+ debug_printf ("iMaxSockets %d", wsadata.iMaxSockets);
+ debug_printf ("iMaxUdpDg %d", wsadata.iMaxUdpDg);
+ debug_printf ("lpVendorInfo %d", wsadata.lpVendorInfo);
-extern void wsock_init ();
+ wsock_started = 1;
+ }
+ }
-LoadDLLinitfuncdef (wsock32)
-{
- LoadDLLstdfunc (wsock32);
- wsock_init ();
- return 0;
-}
+ InterlockedDecrement (&here);
-LoadDLLinitfuncdef (ws2_32)
-{
- LoadDLLstdfunc (ws2_32);
- wsock_init ();
- return 0;
+ /* Kludge alert. Redirects the return address to dll_chain1. */
+ __asm__ __volatile__ (" \n\
+ movl $dll_chain1,4(%ebp) \n\
+ ");
+
+ /* Set "arguments for dll_chain1. */
+ ret.low = (long) dll_func_load;
+ ret.high = (long) func;
+ return ret.ll;
}
-static void __stdcall dummy_autoload (void) __attribute__ ((unused));
-static void __stdcall
-dummy_autoload (void)
-{
-LoadDLLinit (advapi32)
+LoadDLLprime (wsock32, wsock_init)
+LoadDLLprime (ws2_32, wsock_init)
+
LoadDLLfunc (AddAccessAllowedAce, 16, advapi32)
LoadDLLfunc (AddAccessDeniedAce, 16, advapi32)
LoadDLLfunc (AddAce, 20, advapi32)
LoadDLLfunc (SetSecurityDescriptorOwner, 12, advapi32)
LoadDLLfunc (SetTokenInformation, 16, advapi32)
-LoadDLLinit (netapi32)
LoadDLLfunc (NetWkstaUserGetInfo, 12, netapi32)
LoadDLLfunc (NetUserGetInfo, 16, netapi32)
LoadDLLfunc (NetApiBufferFree, 4, netapi32)
-LoadDLLinit (ntdll)
LoadDLLfuncEx (NtMapViewOfSection, 40, ntdll, 1)
LoadDLLfuncEx (NtOpenSection, 12, ntdll, 1)
LoadDLLfuncEx (NtQuerySystemInformation, 16, ntdll, 1)
LoadDLLfuncEx (RtlNtStatusToDosError, 4, ntdll, 1)
LoadDLLfuncEx (ZwQuerySystemInformation, 16, ntdll, 1)
-LoadDLLinit (secur32)
LoadDLLfuncEx (LsaDeregisterLogonProcess, 4, secur32, 1)
LoadDLLfuncEx (LsaFreeReturnBuffer, 4, secur32, 1)
LoadDLLfuncEx (LsaLogonUser, 56, secur32, 1)
LoadDLLfuncEx (LsaLookupAuthenticationPackage, 12, secur32, 1)
LoadDLLfuncEx (LsaRegisterLogonProcess, 12, secur32, 1)
-LoadDLLinit (user32)
LoadDLLfunc (CharToOemA, 8, user32)
LoadDLLfunc (CharToOemBuffA, 12, user32)
LoadDLLfunc (CloseClipboard, 0, user32)
LoadDLLfunc (SetTimer, 16, user32)
LoadDLLfunc (SetUserObjectSecurity, 12, user32)
-LoadDLLinit (wsock32)
LoadDLLfunc (WSAAsyncSelect, 16, wsock32)
LoadDLLfunc (WSACleanup, 0, wsock32)
LoadDLLfunc (WSAGetLastError, 0, wsock32)
LoadDLLfunc (shutdown, 8, wsock32)
LoadDLLfunc (socket, 12, wsock32)
-LoadDLLinit (ws2_32)
LoadDLLfuncEx (WSACloseEvent, 4, ws2_32, 1)
LoadDLLfuncEx (WSACreateEvent, 0, ws2_32, 1)
LoadDLLfuncEx (WSADuplicateSocketA, 12, ws2_32, 1)
LoadDLLfuncEx (WSASocketA, 24, ws2_32, 1)
LoadDLLfuncEx (WSAWaitForMultipleEvents, 20, ws2_32, 1)
-LoadDLLinit (iphlpapi)
LoadDLLfuncEx (GetIfTable, 12, iphlpapi, 1)
LoadDLLfuncEx (GetIpAddrTable, 12, iphlpapi, 1)
-LoadDLLinit (ole32)
LoadDLLfunc (CoInitialize, 4, ole32)
LoadDLLfunc (CoUninitialize, 0, ole32)
LoadDLLfunc (CoCreateInstance, 20, ole32)
-LoadDLLinit (kernel32)
LoadDLLfuncEx (SignalObjectAndWait, 16, kernel32, 1)
-LoadDLLinit (winmm)
LoadDLLfuncEx (waveOutGetNumDevs, 0, winmm, 1)
LoadDLLfuncEx (waveOutOpen, 24, winmm, 1)
LoadDLLfuncEx (waveOutReset, 4, winmm, 1)
LoadDLLfuncEx (waveOutPrepareHeader, 12, winmm, 1)
LoadDLLfuncEx (waveOutWrite, 12, winmm, 1)
}
-}
+++ /dev/null
-/* autoload.h: Define functions for auto-loading symbols from a DLL.
-
- Copyright 1999, 2000 Cygnus Solutions.
-
- Written by Christopher Faylor <cgf@cygnus.com>
-
-This file is part of Cygwin.
-
-This software is a copyrighted work licensed under the terms of the
-Cygwin license. Please consult the file "CYGWIN_LICENSE" for
-details. */
-
-#define LoadDLLinitfunc(dllname) \
-LoadDLLinitfuncdef(dllname) \
-{ \
- return LoadDLLstdfunc(dllname); \
-}
-
-#define LoadDLLinitfuncdef(dllname) \
-HANDLE NO_COPY dllname ## _handle = NULL; \
-LONG NO_COPY dllname ## _here = -1L; \
-/*static*/ int dllname ## _init () __asm__ (#dllname "_init"); \
-/*static*/ int dllname ## _init ()
-
-#define LoadDLLstdfunc(dllname) \
- std_dll_init (dllname ## _handle, #dllname ".dll", dllname ## _here)
-
-#define LoadDLLinitnow(dllname) \
- ({__asm__ ("movl $cygwin_dll_func_load, " #dllname "_init_holder"); dllname##_init ();})
-
-#define _LoadDLLinitnow(dllname) \
- __asm__ ("movl $cygwin_dll_func_load, " #dllname "_init_holder"); \
- __asm__ ("call " #dllname "_init"); \
-
-#define LoadDLLinit(dllname) \
- __asm__ (".section .data_cygwin_nocopy,\"w\""); \
- __asm__ (#dllname "_init_holder: .long " #dllname "_init_and_load"); \
- __asm__ (".text"); \
- __asm__ (#dllname "_init_and_load:"); \
- _LoadDLLinitnow (dllname); \
- __asm__ ("jmp cygwin_dll_func_load");
-
-
-/* Macro for defining "auto-load" functions.
- * Note that this is self-modifying code *gasp*.
- * The first invocation of a routine will trigger the loading of
- * the DLL. This will then be followed by the discovery of
- * the procedure's entry point, which is placed into the location
- * pointed to by the stack pointer. This code then changes
- * the "call" operand which invoked it to a "jmp" which will
- * transfer directly to the DLL function on the next invocation.
- *
- * Subsequent calls to routines whose transfer address has not been
- * determined will skip the "load the dll" step, starting at the
- * "discovery of the DLL" step.
- *
- * So, immediately following the the call to one of the above routines
- * we have:
- * foojmp (4 bytes) Pointer to a word containing the routine used
- * to eventually invoke the function. Initially
- * points to an init function which loads the
- * DLL, gets the process's load address,
- * changes the contents here to point to the
- * function address, and changes the call *(%eax)
- * to a jmp %eax. If the initialization has been
- * done, only the load part is done.
- * DLL handle (4 bytes) The handle to use when loading the DLL.
- * flag (4 bytes) If "TRUE" then it is not a fatal error if this
- * function cannot be found. Instead, error is set
- * to ERROR_PROC_NOT_FOUND and 0 is returned.
- * func name (n bytes) asciz string containing the name of the function
- * to be loaded.
- */
-
-#define LoadDLLmangle(name, n) #name "@" #n
-#define LoadDLLfunc(name, n, dllname) LoadDLLfuncEx (name, n, dllname, 0)
-#define LoadDLLfuncEx(name, n, dllname, notimp) \
-__asm__ (".section .data_cygwin_nocopy,\"w\""); \
-__asm__ (".global _" LoadDLLmangle (name, n)); \
-__asm__ (".global _win32_" LoadDLLmangle (name, n)); \
-__asm__ (".align 8"); \
-__asm__ ("_" LoadDLLmangle (name, n) ":"); \
-__asm__ ("_win32_" LoadDLLmangle (name, n) ":"); \
-__asm__ ("movl (" #name "jump),%eax"); \
-__asm__ ("call *(%eax)"); \
-__asm__ (#name "jump: .long " #dllname "_init_holder"); \
-__asm__ (" .long _" #dllname "_handle"); \
-__asm__ (" .long " #n "+" #notimp); \
-__asm__ (".asciz \"" #name "\""); \
-__asm__ (".text"); \
-
-extern "C" void cygwin_dll_func_load () __asm__ ("cygwin_dll_func_load");
OSDN Git Service
