sal/osl/unx/system.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: system.c,v $
  10  * $Revision: 1.16.60.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "system.h"
  32
  33 #ifdef NO_PTHREAD_RTL
  34
  35 static pthread_mutex_t getrtl_mutex = PTHREAD_MUTEX_INITIALIZER;
  36
  37 /* struct passwd differs on some platforms */
  38 #if defined NETBSD
  39 struct passwd *getpwnam_r(const char* name, struct passwd* s, char* buffer, int size )
  40 {
  41       struct passwd* res;
  42
  43       pthread_mutex_lock(&getrtl_mutex);
  44
  45       if ( (res = getpwnam(name)) )
  46       {
  47         int nname, npasswd, nclass, ngecos, ndir;
  48
  49         nname= strlen(res->pw_name)+1;
  50         npasswd= strlen(res->pw_passwd)+1;
  51         nclass= strlen(res->pw_class)+1;
  52         ngecos= strlen(res->pw_gecos)+1;
  53         ndir= strlen(res->pw_dir)+1;
  54
  55         if (nname+npasswd+nclass+ngecos
  56                 +ndir+strlen(res->pw_shell) < size)
  57         {
  58             memcpy(s, res, sizeof(struct passwd));
  59
  60             strcpy(buffer, res->pw_name);
  61               s->pw_name = buffer;
  62             buffer += nname;
  63
  64             strcpy(buffer, res->pw_passwd);
  65               s->pw_passwd = buffer;
  66             buffer += npasswd;
  67
  68             strcpy(buffer, res->pw_class);
  69               s->pw_class = buffer;
  70             buffer += nclass;
  71
  72             strcpy(buffer, res->pw_gecos);
  73               s->pw_gecos = buffer;
  74             buffer += ngecos;
  75
  76             strcpy(buffer, res->pw_dir);
  77               s->pw_dir = buffer;
  78             buffer += ndir;
  79
  80             strcpy(buffer, res->pw_shell);
  81               s->pw_shell = buffer;
  82
  83                res = s;
  84         }
  85         else
  86             res = 0;
  87     }
  88
  89     pthread_mutex_unlock(&getrtl_mutex);
  90
  91         return(res);
  92 }
  93
  94 int getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer,
  95            size_t buflen, struct passwd **result)
  96 {
  97   struct passwd* res;
  98   int retval = 0;
  99
 100   pthread_mutex_lock(&getrtl_mutex);
 101
 102   if ( (res = getpwuid(uid)) )
 103   {
 104     size_t pw_name, pw_passwd, pw_class, pw_gecos, pw_dir, pw_shell;
 105
 106     pw_name = strlen(res->pw_name)+1;
 107     pw_passwd = strlen(res->pw_passwd)+1;
 108     pw_class = strlen(res->pw_class)+1;
 109     pw_gecos = strlen(res->pw_gecos)+1;
 110     pw_dir = strlen(res->pw_dir)+1;
 111     pw_shell = strlen(res->pw_shell)+1;
 112
 113     if (pw_name+pw_passwd+pw_class+pw_gecos
 114                                  +pw_dir+pw_shell < buflen)
 115     {
 116       memcpy(pwd, res, sizeof(struct passwd));
 117
 118       strncpy(buffer, res->pw_name, pw_name);
 119       pwd->pw_name = buffer;
 120       buffer += pw_name;
 121
 122       strncpy(buffer, res->pw_passwd, pw_passwd);
 123       pwd->pw_passwd = buffer;
 124       buffer += pw_passwd;
 125
 126       strncpy(buffer, res->pw_class, pw_class);
 127       pwd->pw_class = buffer;
 128       buffer += pw_class;
 129
 130       strncpy(buffer, res->pw_gecos, pw_gecos);
 131       pwd->pw_gecos = buffer;
 132       buffer += pw_gecos;
 133
 134       strncpy(buffer, res->pw_dir, pw_dir);
 135       pwd->pw_dir = buffer;
 136       buffer += pw_dir;
 137
 138       strncpy(buffer, res->pw_shell, pw_shell);
 139       pwd->pw_shell = buffer;
 140       buffer += pw_shell;
 141
 142       *result = pwd ;
 143       retval = 0 ;
 144
 145     }
 146     else
 147         retval =  ENOMEM;
 148   }
 149   else
 150       retval = errno ;
 151
 152   pthread_mutex_unlock(&getrtl_mutex);
 153
 154   return retval;
 155 }
 156
 157 struct tm *localtime_r(const time_t *timep, struct tm *buffer)
 158 {
 159     struct tm* res;
 160
 161       pthread_mutex_lock(&getrtl_mutex);
 162
 163     if ( (res = localtime(timep)))
 164     {
 165         memcpy(buffer, res, sizeof(struct tm));
 166         res = buffer;
 167     }
 168
 169     pthread_mutex_unlock(&getrtl_mutex);
 170
 171     return res;
 172 }
 173
 174 struct tm *gmtime_r(const time_t *timep, struct tm *buffer)
 175 {
 176     struct tm* res;
 177
 178       pthread_mutex_lock(&getrtl_mutex);
 179
 180     if ( (res = gmtime(timep)) )
 181     {
 182         memcpy(buffer, res, sizeof(struct tm));
 183         res = buffer;
 184     }
 185
 186     pthread_mutex_unlock(&getrtl_mutex);
 187
 188     return res;
 189 }
 190 #endif  /* defined NETBSD */
 191
 192 #ifdef SCO
 193 #include <pwd.h>
 194 #include <shadow.h>
 195 #include <sys/types.h>
 196
 197 struct spwd *getspnam_r(const char *name, struct spwd* s, char* buffer, int size )
 198 {
 199       struct spwd* res;
 200
 201       pthread_mutex_lock(&getrtl_mutex);
 202
 203       if ( res = getspnam(name) )
 204       {
 205         int nnamp;
 206
 207         nnamp = strlen(res->sp_namp)+1;
 208
 209         if (nnamp+strlen(res->sp_pwdp) < size) {
 210             memcpy(s, res, sizeof(struct spwd));
 211
 212             strcpy(buffer, res->sp_namp);
 213               s->sp_namp = buffer;
 214             buffer += nnamp;
 215
 216             strcpy(buffer, res->sp_pwdp);
 217               s->sp_pwdp = buffer;
 218
 219                res = s;
 220         }
 221         else
 222             res = 0;
 223     }
 224
 225       pthread_mutex_unlock(&getrtl_mutex);
 226
 227       return res;
 228 }
 229
 230 struct passwd *getpwnam_r(const char* name, struct passwd* s, char* buffer, int size )
 231 {
 232       struct passwd* res;
 233
 234       pthread_mutex_lock(&getrtl_mutex);
 235
 236       if ( res = getpwnam(name) )
 237       {
 238         int nname, npasswd, nage;
 239         int ncomment, ngecos, ndir;
 240
 241         nname= strlen(res->pw_name)+1;
 242         npasswd= strlen(res->pw_passwd)+1;
 243         nage= strlen(res->pw_age)+1;
 244         ncomment= strlen(res->pw_comment)+1;
 245         ngecos= strlen(res->pw_gecos)+1;
 246         ndir= strlen(res->pw_dir)+1;
 247
 248         if (nname+npasswd+nage+ncomment+ngecos+ndir
 249                 +strlen(res->pw_shell) < size)
 250         {
 251             memcpy(s, res, sizeof(struct passwd));
 252
 253             strcpy(buffer, res->pw_name);
 254               s->pw_name = buffer;
 255             buffer += nname;
 256
 257             strcpy(buffer, res->pw_passwd);
 258               s->pw_passwd = buffer;
 259             buffer += npasswd;
 260
 261             strcpy(buffer, res->pw_age);
 262               s->pw_age = buffer;
 263             buffer += nage;
 264
 265             strcpy(buffer, res->pw_comment);
 266               s->pw_comment = buffer;
 267             buffer += ncomment;
 268
 269             strcpy(buffer, res->pw_gecos);
 270               s->pw_gecos = buffer;
 271             buffer += ngecos;
 272
 273             strcpy(buffer, res->pw_dir);
 274               s->pw_dir = buffer;
 275             buffer += ndir;
 276
 277             strcpy(buffer, res->pw_shell);
 278               s->pw_shell = buffer;
 279
 280                res = s;
 281         }
 282         else
 283             res = 0;
 284     }
 285
 286     pthread_mutex_unlock(&getrtl_mutex);
 287
 288       return res;
 289 }
 290 #endif /* defined SCO */
 291
 292 #if !defined(FREEBSD) || (__FreeBSD_version < 601103)
 293
 294 extern int h_errno;
 295
 296 struct hostent *gethostbyname_r(const char *name, struct hostent *result,
 297                                 char *buffer, int buflen, int *h_errnop)
 298 {
 299     /* buffer layout:   name\0
 300      *                                  array_of_pointer_to_aliases
 301      *                                  NULL
 302      *                                  alias1\0...aliasn\0
 303      *                  array_of_pointer_to_addresses
 304      *                                  NULL
 305      *                                  addr1addr2addr3...addrn
 306      */
 307       struct hostent* res;
 308
 309       pthread_mutex_lock(&getrtl_mutex);
 310
 311       if ( (res = gethostbyname(name)) )
 312       {
 313         int nname, naliases, naddr_list, naliasesdata, n;
 314         char **p, **parray, *data;
 315
 316         /* Check buffer size before copying, we want to leave the
 317          * buffers unmodified in case something goes wrong.
 318          *
 319          * Is this required?
 320          */
 321
 322         nname= strlen(res->h_name)+1;
 323
 324         naliases = naddr_list = naliasesdata = 0;
 325
 326         for ( p = res->h_aliases; *p != NULL; p++) {
 327             naliases++;
 328             naliasesdata += strlen(*p)+1;
 329         }
 330
 331         for ( p = res->h_addr_list; *p != NULL; p++)
 332             naddr_list++;
 333
 334         if ( nname
 335              + (naliases+1)*sizeof(char*) + naliasesdata
 336              + (naddr_list+1)*sizeof(char*) + naddr_list*res->h_length
 337              <= buflen )
 338         {
 339             memcpy(result, res, sizeof(struct hostent));
 340
 341             strcpy(buffer, res->h_name);
 342               result->h_name = buffer;
 343             buffer += nname;
 344
 345             parray = (char**)buffer;
 346             result->h_aliases = parray;
 347             data = buffer + (naliases+1)*sizeof(char*);
 348             for ( p = res->h_aliases; *p != NULL; p++) {
 349                 n = strlen(*p)+1;
 350                 *parray++ = data;
 351                 memcpy(data, *p, n);
 352                 data += n;
 353             }
 354             *parray = NULL;
 355             buffer = data;
 356             parray = (char**)buffer;
 357             result->h_addr_list = parray;
 358             data = buffer + (naddr_list+1)*sizeof(char*);
 359             for ( p = res->h_addr_list; *p != NULL; p++) {
 360                 *parray++ = data;
 361                 memcpy(data, *p, res->h_length);
 362                 data += res->h_length;
 363             }
 364             *parray = NULL;
 365
 366                res = result;
 367         }
 368         else
 369         {
 370             errno = ERANGE;
 371             res = NULL;
 372         }
 373     }
 374     else
 375     {
 376         *h_errnop = h_errno;
 377     }
 378
 379     pthread_mutex_unlock(&getrtl_mutex);
 380
 381       return res;
 382 }
 383 #endif /* !defined(FREEBSD) || (__FreeBSD_version < 601103) */
 384
 385 #if defined(MACOSX)
 386 /*
 387  * Add support for resolving Mac native alias files (not the same as unix alias files)
 388  * returns 0 on success.
 389  */
 390 int macxp_resolveAlias(char *path, int buflen)
 391 {
 392   FSRef aFSRef;
 393   OSStatus nErr;
 394   Boolean bFolder;
 395   Boolean bAliased;
 396   char *unprocessedPath = path;
 397
 398   if ( *unprocessedPath == '/' )
 399     unprocessedPath++;
 400
 401   int nRet = 0;
 402   while ( !nRet && unprocessedPath && *unprocessedPath )
 403     {
 404       unprocessedPath = strchr( unprocessedPath, '/' );
 405       if ( unprocessedPath )
 406     *unprocessedPath = '\0';
 407
 408       nErr = noErr;
 409       bFolder = FALSE;
 410       bAliased = FALSE;
 411       if ( FSPathMakeRef( (const UInt8 *)path, &aFSRef, 0 ) == noErr )
 412     {
 413       nErr = FSResolveAliasFileWithMountFlags( &aFSRef, TRUE, &bFolder, &bAliased, kResolveAliasFileNoUI );
 414       if ( nErr == nsvErr )
 415         {
 416           errno = ENOENT;
 417           nRet = -1;
 418         }
 419       else if ( nErr == noErr && bAliased )
 420         {
 421           char tmpPath[ PATH_MAX ];
 422           if ( FSRefMakePath( &aFSRef, (UInt8 *)tmpPath, PATH_MAX ) == noErr )
 423         {
 424           int nLen = strlen( tmpPath ) + ( unprocessedPath ? strlen( unprocessedPath + 1 ) + 1 : 0 );
 425           if ( nLen < buflen && nLen < PATH_MAX )
 426             {
 427               if ( unprocessedPath )
 428             {
 429               int nTmpPathLen = strlen( tmpPath );
 430               strcat( tmpPath, "/" );
 431               strcat( tmpPath, unprocessedPath + 1 );
 432               strcpy( path, tmpPath);
 433               unprocessedPath = path + nTmpPathLen;
 434             }
 435               else if ( !unprocessedPath )
 436             {
 437               strcpy( path, tmpPath);
 438             }
 439             }
 440           else
 441             {
 442               errno = ENAMETOOLONG;
 443               nRet = -1;
 444             }
 445         }
 446         }
 447     }
 448
 449       if ( unprocessedPath )
 450     *unprocessedPath++ = '/';
 451     }
 452
 453   return nRet;
 454 }
 455
 456 #endif  /* defined MACOSX */
 457
 458 #endif /* NO_PTHREAD_RTL */
 459
 460 #if (defined (LINUX) && (GLIBC >= 2))
 461 /* The linux kernel thread implemention, always return the pid of the
 462    thread subprocess and not of the main process. So we save the main
 463    pid at startup
 464 */
 465
 466 // Directly from libc.so.6, obviously missing from some unistd.h:
 467 extern __pid_t __getpid(void);
 468
 469 static pid_t pid = -1;
 470
 471 static void savePid(void) __attribute__((constructor));
 472
 473 static void savePid(void)
 474 {
 475     if (pid == -1)
 476         pid = __getpid();
 477 }
 478
 479 pid_t getpid(void)
 480 {
 481     if (pid == -1)
 482         savePid();
 483
 484     return (pid);
 485 }
 486 #endif /*  (defined (LINUX) && (GLIBC >= 2)) */
 487
 488 #ifdef NO_PTHREAD_SEMAPHORES
 489 int sem_init(sem_t* sem, int pshared, unsigned int value)
 490 {
 491     pthread_mutex_init(&sem->mutex, PTHREAD_MUTEXATTR_DEFAULT);
 492     pthread_cond_init(&sem->increased, PTHREAD_CONDATTR_DEFAULT);
 493
 494     sem->value = (int)value;
 495     return 0;
 496 }
 497
 498 int sem_destroy(sem_t* sem)
 499 {
 500     pthread_mutex_destroy(&sem->mutex);
 501     pthread_cond_destroy(&sem->increased);
 502     sem->value = 0;
 503     return 0;
 504 }
 505
 506 int sem_wait(sem_t* sem)
 507 {
 508     pthread_mutex_lock(&sem->mutex);
 509
 510     while (sem->value <= 0)
 511     {
 512         pthread_cond_wait(&sem->increased, &sem->mutex);
 513     }
 514
 515     sem->value--;
 516     pthread_mutex_unlock(&sem->mutex);
 517
 518     return 0;
 519 }
 520
 521 int sem_trywait(sem_t* sem)
 522 {
 523     int result = 0;
 524
 525     pthread_mutex_lock(&sem->mutex);
 526
 527     if (sem->value > 0)
 528     {
 529         sem->value--;
 530     }
 531     else
 532     {
 533         errno = EAGAIN;
 534         result = -1;
 535     }
 536
 537     pthread_mutex_unlock(&sem->mutex);
 538
 539     return result;
 540 }
 541
 542 int sem_post(sem_t* sem)
 543 {
 544     pthread_mutex_lock(&sem->mutex);
 545
 546     sem->value++;
 547
 548     pthread_mutex_unlock(&sem->mutex);
 549
 550     pthread_cond_signal(&sem->increased);
 551
 552     return 0;
 553 }
 554 #endif
 555
 556 #if defined(FREEBSD)
 557 char *fcvt(double value, int ndigit, int *decpt, int *sign)
 558 {
 559   static char ret[256];
 560   char buf[256],zahl[256],format[256]="%";
 561   char *v1,*v2;
 562
 563   if (value==0.0) value=1e-30;
 564
 565   if (value<0.0) *sign=1; else *sign=0;
 566
 567   if (value<1.0)
 568   {
 569     *decpt=(int)log10(value);
 570     value*=pow(10.0,1-*decpt);
 571     ndigit+=*decpt-1;
 572     if (ndigit<0) ndigit=0;
 573   }
 574   else
 575   {
 576     *decpt=(int)log10(value)+1;
 577   }
 578
 579   sprintf(zahl,"%d",ndigit);
 580   strcat(format,zahl);
 581   strcat(format,".");
 582   strcat(format,zahl);
 583   strcat(format,"f");
 584
 585   sprintf(buf,format,value);
 586
 587   if (ndigit!=0)
 588   {
 589     v1=strtok(buf,".");
 590     v2=strtok(NULL,".");
 591     strcpy(ret,v1);
 592     strcat(ret,v2);
 593   }
 594   else
 595   {
 596     strcpy(ret,buf);
 597   }
 598
 599   return(ret);
 600 }
 601
 602 #endif