msi: Don't print the function name twice in a WARN.
[wine] / dlls / kernel32 / kernel_main.c
1 /*
2  * Kernel initialization code
3  *
4  * Copyright 2000 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <signal.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wincon.h"
33 #include "winternl.h"
34 #include "wownt32.h"
35
36 #include "wine/library.h"
37 #include "kernel_private.h"
38 #include "console_private.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(process);
42
43 extern int CDECL __wine_set_signal_handler(unsigned, int (*)(unsigned));
44
45 static ULONGLONG server_start_time;
46
47 /***********************************************************************
48  *           set_entry_point
49  */
50 static void set_entry_point( HMODULE module, const char *name, DWORD rva )
51 {
52     IMAGE_EXPORT_DIRECTORY *exports;
53     DWORD exp_size;
54
55     if ((exports = RtlImageDirectoryEntryToData( module, TRUE,
56                                                   IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size )))
57     {
58         DWORD *functions = (DWORD *)((char *)module + exports->AddressOfFunctions);
59         const WORD *ordinals = (const WORD *)((const char *)module + exports->AddressOfNameOrdinals);
60         const DWORD *names = (const DWORD *)((const char *)module +  exports->AddressOfNames);
61         int min = 0, max = exports->NumberOfNames - 1;
62
63         while (min <= max)
64         {
65             int res, pos = (min + max) / 2;
66             const char *ename = (const char *)module + names[pos];
67             if (!(res = strcmp( ename, name )))
68             {
69                 WORD ordinal = ordinals[pos];
70                 assert( ordinal < exports->NumberOfFunctions );
71                 TRACE( "setting %s at %p to %08x\n", name, &functions[ordinal], rva );
72                 functions[ordinal] = rva;
73                 return;
74             }
75             if (res > 0) max = pos - 1;
76             else min = pos + 1;
77         }
78     }
79 }
80
81
82 /***********************************************************************
83  *           KERNEL process initialisation routine
84  */
85 static BOOL process_attach( HMODULE module )
86 {
87     SYSTEM_TIMEOFDAY_INFORMATION ti;
88     RTL_USER_PROCESS_PARAMETERS *params = NtCurrentTeb()->Peb->ProcessParameters;
89
90     NtQuerySystemInformation( SystemTimeOfDayInformation, &ti, sizeof(ti), NULL );
91     server_start_time = ti.liKeBootTime.QuadPart;
92
93     /* Setup registry locale information */
94     LOCALE_InitRegistry();
95
96     /* Setup computer name */
97     COMPUTERNAME_Init();
98
99     /* convert value from server:
100      * + 0 => INVALID_HANDLE_VALUE
101      * + console handle needs to be mapped
102      */
103     if (!params->hStdInput)
104         params->hStdInput = INVALID_HANDLE_VALUE;
105     else if (VerifyConsoleIoHandle(console_handle_map(params->hStdInput)))
106         params->hStdInput = console_handle_map(params->hStdInput);
107
108     if (!params->hStdOutput)
109         params->hStdOutput = INVALID_HANDLE_VALUE;
110     else if (VerifyConsoleIoHandle(console_handle_map(params->hStdOutput)))
111         params->hStdOutput = console_handle_map(params->hStdOutput);
112
113     if (!params->hStdError)
114         params->hStdError = INVALID_HANDLE_VALUE;
115     else if (VerifyConsoleIoHandle(console_handle_map(params->hStdError)))
116         params->hStdError = console_handle_map(params->hStdError);
117
118     /* copy process information from ntdll */
119     ENV_CopyStartupInformation();
120
121     if (!(GetVersion() & 0x80000000))
122     {
123         /* Securom checks for this one when version is NT */
124         set_entry_point( module, "FT_Thunk", 0 );
125     }
126 #ifdef __i386__
127     else
128     {
129         /* create the shared heap for broken win95 native dlls */
130         HeapCreate( HEAP_SHARED, 0, 0 );
131     }
132 #endif
133
134     /* finish the process initialisation for console bits, if needed */
135     __wine_set_signal_handler(SIGINT, CONSOLE_HandleCtrlC);
136
137     if (params->ConsoleHandle == (HANDLE)1)  /* FIXME */
138     {
139         HMODULE mod = GetModuleHandleA(0);
140         if (RtlImageNtHeader(mod)->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
141             AllocConsole();
142     }
143     /* else TODO for DETACHED_PROCESS:
144      * 1/ inherit console + handles
145      * 2/ create std handles, if handles are not inherited
146      * TBD when not using wineserver handles for console handles
147      */
148
149     LoadLibraryA( "krnl386.exe16" );
150     return TRUE;
151 }
152
153 /***********************************************************************
154  *           KERNEL initialisation routine
155  */
156 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
157 {
158     switch(reason)
159     {
160     case DLL_PROCESS_ATTACH:
161         DisableThreadLibraryCalls( hinst );
162         return process_attach( hinst );
163     case DLL_PROCESS_DETACH:
164         WritePrivateProfileSectionW( NULL, NULL, NULL );
165         break;
166     }
167     return TRUE;
168 }
169
170 /***********************************************************************
171  *           MulDiv   (KERNEL32.@)
172  * RETURNS
173  *      Result of multiplication and division
174  *      -1: Overflow occurred or Divisor was 0
175  */
176 INT WINAPI MulDiv( INT nMultiplicand, INT nMultiplier, INT nDivisor)
177 {
178     LONGLONG ret;
179
180     if (!nDivisor) return -1;
181
182     /* We want to deal with a positive divisor to simplify the logic. */
183     if (nDivisor < 0)
184     {
185       nMultiplicand = - nMultiplicand;
186       nDivisor = -nDivisor;
187     }
188
189     /* If the result is positive, we "add" to round. else, we subtract to round. */
190     if ( ( (nMultiplicand <  0) && (nMultiplier <  0) ) ||
191          ( (nMultiplicand >= 0) && (nMultiplier >= 0) ) )
192       ret = (((LONGLONG)nMultiplicand * nMultiplier) + (nDivisor/2)) / nDivisor;
193     else
194       ret = (((LONGLONG)nMultiplicand * nMultiplier) - (nDivisor/2)) / nDivisor;
195
196     if ((ret > 2147483647) || (ret < -2147483647)) return -1;
197     return ret;
198 }
199
200
201 /******************************************************************************
202  *           GetTickCount64       (KERNEL32.@)
203  */
204 ULONGLONG WINAPI GetTickCount64(void)
205 {
206     LARGE_INTEGER now;
207
208     NtQuerySystemTime( &now );
209     return (now.QuadPart - server_start_time) / 10000;
210 }
211
212
213 /***********************************************************************
214  *           GetTickCount       (KERNEL32.@)
215  *
216  * Get the number of milliseconds the system has been running.
217  *
218  * PARAMS
219  *  None.
220  *
221  * RETURNS
222  *  The current tick count.
223  *
224  * NOTES
225  *  The value returned will wrap around every 2^32 milliseconds.
226  *  Under Windows, tick 0 is the moment at which the system is rebooted.
227  *  Under Wine, tick 0 begins at the moment the wineserver process is started.
228  */
229 DWORD WINAPI GetTickCount(void)
230 {
231     return GetTickCount64();
232 }