libs/loader/ext.c

   1 /********************************************************
   2  *
   3  *
   4  *      Stub functions for Wine module
   5  *
   6  *
   7  ********************************************************/
   8
   9 /*
  10  * Modified for use with MPlayer, detailed CVS changelog at
  11  * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
  12  * $Id$
  13  */
  14
  15 #include "config.h"
  16 #include <stdio.h>
  17 #include <stdlib.h>
  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>
  27 #include <ctype.h>
  28
  29 #include "wine/windef.h"
  30 #include "wine/winbase.h"
  31 #include "wine/debugtools.h"
  32 #include "wine/heap.h"
  33 #include "ext.h"
  34
  35 #if 0
  36 //REMOVE SIMPLIFY
  37 static void* mymalloc(unsigned int size)
  38 {
  39     printf("malloc %d\n", size);
  40     return malloc(size);
  41 }
  42
  43 #undef malloc
  44 #define malloc mymalloc
  45 #endif
  46
  47 int dbg_header_err( const char *dbg_channel, const char *func )
  48 {
  49     return 0;
  50 }
  51 int dbg_header_warn( const char *dbg_channel, const char *func )
  52 {
  53     return 0;
  54 }
  55 int dbg_header_fixme( const char *dbg_channel, const char *func )
  56 {
  57     return 0;
  58 }
  59 int dbg_header_trace( const char *dbg_channel, const char *func )
  60 {
  61     return 0;
  62 }
  63 int dbg_vprintf( const char *format, va_list args )
  64 {
  65     return 0;
  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
  75     return 0;
  76 }
  77
  78 HANDLE WINAPI GetProcessHeap(void)
  79 {
  80     return 1;
  81 }
  82
  83 LPVOID WINAPI HeapAlloc(HANDLE heap, DWORD flags, DWORD size)
  84 {
  85     static int i = 5;
  86     void* m = (flags & 0x8) ? calloc(size, 1) : malloc(size);
  87     //printf("HeapAlloc %p  %d  (%d)\n", m, size, flags);
  88     //if (--i == 0)
  89     //    abort();
  90     return m;
  91 }
  92
  93 WIN_BOOL WINAPI HeapFree(HANDLE heap, DWORD flags, LPVOID mem)
  94 {
  95     if (mem) free(mem);
  96     //printf("HeapFree  %p\n", mem);
  97     //if (!mem)
  98     //    abort();
  99     return 1;
 100 }
 101
 102 static int last_error;
 103
 104 DWORD WINAPI GetLastError(void)
 105 {
 106     return last_error;
 107 }
 108
 109 VOID WINAPI SetLastError(DWORD error)
 110 {
 111     last_error=error;
 112 }
 113
 114 WIN_BOOL WINAPI ReadFile(HANDLE handle, LPVOID mem, DWORD size, LPDWORD result, LPOVERLAPPED flags)
 115 {
 116     *result=read(handle, mem, size);
 117     return *result;
 118 }
 119 INT WINAPI lstrcmpiA(LPCSTR c1, LPCSTR c2)
 120 {
 121     return strcasecmp(c1,c2);
 122 }
 123 LPSTR WINAPI lstrcpynA(LPSTR dest, LPCSTR src, INT num)
 124 {
 125     return strncpy(dest,src,num);
 126 }
 127 INT WINAPI lstrlenA(LPCSTR s)
 128 {
 129     return strlen(s);
 130 }
 131 INT WINAPI lstrlenW(LPCWSTR s)
 132 {
 133     int l;
 134     if(!s)
 135         return 0;
 136     l=0;
 137     while(s[l])
 138         l++;
 139      return l;
 140 }
 141 LPSTR WINAPI lstrcpynWtoA(LPSTR dest, LPCWSTR src, INT count)
 142 {
 143     LPSTR result = dest;
 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)
 152             break;
 153         src++;
 154         dest++;
 155     }
 156     return result;
 157 }
 158 /* i stands here for ignore case! */
 159 int wcsnicmp(const unsigned short* s1, const unsigned short* s2, int n)
 160 {
 161     /*
 162     if(s1==0)
 163         return;
 164     if(s2==0)
 165         return;
 166     */
 167     while(n>0)
 168     {
 169         if (((*s1 | *s2) & 0xff00) || toupper((char)*s1) != toupper((char)*s2))
 170         {
 171
 172             if(*s1<*s2)
 173                 return -1;
 174             else
 175                 if(*s1>*s2)
 176                     return 1;
 177                 else
 178                     if(*s1==0)
 179                         return 0;
 180         }
 181         s1++;
 182         s2++;
 183         n--;
 184     }
 185     return 0;
 186 }
 187
 188 WIN_BOOL WINAPI IsBadReadPtr(LPCVOID data, UINT size)
 189 {
 190     if(size==0)
 191         return 0;
 192     if(data==NULL)
 193         return 1;
 194     return 0;
 195 }
 196 LPSTR HEAP_strdupA(HANDLE heap, DWORD flags, LPCSTR string)
 197 {
 198 //    return strdup(string);
 199     char* answ = (char*) malloc(strlen(string) + 1);
 200     strcpy(answ, string);
 201     return answ;
 202 }
 203 LPWSTR HEAP_strdupAtoW(HANDLE heap, DWORD flags, LPCSTR string)
 204 {
 205     int size, i;
 206     WCHAR* answer;
 207     if(string==0)
 208         return 0;
 209     size=strlen(string);
 210     answer = (WCHAR*) malloc(sizeof(WCHAR) * (size + 1));
 211     for(i=0; i<=size; i++)
 212         answer[i]=(short)string[i];
 213     return answer;
 214 }
 215 LPSTR HEAP_strdupWtoA(HANDLE heap, DWORD flags, LPCWSTR string)
 216 {
 217     int size, i;
 218     char* answer;
 219     if(string==0)
 220         return 0;
 221     size=0;
 222     while(string[size])
 223        size++;
 224     answer = (char*) malloc(size + 2);
 225     for(i=0; i<=size; i++)
 226         answer[i]=(char)string[i];
 227     return answer;
 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             {
 261                 perror( "Cannot open /dev/zero for READ. Check permissions! error: " );
 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);
 283 //      printf("%x\n", ret);
 284             return ret;
 285     }
 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;
 344     LPVOID handle;
 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
 363 HANDLE WINAPI CreateFileMappingA(HANDLE handle, LPSECURITY_ATTRIBUTES lpAttr,
 364                                  DWORD flProtect,
 365                                  DWORD dwMaxHigh, DWORD dwMaxLow,
 366                                  LPCSTR name)
 367 {
 368     int hFile = (int)handle;
 369     unsigned int len;
 370     LPVOID answer;
 371     int anon=0;
 372     int mmap_access=0;
 373     if(hFile<0)
 374     {
 375         anon=1;
 376         hFile=open("/dev/zero", O_RDWR);
 377         if(hFile<0){
 378             perror( "Cannot open /dev/zero for READ+WRITE. Check permissions! error: " );
 379             return 0;
 380         }
 381     }
 382     if(!anon)
 383     {
 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;
 393
 394     answer=mmap(NULL, len, mmap_access, MAP_PRIVATE, hFile, 0);
 395     if(anon)
 396         close(hFile);
 397     if(answer!=(LPVOID)-1)
 398     {
 399         if(fm==0)
 400         {
 401             fm = (file_mapping*) malloc(sizeof(file_mapping));
 402             fm->prev=NULL;
 403         }
 404         else
 405         {
 406             fm->next = (file_mapping*) malloc(sizeof(file_mapping));
 407             fm->next->prev=fm;
 408             fm=fm->next;
 409         }
 410         fm->next=NULL;
 411         fm->handle=answer;
 412         if(name)
 413         {
 414             fm->name = (char*) malloc(strlen(name)+1);
 415             strcpy(fm->name, name);
 416         }
 417         else
 418             fm->name=NULL;
 419         fm->mapping_size=len;
 420
 421         if(anon)
 422             close(hFile);
 423         return (HANDLE)answer;
 424     }
 425     return (HANDLE)0;
 426 }
 427 WIN_BOOL WINAPI UnmapViewOfFile(LPVOID handle)
 428 {
 429     file_mapping* p;
 430     int result;
 431     if(fm==0)
 432         return 0;
 433     for(p=fm; p; p=p->next)
 434     {
 435         if(p->handle==handle)
 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;
 446         }
 447     }
 448     return 0;
 449 }
 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
 464 LPVOID WINAPI VirtualAlloc(LPVOID address, DWORD size, DWORD type,  DWORD protection)
 465 {
 466     void* answer;
 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);
 475     if(fd<0){
 476         perror( "Cannot open /dev/zero for READ+WRITE. Check permissions! error: " );
 477         return NULL;
 478     }
 479
 480     if (type&MEM_RESERVE && (unsigned)address&0xffff) {
 481         size += (unsigned)address&0xffff;
 482         address = (unsigned)address&~0xffff;
 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
 493     if(address!=0)
 494     {
 495     //check whether we can allow to allocate this
 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;
 503             }
 504             if((unsigned)address+size<=(unsigned)str->address)
 505             {
 506                 str=str->prev;
 507                 continue;
 508             }
 509             if(str->state==0)
 510             {
 511 #warning FIXME
 512                 if(   ((unsigned)address >= (unsigned)str->address)
 513                    && ((unsigned)address+size<=(unsigned)str->address+str->mapping_size)
 514                    && (type & MEM_COMMIT))
 515                 {
 516                     close(fd);
 517                     return address; //returning previously reserved memory
 518                 }
 519                 //printf(" VirtualAlloc(...) does not commit or not entirely within reserved, and\n");
 520             }
 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);*/
 523             close(fd);
 524             return NULL;
 525         }
 526     }
 527
 528     answer=mmap(address, size, PROT_READ | PROT_WRITE | PROT_EXEC,
 529                 MAP_PRIVATE, fd, 0);
 530 //    answer=FILE_dommap(-1, address, 0, size, 0, 0,
 531 //      PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
 532     close(fd);
 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     }
 542     if(answer==(void*)-1)
 543     {
 544         /*printf(" VirtualAlloc(...) mmap(0x%08X, %u, ...) failed with errno=%d (\"%s\")\n",
 545                (unsigned)address, size, errno, strerror(errno));*/
 546         return NULL;
 547     }
 548     else
 549     {
 550         virt_alloc *new_vm = (virt_alloc*) malloc(sizeof(virt_alloc));
 551         new_vm->mapping_size=size;
 552         new_vm->address=(char*)answer;
 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;
 562         //if(va_size!=0)
 563         //    printf("Multiple VirtualAlloc!\n");
 564         //printf(" VirtualAlloc(...) provides (0x%08X, %u)\n", (unsigned)answer, size);
 565         return answer;
 566     }
 567 }
 568
 569 WIN_BOOL WINAPI VirtualFree(LPVOID  address, SIZE_T dwSize, DWORD dwFreeType)//not sure
 570 {
 571     virt_alloc* str=vm;
 572     int answer;
 573
 574     //printf("VirtualFree(0x%08X, %d, 0x%08X)\n", (unsigned)address, dwSize, dwFreeType);
 575     while(str)
 576     {
 577         if(address!=str->address)
 578         {
 579             str=str->prev;
 580             continue;
 581         }
 582         //printf(" VirtualFree(...) munmap(0x%08X, %d)\n", (unsigned)str->address, str->mapping_size);
 583         answer=munmap(str->address, str->mapping_size);
 584         if(str->next)str->next->prev=str->prev;
 585         if(str->prev)str->prev->next=str->next;
 586         if(vm==str)vm=str->prev;
 587         free(str);
 588         return 0;
 589     }
 590     return -1;
 591 }
 592
 593 INT WINAPI WideCharToMultiByte(UINT codepage, DWORD flags, LPCWSTR src,
 594      INT srclen,LPSTR dest, INT destlen, LPCSTR defch, WIN_BOOL* used_defch)
 595 {
 596     int i;
 597     if(src==0)
 598         return 0;
 599     if ((srclen==-1)&&(dest==0)) return 0;
 600     if(srclen==-1){srclen=0; while(src[srclen++]);}
 601 //    for(i=0; i<srclen; i++)
 602 //      printf("%c", src[i]);
 603 //    printf("\n");
 604     if(dest==0)
 605     {
 606     for(i=0; i<srclen; i++)
 607     {
 608         src++;
 609         if(*src==0)
 610             return i+1;
 611     }
 612         return srclen+1;
 613     }
 614     if(used_defch)
 615         *used_defch=0;
 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;
 623     }
 624     return min(srclen, destlen);
 625 }
 626 INT WINAPI MultiByteToWideChar(UINT codepage,DWORD flags, LPCSTR src, INT srclen,
 627     LPWSTR dest, INT destlen)
 628 {
 629     return 0;
 630 }
 631 HANDLE WINAPI OpenFileMappingA(DWORD access, WIN_BOOL prot, LPCSTR name)
 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)
 643             return (HANDLE)p->handle;
 644     }
 645     return 0;
 646 }