Mercurial > mplayer.hg
annotate loader/ext.c @ 17026:3c4b93bc0db3
10l
author | lorenm |
---|---|
date | Tue, 22 Nov 2005 05:32:28 +0000 |
parents | f5537cc95b02 |
children | 0783dd397f74 |
rev | line source |
---|---|
1 | 1 /******************************************************** |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
2 * |
1 | 3 * |
4 * Stub functions for Wine module | |
5 * | |
6 * | |
7 ********************************************************/ | |
15166
f5537cc95b02
Mark modified imported files as such to comply with GPL ¡ø2a.
diego
parents:
13827
diff
changeset
|
8 |
f5537cc95b02
Mark modified imported files as such to comply with GPL ¡ø2a.
diego
parents:
13827
diff
changeset
|
9 /* |
f5537cc95b02
Mark modified imported files as such to comply with GPL ¡ø2a.
diego
parents:
13827
diff
changeset
|
10 * Modified for use with MPlayer, detailed CVS changelog at |
f5537cc95b02
Mark modified imported files as such to comply with GPL ¡ø2a.
diego
parents:
13827
diff
changeset
|
11 * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/ |
f5537cc95b02
Mark modified imported files as such to comply with GPL ¡ø2a.
diego
parents:
13827
diff
changeset
|
12 * $Id$ |
f5537cc95b02
Mark modified imported files as such to comply with GPL ¡ø2a.
diego
parents:
13827
diff
changeset
|
13 */ |
f5537cc95b02
Mark modified imported files as such to comply with GPL ¡ø2a.
diego
parents:
13827
diff
changeset
|
14 |
3465 | 15 #include "config.h" |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
16 #include <stdio.h> |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
17 #include <stdlib.h> |
1 | 18 #ifdef HAVE_MALLOC_H |
19 #include <malloc.h> | |
20 #endif | |
21 #include <unistd.h> | |
22 #include <sys/mman.h> | |
23 #include <errno.h> | |
24 #include <fcntl.h> | |
25 #include <string.h> | |
26 #include <stdarg.h> | |
3465 | 27 #include <ctype.h> |
7386 | 28 |
29 #include "wine/windef.h" | |
30 #include "wine/winbase.h" | |
31 #include "wine/debugtools.h" | |
32 #include "wine/heap.h" | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
33 #include "ext.h" |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
34 |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
35 #if 0 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
36 //REMOVE SIMPLIFY |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
37 static void* mymalloc(unsigned int size) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
38 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
39 printf("malloc %d\n", size); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
40 return malloc(size); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
41 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
42 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
43 #undef malloc |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
44 #define malloc mymalloc |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
45 #endif |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
46 |
1 | 47 int dbg_header_err( const char *dbg_channel, const char *func ) |
48 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
49 return 0; |
1 | 50 } |
51 int dbg_header_warn( const char *dbg_channel, const char *func ) | |
52 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
53 return 0; |
1 | 54 } |
55 int dbg_header_fixme( const char *dbg_channel, const char *func ) | |
56 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
57 return 0; |
1 | 58 } |
59 int dbg_header_trace( const char *dbg_channel, const char *func ) | |
60 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
61 return 0; |
1 | 62 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
63 int dbg_vprintf( const char *format, va_list args ) |
1 | 64 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
65 return 0; |
1 | 66 } |
67 int __vprintf( const char *format, ... ) | |
68 { | |
69 #ifdef DETAILED_OUT | |
70 va_list va; | |
71 va_start(va, format); | |
72 vprintf(format, va); | |
73 va_end(va); | |
74 #endif | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
75 return 0; |
1 | 76 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
77 |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
78 HANDLE WINAPI GetProcessHeap(void) |
1 | 79 { |
80 return 1; | |
81 } | |
82 | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
83 LPVOID WINAPI HeapAlloc(HANDLE heap, DWORD flags, DWORD size) |
1 | 84 { |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
85 static int i = 5; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
86 void* m = (flags & 0x8) ? calloc(size, 1) : malloc(size); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
87 //printf("HeapAlloc %p %d (%d)\n", m, size, flags); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
88 //if (--i == 0) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
89 // abort(); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
90 return m; |
1 | 91 } |
92 | |
2069 | 93 WIN_BOOL WINAPI HeapFree(HANDLE heap, DWORD flags, LPVOID mem) |
1 | 94 { |
128 | 95 if (mem) free(mem); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
96 //printf("HeapFree %p\n", mem); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
97 //if (!mem) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
98 // abort(); |
1 | 99 return 1; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
100 } |
1 | 101 |
102 static int last_error; | |
103 | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
104 DWORD WINAPI GetLastError(void) |
1 | 105 { |
106 return last_error; | |
107 } | |
108 | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
109 VOID WINAPI SetLastError(DWORD error) |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
110 { |
2069 | 111 last_error=error; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
112 } |
1 | 113 |
2069 | 114 WIN_BOOL WINAPI ReadFile(HANDLE handle, LPVOID mem, DWORD size, LPDWORD result, LPOVERLAPPED flags) |
1 | 115 { |
116 *result=read(handle, mem, size); | |
117 return *result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
118 } |
2069 | 119 INT WINAPI lstrcmpiA(LPCSTR c1, LPCSTR c2) |
1 | 120 { |
121 return strcasecmp(c1,c2); | |
122 } | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
123 LPSTR WINAPI lstrcpynA(LPSTR dest, LPCSTR src, INT num) |
1 | 124 { |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
125 return strncpy(dest,src,num); |
1 | 126 } |
2069 | 127 INT WINAPI lstrlenA(LPCSTR s) |
1 | 128 { |
129 return strlen(s); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
130 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
131 INT WINAPI lstrlenW(LPCWSTR s) |
1 | 132 { |
133 int l; | |
134 if(!s) | |
135 return 0; | |
136 l=0; | |
137 while(s[l]) | |
138 l++; | |
139 return l; | |
140 } | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
141 LPSTR WINAPI lstrcpynWtoA(LPSTR dest, LPCWSTR src, INT count) |
1 | 142 { |
2069 | 143 LPSTR result = dest; |
1 | 144 int moved=0; |
145 if((dest==0) || (src==0)) | |
146 return 0; | |
147 while(moved<count) | |
148 { | |
149 *dest=*src; | |
150 moved++; | |
151 if(*src==0) | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
152 break; |
1 | 153 src++; |
154 dest++; | |
155 } | |
2069 | 156 return result; |
1 | 157 } |
3465 | 158 /* i stands here for ignore case! */ |
1 | 159 int wcsnicmp(const unsigned short* s1, const unsigned short* s2, int n) |
160 { | |
2069 | 161 /* |
1 | 162 if(s1==0) |
163 return; | |
164 if(s2==0) | |
165 return; | |
2069 | 166 */ |
1 | 167 while(n>0) |
168 { | |
3465 | 169 if (((*s1 | *s2) & 0xff00) || toupper((char)*s1) != toupper((char)*s2)) |
170 { | |
171 | |
172 if(*s1<*s2) | |
173 return -1; | |
1 | 174 else |
3465 | 175 if(*s1>*s2) |
176 return 1; | |
177 else | |
178 if(*s1==0) | |
179 return 0; | |
180 } | |
181 s1++; | |
182 s2++; | |
183 n--; | |
1 | 184 } |
185 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
186 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
187 |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
188 WIN_BOOL WINAPI IsBadReadPtr(LPCVOID data, UINT size) |
1 | 189 { |
190 if(size==0) | |
191 return 0; | |
192 if(data==NULL) | |
193 return 1; | |
194 return 0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
195 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
196 LPSTR HEAP_strdupA(HANDLE heap, DWORD flags, LPCSTR string) |
1 | 197 { |
198 // return strdup(string); | |
7386 | 199 char* answ = (char*) malloc(strlen(string) + 1); |
1 | 200 strcpy(answ, string); |
201 return answ; | |
202 } | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
203 LPWSTR HEAP_strdupAtoW(HANDLE heap, DWORD flags, LPCSTR string) |
1 | 204 { |
205 int size, i; | |
7386 | 206 WCHAR* answer; |
1 | 207 if(string==0) |
208 return 0; | |
209 size=strlen(string); | |
7386 | 210 answer = (WCHAR*) malloc(sizeof(WCHAR) * (size + 1)); |
1 | 211 for(i=0; i<=size; i++) |
212 answer[i]=(short)string[i]; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
213 return answer; |
1 | 214 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
215 LPSTR HEAP_strdupWtoA(HANDLE heap, DWORD flags, LPCWSTR string) |
1 | 216 { |
217 int size, i; | |
218 char* answer; | |
219 if(string==0) | |
220 return 0; | |
221 size=0; | |
222 while(string[size]) | |
223 size++; | |
7386 | 224 answer = (char*) malloc(size + 2); |
1 | 225 for(i=0; i<=size; i++) |
226 answer[i]=(char)string[i]; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
227 return answer; |
1 | 228 } |
229 | |
230 /*********************************************************************** | |
231 * FILE_dommap | |
232 */ | |
233 | |
234 //#define MAP_PRIVATE | |
235 //#define MAP_SHARED | |
236 #undef MAP_ANON | |
237 LPVOID FILE_dommap( int unix_handle, LPVOID start, | |
238 DWORD size_high, DWORD size_low, | |
239 DWORD offset_high, DWORD offset_low, | |
240 int prot, int flags ) | |
241 { | |
242 int fd = -1; | |
243 int pos; | |
244 LPVOID ret; | |
245 | |
246 if (size_high || offset_high) | |
247 printf("offsets larger than 4Gb not supported\n"); | |
248 | |
249 if (unix_handle == -1) | |
250 { | |
251 #ifdef MAP_ANON | |
252 // printf("Anonymous\n"); | |
253 flags |= MAP_ANON; | |
254 #else | |
255 static int fdzero = -1; | |
256 | |
257 if (fdzero == -1) | |
258 { | |
259 if ((fdzero = open( "/dev/zero", O_RDONLY )) == -1) | |
260 { | |
3775 | 261 perror( "Cannot open /dev/zero for READ. Check permissions! error: " ); |
1 | 262 exit(1); |
263 } | |
264 } | |
265 fd = fdzero; | |
266 #endif /* MAP_ANON */ | |
267 /* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */ | |
268 #ifdef MAP_SHARED | |
269 flags &= ~MAP_SHARED; | |
270 #endif | |
271 #ifdef MAP_PRIVATE | |
272 flags |= MAP_PRIVATE; | |
273 #endif | |
274 } | |
275 else fd = unix_handle; | |
276 // printf("fd %x, start %x, size %x, pos %x, prot %x\n",fd,start,size_low, offset_low, prot); | |
277 // if ((ret = mmap( start, size_low, prot, | |
278 // flags, fd, offset_low )) != (LPVOID)-1) | |
279 if ((ret = mmap( start, size_low, prot, | |
280 MAP_PRIVATE | MAP_FIXED, fd, offset_low )) != (LPVOID)-1) | |
281 { | |
282 // printf("address %08x\n", *(int*)ret); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
283 // printf("%x\n", ret); |
1 | 284 return ret; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
285 } |
1 | 286 |
287 // printf("mmap %d\n", errno); | |
288 | |
289 /* mmap() failed; if this is because the file offset is not */ | |
290 /* page-aligned (EINVAL), or because the underlying filesystem */ | |
291 /* does not support mmap() (ENOEXEC), we do it by hand. */ | |
292 | |
293 if (unix_handle == -1) return ret; | |
294 if ((errno != ENOEXEC) && (errno != EINVAL)) return ret; | |
295 if (prot & PROT_WRITE) | |
296 { | |
297 /* We cannot fake shared write mappings */ | |
298 #ifdef MAP_SHARED | |
299 if (flags & MAP_SHARED) return ret; | |
300 #endif | |
301 #ifdef MAP_PRIVATE | |
302 if (!(flags & MAP_PRIVATE)) return ret; | |
303 #endif | |
304 } | |
305 /* printf( "FILE_mmap: mmap failed (%d), faking it\n", errno );*/ | |
306 /* Reserve the memory with an anonymous mmap */ | |
307 ret = FILE_dommap( -1, start, size_high, size_low, 0, 0, | |
308 PROT_READ | PROT_WRITE, flags ); | |
309 if (ret == (LPVOID)-1) | |
310 // { | |
311 // perror( | |
312 return ret; | |
313 /* Now read in the file */ | |
314 if ((pos = lseek( fd, offset_low, SEEK_SET )) == -1) | |
315 { | |
316 FILE_munmap( ret, size_high, size_low ); | |
317 // printf("lseek\n"); | |
318 return (LPVOID)-1; | |
319 } | |
320 read( fd, ret, size_low ); | |
321 lseek( fd, pos, SEEK_SET ); /* Restore the file pointer */ | |
322 mprotect( ret, size_low, prot ); /* Set the right protection */ | |
323 // printf("address %08x\n", *(int*)ret); | |
324 return ret; | |
325 } | |
326 | |
327 | |
328 /*********************************************************************** | |
329 * FILE_munmap | |
330 */ | |
331 int FILE_munmap( LPVOID start, DWORD size_high, DWORD size_low ) | |
332 { | |
333 if (size_high) | |
334 printf("offsets larger than 4Gb not supported\n"); | |
335 return munmap( start, size_low ); | |
336 } | |
337 static int mapping_size=0; | |
338 | |
339 struct file_mapping_s; | |
340 typedef struct file_mapping_s | |
341 { | |
342 int mapping_size; | |
343 char* name; | |
2069 | 344 LPVOID handle; |
1 | 345 struct file_mapping_s* next; |
346 struct file_mapping_s* prev; | |
347 }file_mapping; | |
348 static file_mapping* fm=0; | |
349 | |
350 | |
351 | |
352 #define PAGE_NOACCESS 0x01 | |
353 #define PAGE_READONLY 0x02 | |
354 #define PAGE_READWRITE 0x04 | |
355 #define PAGE_WRITECOPY 0x08 | |
356 #define PAGE_EXECUTE 0x10 | |
357 #define PAGE_EXECUTE_READ 0x20 | |
358 #define PAGE_EXECUTE_READWRITE 0x40 | |
359 #define PAGE_EXECUTE_WRITECOPY 0x80 | |
360 #define PAGE_GUARD 0x100 | |
361 #define PAGE_NOCACHE 0x200 | |
362 | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
363 HANDLE WINAPI CreateFileMappingA(HANDLE handle, LPSECURITY_ATTRIBUTES lpAttr, |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
364 DWORD flProtect, |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
365 DWORD dwMaxHigh, DWORD dwMaxLow, |
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
366 LPCSTR name) |
1 | 367 { |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
368 int hFile = (int)handle; |
1 | 369 unsigned int len; |
2069 | 370 LPVOID answer; |
1 | 371 int anon=0; |
372 int mmap_access=0; | |
373 if(hFile<0) | |
374 { | |
375 anon=1; | |
376 hFile=open("/dev/zero", O_RDWR); | |
3775 | 377 if(hFile<0){ |
378 perror( "Cannot open /dev/zero for READ+WRITE. Check permissions! error: " ); | |
1 | 379 return 0; |
3775 | 380 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
381 } |
1 | 382 if(!anon) |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
383 { |
1 | 384 len=lseek(hFile, 0, SEEK_END); |
385 lseek(hFile, 0, SEEK_SET); | |
386 } | |
387 else len=dwMaxLow; | |
388 | |
389 if(flProtect & PAGE_READONLY) | |
390 mmap_access |=PROT_READ; | |
391 else | |
392 mmap_access |=PROT_READ|PROT_WRITE; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
393 |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
394 answer=mmap(NULL, len, mmap_access, MAP_PRIVATE, hFile, 0); |
1 | 395 if(anon) |
396 close(hFile); | |
2069 | 397 if(answer!=(LPVOID)-1) |
1 | 398 { |
399 if(fm==0) | |
400 { | |
7386 | 401 fm = (file_mapping*) malloc(sizeof(file_mapping)); |
1 | 402 fm->prev=NULL; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
403 } |
1 | 404 else |
405 { | |
7386 | 406 fm->next = (file_mapping*) malloc(sizeof(file_mapping)); |
1 | 407 fm->next->prev=fm; |
408 fm=fm->next; | |
409 } | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
410 fm->next=NULL; |
1 | 411 fm->handle=answer; |
412 if(name) | |
413 { | |
7386 | 414 fm->name = (char*) malloc(strlen(name)+1); |
1 | 415 strcpy(fm->name, name); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
416 } |
1 | 417 else |
418 fm->name=NULL; | |
419 fm->mapping_size=len; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
420 |
1 | 421 if(anon) |
422 close(hFile); | |
2069 | 423 return (HANDLE)answer; |
1 | 424 } |
425 return (HANDLE)0; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
426 } |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
427 WIN_BOOL WINAPI UnmapViewOfFile(LPVOID handle) |
1 | 428 { |
429 file_mapping* p; | |
430 int result; | |
431 if(fm==0) | |
2069 | 432 return 0; |
1 | 433 for(p=fm; p; p=p->next) |
434 { | |
2069 | 435 if(p->handle==handle) |
1 | 436 { |
437 result=munmap((void*)handle, p->mapping_size); | |
438 if(p->next)p->next->prev=p->prev; | |
439 if(p->prev)p->prev->next=p->next; | |
440 if(p->name) | |
441 free(p->name); | |
442 if(p==fm) | |
443 fm=p->prev; | |
444 free(p); | |
445 return result; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
446 } |
1 | 447 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
448 return 0; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
449 } |
1 | 450 //static int va_size=0; |
451 struct virt_alloc_s; | |
452 typedef struct virt_alloc_s | |
453 { | |
454 int mapping_size; | |
455 char* address; | |
456 struct virt_alloc_s* next; | |
457 struct virt_alloc_s* prev; | |
458 int state; | |
459 }virt_alloc; | |
460 static virt_alloc* vm=0; | |
461 #define MEM_COMMIT 0x00001000 | |
462 #define MEM_RESERVE 0x00002000 | |
463 | |
2069 | 464 LPVOID WINAPI VirtualAlloc(LPVOID address, DWORD size, DWORD type, DWORD protection) |
1 | 465 { |
466 void* answer; | |
13303 | 467 int fd; |
468 long pgsz; | |
469 | |
470 //printf("VirtualAlloc(0x%08X, %u, 0x%08X, 0x%08X)\n", (unsigned)address, size, type, protection); | |
471 | |
472 if ((type&(MEM_RESERVE|MEM_COMMIT)) == 0) return NULL; | |
473 | |
474 fd=open("/dev/zero", O_RDWR); | |
3775 | 475 if(fd<0){ |
476 perror( "Cannot open /dev/zero for READ+WRITE. Check permissions! error: " ); | |
477 return NULL; | |
478 } | |
13303 | 479 |
480 if (type&MEM_RESERVE && (unsigned)address&0xffff) { | |
481 size += (unsigned)address&0xffff; | |
13827 | 482 address = (unsigned)address&~0xffff; |
13303 | 483 } |
484 pgsz = sysconf(_SC_PAGESIZE); | |
485 if (type&MEM_COMMIT && (unsigned)address%pgsz) { | |
486 size += (unsigned)address%pgsz; | |
487 address -= (unsigned)address%pgsz; | |
488 } | |
489 | |
490 if (type&MEM_RESERVE && size<0x10000) size = 0x10000; | |
491 if (size%pgsz) size += pgsz - size%pgsz; | |
492 | |
1 | 493 if(address!=0) |
494 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
495 //check whether we can allow to allocate this |
1 | 496 virt_alloc* str=vm; |
497 while(str) | |
498 { | |
499 if((unsigned)address>=(unsigned)str->address+str->mapping_size) | |
500 { | |
501 str=str->prev; | |
502 continue; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
503 } |
13303 | 504 if((unsigned)address+size<=(unsigned)str->address) |
1 | 505 { |
506 str=str->prev; | |
507 continue; | |
508 } | |
509 if(str->state==0) | |
510 { | |
511 #warning FIXME | |
13303 | 512 if( ((unsigned)address >= (unsigned)str->address) |
513 && ((unsigned)address+size<=(unsigned)str->address+str->mapping_size) | |
514 && (type & MEM_COMMIT)) | |
1 | 515 { |
516 close(fd); | |
517 return address; //returning previously reserved memory | |
518 } | |
13303 | 519 //printf(" VirtualAlloc(...) does not commit or not entirely within reserved, and\n"); |
1 | 520 } |
13303 | 521 /*printf(" VirtualAlloc(...) (0x%08X, %u) overlaps with (0x%08X, %u, state=%d)\n", |
522 (unsigned)address, size, (unsigned)str->address, str->mapping_size, str->state);*/ | |
1 | 523 close(fd); |
524 return NULL; | |
525 } | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
526 } |
13303 | 527 |
528 answer=mmap(address, size, PROT_READ | PROT_WRITE | PROT_EXEC, | |
529 MAP_PRIVATE, fd, 0); | |
1 | 530 // answer=FILE_dommap(-1, address, 0, size, 0, 0, |
531 // PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE); | |
3134 | 532 close(fd); |
13303 | 533 if (answer != (void *)-1 && address && answer != address) { |
534 /* It is dangerous to try mmap() with MAP_FIXED since it does not | |
535 always detect conflicts or non-allocation and chaos ensues after | |
536 a successful call but an overlapping or non-allocated region. */ | |
537 munmap(answer, size); | |
538 answer = (void *) -1; | |
539 errno = EINVAL; | |
540 //printf(" VirtualAlloc(...) cannot satisfy requested address but address=NULL would work.\n"); | |
541 } | |
1 | 542 if(answer==(void*)-1) |
543 { | |
13306 | 544 /*printf(" VirtualAlloc(...) mmap(0x%08X, %u, ...) failed with errno=%d (\"%s\")\n", |
545 (unsigned)address, size, errno, strerror(errno));*/ | |
1 | 546 return NULL; |
547 } | |
548 else | |
549 { | |
7386 | 550 virt_alloc *new_vm = (virt_alloc*) malloc(sizeof(virt_alloc)); |
1 | 551 new_vm->mapping_size=size; |
7386 | 552 new_vm->address=(char*)answer; |
1 | 553 new_vm->prev=vm; |
554 if(type == MEM_RESERVE) | |
555 new_vm->state=0; | |
556 else | |
557 new_vm->state=1; | |
558 if(vm) | |
559 vm->next=new_vm; | |
560 vm=new_vm; | |
561 vm->next=0; | |
3134 | 562 //if(va_size!=0) |
563 // printf("Multiple VirtualAlloc!\n"); | |
13303 | 564 //printf(" VirtualAlloc(...) provides (0x%08X, %u)\n", (unsigned)answer, size); |
1 | 565 return answer; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
566 } |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
567 } |
13303 | 568 |
3134 | 569 WIN_BOOL WINAPI VirtualFree(LPVOID address, SIZE_T dwSize, DWORD dwFreeType)//not sure |
1 | 570 { |
571 virt_alloc* str=vm; | |
572 int answer; | |
13303 | 573 |
574 //printf("VirtualFree(0x%08X, %d, 0x%08X)\n", (unsigned)address, dwSize, dwFreeType); | |
1 | 575 while(str) |
576 { | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
577 if(address!=str->address) |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
578 { |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
579 str=str->prev; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
580 continue; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
581 } |
13303 | 582 //printf(" VirtualFree(...) munmap(0x%08X, %d)\n", (unsigned)str->address, str->mapping_size); |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
583 answer=munmap(str->address, str->mapping_size); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
584 if(str->next)str->next->prev=str->prev; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
585 if(str->prev)str->prev->next=str->next; |
3134 | 586 if(vm==str)vm=str->prev; |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
587 free(str); |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
588 return 0; |
1 | 589 } |
590 return -1; | |
591 } | |
592 | |
2069 | 593 INT WINAPI WideCharToMultiByte(UINT codepage, DWORD flags, LPCWSTR src, |
594 INT srclen,LPSTR dest, INT destlen, LPCSTR defch, WIN_BOOL* used_defch) | |
1 | 595 { |
596 int i; | |
597 if(src==0) | |
598 return 0; | |
2069 | 599 if ((srclen==-1)&&(dest==0)) return 0; |
128 | 600 if(srclen==-1){srclen=0; while(src[srclen++]);} |
601 // for(i=0; i<srclen; i++) | |
602 // printf("%c", src[i]); | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
603 // printf("\n"); |
1 | 604 if(dest==0) |
605 { | |
606 for(i=0; i<srclen; i++) | |
607 { | |
608 src++; | |
609 if(*src==0) | |
610 return i+1; | |
611 } | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
612 return srclen+1; |
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
613 } |
1 | 614 if(used_defch) |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
615 *used_defch=0; |
1 | 616 for(i=0; i<min(srclen, destlen); i++) |
617 { | |
618 *dest=(char)*src; | |
619 dest++; | |
620 src++; | |
621 if(*src==0) | |
622 return i+1; | |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
623 } |
1 | 624 return min(srclen, destlen); |
625 } | |
2069 | 626 INT WINAPI MultiByteToWideChar(UINT codepage,DWORD flags, LPCSTR src, INT srclen, |
627 LPWSTR dest, INT destlen) | |
1 | 628 { |
629 return 0; | |
630 } | |
1307
d8c1b0b38edc
Add prototypes to wine/loader stuff, so that we can catch __stdcall function
jkeil
parents:
128
diff
changeset
|
631 HANDLE WINAPI OpenFileMappingA(DWORD access, WIN_BOOL prot, LPCSTR name) |
1 | 632 { |
633 file_mapping* p; | |
634 if(fm==0) | |
635 return (HANDLE)0; | |
636 if(name==0) | |
637 return (HANDLE)0; | |
638 for(p=fm; p; p=p->prev) | |
639 { | |
640 if(p->name==0) | |
641 continue; | |
642 if(strcmp(p->name, name)==0) | |
2069 | 643 return (HANDLE)p->handle; |
1 | 644 } |
2651
958d10763c34
partially synced with avifile... (TODO: migrate to new registry.c and driver.c)
arpi
parents:
2069
diff
changeset
|
645 return 0; |
1 | 646 } |