loader/ext.c

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