git.oblomov.eu Git - wine/blob - library/port.c

   1 /*
   2  * Misc. functions for systems that don't have them
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #ifdef __BEOS__
  10 #include <be/kernel/fs_info.h>
  11 #include <be/kernel/OS.h>
  12 #endif
  13
  14 #include <assert.h>
  15 #include <ctype.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <unistd.h>
  19 #include <sys/types.h>
  20 #include <sys/time.h>
  21 #include <sys/stat.h>
  22 #include <sys/ioctl.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <termios.h>
  26 #ifdef HAVE_SYS_MMAN_H
  27 #include <sys/mman.h>
  28 #endif
  29 #ifdef HAVE_LIBIO_H
  30 # include <libio.h>
  31 #endif
  32 #ifdef HAVE_SYSCALL_H
  33 # include <syscall.h>
  34 #endif
  35 #ifdef HAVE_PTY_H
  36 # include <pty.h>
  37 #endif
  38 #ifdef HAVE_LIBUTIL_H
  39 # include <libutil.h>
  40 #endif
  41
  42 #include "wine/port.h"
  43
  44 /***********************************************************************
  45  *              usleep
  46  */
  47 #ifndef HAVE_USLEEP
  48 unsigned int usleep (unsigned int useconds)
  49 {
  50 #if defined(__EMX__)
  51     DosSleep(useconds);
  52     return 0;
  53 #elif defined(__BEOS__)
  54     return snooze(useconds);
  55 #elif defined(HAVE_SELECT)
  56     struct timeval delay;
  57
  58     delay.tv_sec = useconds / 1000000;
  59     delay.tv_usec = useconds % 1000000;
  60
  61     select( 0, 0, 0, 0, &delay );
  62     return 0;
  63 #else /* defined(__EMX__) || defined(__BEOS__) || defined(HAVE_SELECT) */
  64     errno = ENOSYS;
  65     return -1;
  66 #endif /* defined(__EMX__) || defined(__BEOS__) || defined(HAVE_SELECT) */
  67 }
  68 #endif /* HAVE_USLEEP */
  69
  70 /***********************************************************************
  71  *              memmove
  72  */
  73 #ifndef HAVE_MEMMOVE
  74 void *memmove( void *dest, const void *src, unsigned int len )
  75 {
  76     register char *dst = dest;
  77
  78     /* Use memcpy if not overlapping */
  79     if ((dst + len <= (char *)src) || ((char *)src + len <= dst))
  80     {
  81         memcpy( dst, src, len );
  82     }
  83     /* Otherwise do it the hard way (FIXME: could do better than this) */
  84     else if (dst < src)
  85     {
  86         while (len--) *dst++ = *((char *)src)++;
  87     }
  88     else
  89     {
  90         dst += len - 1;
  91         src = (char *)src + len - 1;
  92         while (len--) *dst-- = *((char *)src)--;
  93     }
  94     return dest;
  95 }
  96 #endif  /* HAVE_MEMMOVE */
  97
  98 /***********************************************************************
  99  *              strerror
 100  */
 101 #ifndef HAVE_STRERROR
 102 const char *strerror( int err )
 103 {
 104     /* Let's hope we have sys_errlist then */
 105     return sys_errlist[err];
 106 }
 107 #endif  /* HAVE_STRERROR */
 108
 109
 110 /***********************************************************************
 111  *              getpagesize
 112  */
 113 #ifndef HAVE_GETPAGESIZE
 114 size_t getpagesize(void)
 115 {
 116 # ifdef __svr4__
 117     return sysconf(_SC_PAGESIZE);
 118 # else
 119 #  error Cannot get the page size on this platform
 120 # endif
 121 }
 122 #endif  /* HAVE_GETPAGESIZE */
 123
 124
 125 /***********************************************************************
 126  *              clone
 127  */
 128 #if !defined(HAVE_CLONE) && defined(__linux__)
 129 int clone( int (*fn)(void *), void *stack, int flags, void *arg )
 130 {
 131 #ifdef __i386__
 132     int ret;
 133     void **stack_ptr = (void **)stack;
 134     *--stack_ptr = arg;  /* Push argument on stack */
 135     *--stack_ptr = fn;   /* Push function pointer (popped into ebx) */
 136     __asm__ __volatile__( "pushl %%ebx\n\t"
 137                           "movl %2,%%ebx\n\t"
 138                           "int $0x80\n\t"
 139                           "popl %%ebx\n\t"   /* Contains fn in the child */
 140                           "testl %%eax,%%eax\n\t"
 141                           "jnz 0f\n\t"
 142                           "call *%%ebx\n\t"       /* Should never return */
 143                           "xorl %%eax,%%eax\n\t"  /* Just in case it does*/
 144                           "0:"
 145                           : "=a" (ret)
 146                           : "0" (SYS_clone), "r" (flags), "c" (stack_ptr) );
 147     assert( ret );  /* If ret is 0, we returned from the child function */
 148     if (ret > 0) return ret;
 149     errno = -ret;
 150     return -1;
 151 #else
 152     errno = EINVAL;
 153     return -1;
 154 #endif  /* __i386__ */
 155 }
 156 #endif  /* !HAVE_CLONE && __linux__ */
 157
 158 /***********************************************************************
 159  *              strcasecmp
 160  */
 161 #ifndef HAVE_STRCASECMP
 162 int strcasecmp( const char *str1, const char *str2 )
 163 {
 164     while (*str1 && toupper(*str1) == toupper(*str2)) { str1++; str2++; }
 165     return toupper(*str1) - toupper(*str2);
 166 }
 167 #endif /* HAVE_STRCASECMP */
 168
 169 /***********************************************************************
 170  *              strncasecmp
 171  */
 172 #ifndef HAVE_STRNCASECMP
 173 int strncasecmp( const char *str1, const char *str2, size_t n )
 174 {
 175     int res;
 176     if (!n) return 0;
 177     while ((--n > 0) && *str1)
 178       if ((res = toupper(*str1++) - toupper(*str2++))) return res;
 179     return toupper(*str1) - toupper(*str2);
 180 }
 181 #endif /* HAVE_STRNCASECMP */
 182
 183 /***********************************************************************
 184  *              wine_openpty
 185  * NOTE
 186  *   It looks like the openpty that comes with glibc in RedHat 5.0
 187  *   is buggy (second call returns what looks like a dup of 0 and 1
 188  *   instead of a new pty), this is a generic replacement.
 189  *
 190  * FIXME
 191  *   We should have a autoconf check for this.
 192  */
 193 int wine_openpty(int *master, int *slave, char *name,
 194                  struct termios *term, struct winsize *winsize)
 195 {
 196 #ifdef HAVE_OPENPTY
 197     return openpty(master,slave,name,term,winsize);
 198 #else
 199     char *ptr1, *ptr2;
 200     char pts_name[512];
 201
 202     strcpy (pts_name, "/dev/ptyXY");
 203
 204     for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1 != 0; ptr1++) {
 205         pts_name[8] = *ptr1;
 206         for (ptr2 = "0123456789abcdef"; *ptr2 != 0; ptr2++) {
 207             pts_name[9] = *ptr2;
 208
 209             if ((*master = open(pts_name, O_RDWR)) < 0) {
 210                 if (errno == ENOENT)
 211                     return -1;
 212                 else
 213                     continue;
 214             }
 215             pts_name[5] = 't';
 216             if ((*slave = open(pts_name, O_RDWR)) < 0) {
 217                 pts_name[5] = 'p';
 218                 continue;
 219             }
 220
 221             if (term != NULL)
 222                 tcsetattr(*slave, TCSANOW, term);
 223             if (winsize != NULL)
 224                 ioctl(*slave, TIOCSWINSZ, winsize);
 225             if (name != NULL)
 226                 strcpy(name, pts_name);
 227             return *slave;
 228         }
 229     }
 230     return -1;
 231 #endif
 232 }
 233
 234 /***********************************************************************
 235  *              getnetbyaddr
 236  */
 237 #ifndef HAVE_GETNETBYADDR
 238 struct netent *getnetbyaddr(unsigned long net, int type)
 239 {
 240     errno = ENOSYS;
 241     return NULL;
 242 }
 243 #endif /* defined(HAVE_GETNETBYNAME) */
 244
 245 /***********************************************************************
 246  *              getnetbyname
 247  */
 248 #ifndef HAVE_GETNETBYNAME
 249 struct netent *getnetbyname(const char *name)
 250 {
 251     errno = ENOSYS;
 252     return NULL;
 253 }
 254 #endif /* defined(HAVE_GETNETBYNAME) */
 255
 256 /***********************************************************************
 257  *              getprotobyname
 258  */
 259 #ifndef HAVE_GETPROTOBYNAME
 260 struct protoent *getprotobyname(const char *name)
 261 {
 262     errno = ENOSYS;
 263     return NULL;
 264 }
 265 #endif /* !defined(HAVE_GETPROTOBYNAME) */
 266
 267 /***********************************************************************
 268  *              getprotobynumber
 269  */
 270 #ifndef HAVE_GETPROTOBYNUMBER
 271 struct protoent *getprotobynumber(int proto)
 272 {
 273     errno = ENOSYS;
 274     return NULL;
 275 }
 276 #endif /* !defined(HAVE_GETPROTOBYNUMBER) */
 277
 278 /***********************************************************************
 279  *              getservbyport
 280  */
 281 #ifndef HAVE_GETSERVBYPORT
 282 struct servent *getservbyport(int port, const char *proto)
 283 {
 284     errno = ENOSYS;
 285     return NULL;
 286 }
 287 #endif /* !defined(HAVE_GETSERVBYPORT) */
 288
 289 /***********************************************************************
 290  *              getsockopt
 291  */
 292 #ifndef HAVE_GETSOCKOPT
 293 int getsockopt(int socket, int level, int option_name,
 294                void *option_value, size_t *option_len)
 295 {
 296     errno = ENOSYS;
 297     return -1;
 298 }
 299 #endif /* !defined(HAVE_GETSOCKOPT) */
 300
 301 /***********************************************************************
 302  *              inet_network
 303  */
 304 #ifndef HAVE_INET_NETWORK
 305 unsigned long inet_network(const char *cp)
 306 {
 307     errno = ENOSYS;
 308     return 0;
 309 }
 310 #endif /* defined(HAVE_INET_NETWORK) */
 311
 312 /***********************************************************************
 313  *              settimeofday
 314  */
 315 #ifndef HAVE_SETTIMEOFDAY
 316 int settimeofday(struct timeval *tp, void *reserved)
 317 {
 318     tp->tv_sec = 0;
 319     tp->tv_usec = 0;
 320
 321     errno = ENOSYS;
 322     return -1;
 323 }
 324 #endif /* HAVE_SETTIMEOFDAY */
 325
 326 /***********************************************************************
 327  *              statfs
 328  */
 329 #ifndef HAVE_STATFS
 330 int statfs(const char *name, struct statfs *info)
 331 {
 332 #ifdef __BEOS__
 333     dev_t mydev;
 334     fs_info fsinfo;
 335
 336     if(!info) {
 337         errno = ENOSYS;
 338         return -1;
 339     }
 340
 341     if ((mydev = dev_for_path(name)) < 0) {
 342         errno = ENOSYS;
 343         return -1;
 344     }
 345
 346     if (fs_stat_dev(mydev,&fsinfo) < 0) {
 347         errno = ENOSYS;
 348         return -1;
 349     }
 350
 351     info->f_bsize = fsinfo.block_size;
 352     info->f_blocks = fsinfo.total_blocks;
 353     info->f_bfree = fsinfo.free_blocks;
 354     return 0;
 355 #else /* defined(__BEOS__) */
 356     errno = ENOSYS;
 357     return -1;
 358 #endif /* defined(__BEOS__) */
 359 }
 360 #endif /* !defined(HAVE_STATFS) */
 361
 362
 363 /***********************************************************************
 364  *              lstat
 365  */
 366 #ifndef HAVE_LSTAT
 367 int lstat(const char *file_name, struct stat *buf)
 368 {
 369     return stat( file_name, buf );
 370 }
 371 #endif /* HAVE_LSTAT */
 372
 373
 374 /***********************************************************************
 375  *              getrlimit
 376  */
 377 #ifndef HAVE_GETRLIMIT
 378 int getrlimit (int resource, struct rlimit *rlim)
 379 {
 380     return -1; /* FAIL */
 381 }
 382 #endif /* HAVE_GETRLIMIT */
 383
 384 /***********************************************************************
 385  *              wine_anon_mmap
 386  *
 387  * Portable wrapper for anonymous mmaps
 388  */
 389 void *wine_anon_mmap( void *start, size_t size, int prot, int flags )
 390 {
 391     static int fdzero = -1;
 392
 393 #ifdef MAP_ANON
 394     flags |= MAP_ANON;
 395 #else
 396     if (fdzero == -1)
 397     {
 398         if ((fdzero = open( "/dev/zero", O_RDONLY )) == -1)
 399         {
 400             perror( "/dev/zero: open" );
 401             exit(1);
 402         }
 403     }
 404 #endif  /* MAP_ANON */
 405     /* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */
 406 #ifdef MAP_SHARED
 407     flags &= ~MAP_SHARED;
 408 #endif
 409 #ifdef MAP_PRIVATE
 410     flags |= MAP_PRIVATE;
 411 #endif
 412     return mmap( start, size, prot, flags, fdzero, 0 );
 413 }