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