sal/osl/unx/system.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include "system.h"
  30
  31 #ifdef NO_PTHREAD_RTL
  32
  33 static pthread_mutex_t getrtl_mutex = PTHREAD_MUTEX_INITIALIZER;
  34
  35 /* struct passwd differs on some platforms */
  36 #if defined(MACOSX) || defined(IOS) || defined(OPENBSD) || defined(NETBSD)
  37
  38 extern int h_errno;
  39
  40 struct hostent *gethostbyname_r(const char *name, struct hostent *result,
  41                                 char *buffer, size_t buflen, int *h_errnop)
  42 {
  43     /* buffer layout:   name\0
  44      *                  array_of_pointer_to_aliases
  45      *                  NULL
  46      *                  alias1\0...aliasn\0
  47      *                  array_of_pointer_to_addresses
  48      *                  NULL
  49      *                  addr1addr2addr3...addrn
  50      */
  51       struct hostent* res;
  52
  53       pthread_mutex_lock(&getrtl_mutex);
  54
  55       if ( (res = gethostbyname(name)) )
  56       {
  57         int nname, naliases, naddr_list, naliasesdata, n;
  58         char **p, **parray, *data;
  59
  60         /* Check buffer size before copying, we want to leave the
  61          * buffers unmodified in case something goes wrong.
  62          *
  63          * Is this required?
  64          */
  65
  66         nname= strlen(res->h_name)+1;
  67
  68         naliases = naddr_list = naliasesdata = 0;
  69
  70         for ( p = res->h_aliases; *p != NULL; p++) {
  71             naliases++;
  72             naliasesdata += strlen(*p)+1;
  73         }
  74
  75         for ( p = res->h_addr_list; *p != NULL; p++)
  76             naddr_list++;
  77
  78         if ( nname
  79              + (naliases+1)*sizeof(char*) + naliasesdata
  80              + (naddr_list+1)*sizeof(char*) + naddr_list*res->h_length
  81              <= buflen )
  82         {
  83             memcpy(result, res, sizeof(struct hostent));
  84
  85             strcpy(buffer, res->h_name);
  86               result->h_name = buffer;
  87             buffer += nname;
  88
  89             parray = (char**)buffer;
  90             result->h_aliases = parray;
  91             data = buffer + (naliases+1)*sizeof(char*);
  92             for ( p = res->h_aliases; *p != NULL; p++) {
  93                 n = strlen(*p)+1;
  94                 *parray++ = data;
  95                 memcpy(data, *p, n);
  96                 data += n;
  97             }
  98             *parray = NULL;
  99             buffer = data;
 100             parray = (char**)buffer;
 101             result->h_addr_list = parray;
 102             data = buffer + (naddr_list+1)*sizeof(char*);
 103             for ( p = res->h_addr_list; *p != NULL; p++) {
 104                 *parray++ = data;
 105                 memcpy(data, *p, res->h_length);
 106                 data += res->h_length;
 107             }
 108             *parray = NULL;
 109
 110                res = result;
 111         }
 112         else
 113         {
 114             errno = ERANGE;
 115             res = NULL;
 116         }
 117     }
 118     else
 119     {
 120         *h_errnop = h_errno;
 121     }
 122
 123     pthread_mutex_unlock(&getrtl_mutex);
 124
 125       return res;
 126 }
 127 #endif // OSX || IOS || OPENBSD || NETBSD
 128
 129 #if defined(MACOSX)
 130 /*
 131  * Add support for resolving Mac native alias files (not the same as unix alias files)
 132  * returns 0 on success.
 133  */
 134 int macxp_resolveAlias(char *path, int buflen)
 135 {
 136   FSRef aFSRef;
 137   OSStatus nErr;
 138   Boolean bFolder;
 139   Boolean bAliased;
 140   char *unprocessedPath = path;
 141
 142   if ( *unprocessedPath == '/' )
 143     unprocessedPath++;
 144
 145   int nRet = 0;
 146   while ( !nRet && unprocessedPath && *unprocessedPath )
 147     {
 148       unprocessedPath = strchr( unprocessedPath, '/' );
 149       if ( unprocessedPath )
 150     *unprocessedPath = '\0';
 151
 152       nErr = noErr;
 153       bFolder = FALSE;
 154       bAliased = FALSE;
 155       if ( FSPathMakeRef( (const UInt8 *)path, &aFSRef, 0 ) == noErr )
 156     {
 157       nErr = FSResolveAliasFileWithMountFlags( &aFSRef, TRUE, &bFolder, &bAliased, kResolveAliasFileNoUI );
 158       if ( nErr == nsvErr )
 159         {
 160           errno = ENOENT;
 161           nRet = -1;
 162         }
 163       else if ( nErr == noErr && bAliased )
 164         {
 165           char tmpPath[ PATH_MAX ];
 166           if ( FSRefMakePath( &aFSRef, (UInt8 *)tmpPath, PATH_MAX ) == noErr )
 167         {
 168           int nLen = strlen( tmpPath ) + ( unprocessedPath ? strlen( unprocessedPath + 1 ) + 1 : 0 );
 169           if ( nLen < buflen && nLen < PATH_MAX )
 170             {
 171               if ( unprocessedPath )
 172             {
 173               int nTmpPathLen = strlen( tmpPath );
 174               strcat( tmpPath, "/" );
 175               strcat( tmpPath, unprocessedPath + 1 );
 176               strcpy( path, tmpPath);
 177               unprocessedPath = path + nTmpPathLen;
 178             }
 179               else if ( !unprocessedPath )
 180             {
 181               strcpy( path, tmpPath);
 182             }
 183             }
 184           else
 185             {
 186               errno = ENAMETOOLONG;
 187               nRet = -1;
 188             }
 189         }
 190         }
 191     }
 192
 193       if ( unprocessedPath )
 194     *unprocessedPath++ = '/';
 195     }
 196
 197   return nRet;
 198 }
 199
 200 #endif  /* defined MACOSX */
 201
 202 #endif /* NO_PTHREAD_RTL */
 203
 204 #if defined(LINUX) && defined (__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 4
 205 /* The linux kernel 2.4 getpid implemention always return the pid of the
 206    thread subprocess and not of the main process, the NPTL implementation
 207    with a Linux kernel 2.6 kernel return the pid. So when possibly
 208    there is the wrong implementation of getpid, we save the pid at startup.
 209    FIXME: when our Linux base-line is above:
 210         + Linux kernel version 2.6 or higher; -> clone() for NTPL
 211         + glibc2 version 2.4 or higher; -> No longer LinuxThreads, only NPTL
 212    Then we get a working getpid() and can remove this hack.
 213    FIXME: getppid is also wrong in this situation
 214 */
 215
 216 // Directly from libc.so.6, obviously missing from some unistd.h:
 217 extern __pid_t __getpid(void);
 218
 219 static pid_t pid = -1;
 220
 221 static void savePid(void) __attribute__((constructor));
 222
 223 static void savePid(void)
 224 {
 225     if (pid == -1)
 226         pid = __getpid();
 227 }
 228
 229 pid_t getpid(void)
 230 {
 231     if (pid == -1)
 232         savePid();
 233
 234     return (pid);
 235 }
 236 #endif /*  defined LINUX */
 237
 238 #ifdef NO_PTHREAD_SEMAPHORES
 239 int sem_init(sem_t* sem, int pshared, unsigned int value)
 240 {
 241     (void)pshared;
 242     pthread_mutex_init(&sem->mutex, PTHREAD_MUTEXATTR_DEFAULT);
 243     pthread_cond_init(&sem->increased, PTHREAD_CONDATTR_DEFAULT);
 244
 245     sem->value = (int)value;
 246     return 0;
 247 }
 248
 249 int sem_destroy(sem_t* sem)
 250 {
 251     pthread_mutex_destroy(&sem->mutex);
 252     pthread_cond_destroy(&sem->increased);
 253     sem->value = 0;
 254     return 0;
 255 }
 256
 257 int sem_wait(sem_t* sem)
 258 {
 259     pthread_mutex_lock(&sem->mutex);
 260
 261     while (sem->value <= 0)
 262     {
 263         pthread_cond_wait(&sem->increased, &sem->mutex);
 264     }
 265
 266     sem->value--;
 267     pthread_mutex_unlock(&sem->mutex);
 268
 269     return 0;
 270 }
 271
 272 int sem_trywait(sem_t* sem)
 273 {
 274     int result = 0;
 275
 276     pthread_mutex_lock(&sem->mutex);
 277
 278     if (sem->value > 0)
 279     {
 280         sem->value--;
 281     }
 282     else
 283     {
 284         errno = EAGAIN;
 285         result = -1;
 286     }
 287
 288     pthread_mutex_unlock(&sem->mutex);
 289
 290     return result;
 291 }
 292
 293 int sem_post(sem_t* sem)
 294 {
 295     pthread_mutex_lock(&sem->mutex);
 296
 297     sem->value++;
 298
 299     pthread_mutex_unlock(&sem->mutex);
 300
 301     pthread_cond_signal(&sem->increased);
 302
 303     return 0;
 304 }
 305 #endif
 306
 307 #if defined(FREEBSD)
 308 char *fcvt(double value, int ndigit, int *decpt, int *sign)
 309 {
 310   static char ret[256];
 311   char buf[256],zahl[256],format[256]="%";
 312   char *v1,*v2;
 313
 314   if (value==0.0) value=1e-30;
 315
 316   if (value<0.0) *sign=1; else *sign=0;
 317
 318   if (value<1.0)
 319   {
 320     *decpt=(int)log10(value);
 321     value*=pow(10.0,1-*decpt);
 322     ndigit+=*decpt-1;
 323     if (ndigit<0) ndigit=0;
 324   }
 325   else
 326   {
 327     *decpt=(int)log10(value)+1;
 328   }
 329
 330   sprintf(zahl,"%d",ndigit);
 331   strcat(format,zahl);
 332   strcat(format,".");
 333   strcat(format,zahl);
 334   strcat(format,"f");
 335
 336   sprintf(buf,format,value);
 337
 338   if (ndigit!=0)
 339   {
 340     v1=strtok(buf,".");
 341     v2=strtok(NULL,".");
 342     strcpy(ret,v1);
 343     strcat(ret,v2);
 344   }
 345   else
 346   {
 347     strcpy(ret,buf);
 348   }
 349
 350   return(ret);
 351 }
 352
 353 #endif
 354
 355 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */