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

   1 /*
   2  * Misc. functions for systems that don't have them
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include "wine/port.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_LIBIO_H
  27 # include <libio.h>
  28 #endif
  29 #ifdef HAVE_SYSCALL_H
  30 # include <syscall.h>
  31 #endif
  32 #ifdef HAVE_PTY_H
  33 # include <pty.h>
  34 #endif
  35
  36 /***********************************************************************
  37  *              usleep
  38  */
  39 #ifndef HAVE_USLEEP
  40 unsigned int usleep (unsigned int useconds)
  41 {
  42 #if defined(__EMX__)
  43     DosSleep(useconds);
  44     return 0;
  45 #elif defined(__BEOS__)
  46     return snooze(useconds);
  47 #elif defined(HAVE_SELECT)
  48     struct timeval delay;
  49
  50     delay.tv_sec = 0;
  51     delay.tv_usec = useconds;
  52
  53     select( 0, 0, 0, 0, &delay );
  54     return 0;
  55 #else /* defined(__EMX__) || defined(__BEOS__) || defined(HAVE_SELECT) */
  56     errno = ENOSYS;
  57     return -1;
  58 #endif /* defined(__EMX__) || defined(__BEOS__) || defined(HAVE_SELECT) */
  59 }
  60 #endif /* HAVE_USLEEP */
  61
  62 /***********************************************************************
  63  *              memmove
  64  */
  65 #ifndef HAVE_MEMMOVE
  66 void *memmove( void *dest, const void *src, unsigned int len )
  67 {
  68     register char *dst = dest;
  69
  70     /* Use memcpy if not overlapping */
  71     if ((dst + len <= (char *)src) || ((char *)src + len <= dst))
  72     {
  73         memcpy( dst, src, len );
  74     }
  75     /* Otherwise do it the hard way (FIXME: could do better than this) */
  76     else if (dst < src)
  77     {
  78         while (len--) *dst++ = *((char *)src)++;
  79     }
  80     else
  81     {
  82         dst += len - 1;
  83         src = (char *)src + len - 1;
  84         while (len--) *dst-- = *((char *)src)--;
  85     }
  86     return dest;
  87 }
  88 #endif  /* HAVE_MEMMOVE */
  89
  90 /***********************************************************************
  91  *              strerror
  92  */
  93 #ifndef HAVE_STRERROR
  94 const char *strerror( int err )
  95 {
  96     /* Let's hope we have sys_errlist then */
  97     return sys_errlist[err];
  98 }
  99 #endif  /* HAVE_STRERROR */
 100
 101 /***********************************************************************
 102  *              clone
 103  */
 104 #if !defined(HAVE_CLONE) && defined(__linux__)
 105 int clone( int (*fn)(void *), void *stack, int flags, void *arg )
 106 {
 107 #ifdef __i386__
 108     int ret;
 109     void **stack_ptr = (void **)stack;
 110     *--stack_ptr = arg;  /* Push argument on stack */
 111     *--stack_ptr = fn;   /* Push function pointer (popped into ebx) */
 112     __asm__ __volatile__( "pushl %%ebx\n\t"
 113                           "movl %2,%%ebx\n\t"
 114                           "int $0x80\n\t"
 115                           "popl %%ebx\n\t"   /* Contains fn in the child */
 116                           "testl %%eax,%%eax\n\t"
 117                           "jnz 0f\n\t"
 118                           "call *%%ebx\n\t"       /* Should never return */
 119                           "xorl %%eax,%%eax\n\t"  /* Just in case it does*/
 120                           "0:"
 121                           : "=a" (ret)
 122                           : "0" (SYS_clone), "r" (flags), "c" (stack_ptr) );
 123     assert( ret );  /* If ret is 0, we returned from the child function */
 124     if (ret > 0) return ret;
 125     errno = -ret;
 126     return -1;
 127 #else
 128     errno = EINVAL;
 129     return -1;
 130 #endif  /* __i386__ */
 131 }
 132 #endif  /* !HAVE_CLONE && __linux__ */
 133
 134 /***********************************************************************
 135  *              strcasecmp
 136  */
 137 #ifndef HAVE_STRCASECMP
 138 int strcasecmp( const char *str1, const char *str2 )
 139 {
 140     while (*str1 && toupper(*str1) == toupper(*str2)) { str1++; str2++; }
 141     return toupper(*str1) - toupper(*str2);
 142 }
 143 #endif /* HAVE_STRCASECMP */
 144
 145 /***********************************************************************
 146  *              strncasecmp
 147  */
 148 #ifndef HAVE_STRNCASECMP
 149 int strncasecmp( const char *str1, const char *str2, size_t n )
 150 {
 151     int res;
 152     if (!n) return 0;
 153     while ((--n > 0) && *str1)
 154       if ((res = toupper(*str1++) - toupper(*str2++))) return res;
 155     return toupper(*str1) - toupper(*str2);
 156 }
 157 #endif /* HAVE_STRNCASECMP */
 158
 159 /***********************************************************************
 160  *              wine_openpty
 161  * NOTE
 162  *   It looks like the openpty that comes with glibc in RedHat 5.0
 163  *   is buggy (second call returns what looks like a dup of 0 and 1
 164  *   instead of a new pty), this is a generic replacement.
 165  *
 166  * FIXME
 167  *   We should have a autoconf check for this.
 168  */
 169 int wine_openpty(int *master, int *slave, char *name,
 170                         struct termios *term, struct winsize *winsize)
 171 {
 172 #ifdef HAVE_OPENPTY
 173     return openpty(master,slave,name,term,winsize);
 174 #else
 175     char *ptr1, *ptr2;
 176     char pts_name[512];
 177
 178     strcpy (pts_name, "/dev/ptyXY");
 179
 180     for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1 != 0; ptr1++) {
 181         pts_name[8] = *ptr1;
 182         for (ptr2 = "0123456789abcdef"; *ptr2 != 0; ptr2++) {
 183             pts_name[9] = *ptr2;
 184
 185             if ((*master = open(pts_name, O_RDWR)) < 0) {
 186                 if (errno == ENOENT)
 187                     return -1;
 188                 else
 189                     continue;
 190             }
 191             pts_name[5] = 't';
 192             if ((*slave = open(pts_name, O_RDWR)) < 0) {
 193                 pts_name[5] = 'p';
 194                 continue;
 195             }
 196
 197             if (term != NULL)
 198                 tcsetattr(*slave, TCSANOW, term);
 199             if (winsize != NULL)
 200                 ioctl(*slave, TIOCSWINSZ, winsize);
 201             if (name != NULL)
 202                 strcpy(name, pts_name);
 203             return *slave;
 204         }
 205     }
 206     return -1;
 207 #endif
 208 }
 209
 210 /***********************************************************************
 211  *              getnetbyaddr
 212  */
 213 #ifndef HAVE_GETNETBYADDR
 214 struct netent *getnetbyaddr(unsigned long net, int type)
 215 {
 216     errno = ENOSYS;
 217     return NULL;
 218 }
 219 #endif /* defined(HAVE_GETNETBYNAME) */
 220
 221 /***********************************************************************
 222  *              getnetbyname
 223  */
 224 #ifndef HAVE_GETNETBYNAME
 225 struct netent *getnetbyname(const char *name)
 226 {
 227     errno = ENOSYS;
 228     return NULL;
 229 }
 230 #endif /* defined(HAVE_GETNETBYNAME) */
 231
 232 /***********************************************************************
 233  *              getprotobyname
 234  */
 235 #ifndef HAVE_GETPROTOBYNAME
 236 struct protoent *getprotobyname(const char *name)
 237 {
 238     errno = ENOSYS;
 239     return NULL;
 240 }
 241 #endif /* !defined(HAVE_GETPROTOBYNAME) */
 242
 243 /***********************************************************************
 244  *              getprotobynumber
 245  */
 246 #ifndef HAVE_GETPROTOBYNUMBER
 247 struct protoent *getprotobynumber(int proto)
 248 {
 249     errno = ENOSYS;
 250     return NULL;
 251 }
 252 #endif /* !defined(HAVE_GETPROTOBYNUMBER) */
 253
 254 /***********************************************************************
 255  *              getservbyport
 256  */
 257 #ifndef HAVE_GETSERVBYPORT
 258 struct servent *getservbyport(int port, const char *proto)
 259 {
 260     errno = ENOSYS;
 261     return NULL;
 262 }
 263 #endif /* !defined(HAVE_GETSERVBYPORT) */
 264
 265 /***********************************************************************
 266  *              getsockopt
 267  */
 268 #ifndef HAVE_GETSOCKOPT
 269 int getsockopt(int socket, int level, int option_name,
 270                void *option_value, size_t *option_len)
 271 {
 272     errno = ENOSYS;
 273     return -1;
 274 }
 275 #endif /* !defined(HAVE_GETSOCKOPT) */
 276
 277 /***********************************************************************
 278  *              inet_network
 279  */
 280 #ifndef HAVE_INET_NETWORK
 281 unsigned long inet_network(const char *cp)
 282 {
 283     errno = ENOSYS;
 284     return 0;
 285 }
 286 #endif /* defined(HAVE_INET_NETWORK) */
 287
 288 /***********************************************************************
 289  *              settimeofday
 290  */
 291 #ifndef HAVE_SETTIMEOFDAY
 292 int settimeofday(struct timeval *tp, void *reserved)
 293 {
 294     tp->tv_sec = 0;
 295     tp->tv_usec = 0;
 296
 297     errno = ENOSYS;
 298     return -1;
 299 }
 300 #endif /* HAVE_SETTIMEOFDAY */
 301
 302 /***********************************************************************
 303  *              statfs
 304  */
 305 #ifndef HAVE_STATFS
 306 int statfs(const char *name, struct statfs *info)
 307 {
 308 #ifdef __BEOS__
 309     dev_t mydev;
 310     fs_info fsinfo;
 311
 312     if(!info) {
 313         errno = ENOSYS;
 314         return -1;
 315     }
 316
 317     if ((mydev = dev_for_path(name)) < 0) {
 318         errno = ENOSYS;
 319         return -1;
 320     }
 321
 322     if (fs_stat_dev(mydev,&fsinfo) < 0) {
 323         errno = ENOSYS;
 324         return -1;
 325     }
 326
 327     info->f_bsize = fsinfo.block_size;
 328     info->f_blocks = fsinfo.total_blocks;
 329     info->f_bfree = fsinfo.free_blocks;
 330
 331     return 0;
 332 #else /* defined(__BEOS__) */
 333     errno = ENOSYS;
 334     return -1;
 335 #endif /* defined(__BEOS__) */
 336 }
 337 #endif /* !defined(HAVE_STATFS) */