sal/osl/unx/util.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <unistd.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/socket.h>
  27 #include <net/if.h>
  28
  29 #ifdef SOLARIS
  30 #include <sys/sockio.h>
  31 #endif
  32
  33 #include "osl/util.h"
  34 #include "osl/diagnose.h"
  35
  36
  37 /*****************************************************************************/
  38 /* Static Module Functions */
  39 /*****************************************************************************/
  40
  41 static int   osl_getHWAddr(const char *ifname, char* hard_addr);
  42 static int   osl_checkAddr(const char* addr);
  43
  44
  45 /*****************************************************************************/
  46 /* osl_getEthernetAddress */
  47 /*****************************************************************************/
  48
  49 sal_Bool SAL_CALL osl_getEthernetAddress( sal_uInt8 * pAddr )
  50 {
  51 #ifdef SOLARIS
  52     /** algorithm doesn't work on solaris */
  53     return sal_False;
  54 #else
  55     char buff[1024];
  56     char hard_addr[64];
  57     struct ifconf ifc;
  58     struct ifreq *ifr;
  59     int i;
  60     int so;
  61
  62     if ( pAddr == 0 )
  63     {
  64         return sal_False;
  65     }
  66
  67
  68     /*
  69      * All we need is ... a network file descriptor.
  70      * Normally, this is a very socket.
  71      */
  72
  73     so = socket(AF_INET, SOCK_DGRAM, 0);
  74
  75
  76     /*
  77      * The first thing we have to do, get the interface configuration.
  78      * It is a list of attached/configured interfaces
  79      */
  80
  81     ifc.ifc_len = sizeof(buff);
  82     ifc.ifc_buf = buff;
  83     if ( ioctl(so, SIOCGIFCONF, &ifc) < 0 )
  84     {
  85         OSL_TRACE( "SIOCGIFCONF: %s", strerror(errno) );
  86         close(so);
  87         return sal_False;
  88     }
  89
  90     close(so);
  91
  92     /*
  93      *  For each of the interfaces in the interface list,
  94      *  try to get the hardware address
  95      */
  96
  97     ifr = ifc.ifc_req;
  98     for ( i = ifc.ifc_len / sizeof(struct ifreq) ; --i >= 0 ; ifr++ )
  99     {
 100         int nRet=0;
 101         nRet = osl_getHWAddr(ifr->ifr_name,hard_addr);
 102         if ( nRet  > 0 )
 103         {
 104             memcpy( pAddr , hard_addr, 6 );
 105             return sal_True;
 106         }
 107     }
 108
 109     return sal_False;
 110 #endif
 111 }
 112
 113
 114 /*****************************************************************************/
 115 /* osl_getHWAddr */
 116 /*****************************************************************************/
 117
 118 static int osl_getHWAddr(const char *ifname, char* hard_addr)
 119 {
 120     int ret=0;
 121     struct ifreq ifr;
 122     int so = socket(AF_INET, SOCK_DGRAM, 0);
 123
 124     if (strlen(ifname) >= sizeof(ifr.ifr_name))
 125     {
 126         close(so);
 127         return 0;
 128     }
 129
 130     strcpy(ifr.ifr_name, ifname);
 131
 132     /*
 133      *   First, get the Interface-FLAGS
 134      */
 135
 136     ret=ioctl(so, SIOCGIFFLAGS, &ifr) ;
 137
 138     if ( ret < 0 )
 139     {
 140         OSL_TRACE( "SIOCGIFFLAGS: %s", strerror(errno) );
 141         close(so);
 142         return ret;
 143     }
 144
 145
 146     /*
 147      *  If it is the loopback device, do not consider it any further
 148      */
 149
 150     if (ifr.ifr_flags & IFF_LOOPBACK)
 151     {
 152         OSL_TRACE( "SIOCGIFFLAGS : is LOOPBACK : %s", strerror(errno) );
 153         close(so);
 154         return 0;
 155     }
 156
 157
 158     /*
 159      *  And now, the real thing: the get address
 160      */
 161
 162 #if defined(SIOCGIFHWADDR) && !defined(SOLARIS)
 163     ret=ioctl(so, SIOCGIFHWADDR, &ifr);
 164 #else
 165     ret=ioctl(so, SIOCGIFADDR, &ifr);
 166 #endif
 167
 168     if (ret < 0) {
 169         OSL_TRACE( "SIOCGIFADDR: %s", strerror(errno) );
 170         memset(hard_addr, 0, 32);
 171         close(so);
 172         return ret;
 173     }
 174
 175     close(so);
 176
 177 #if defined(SIOCGIFHWADDR) && !defined(SOLARIS)
 178     memcpy(hard_addr,ifr.ifr_hwaddr.sa_data,8);
 179 #else
 180     memcpy(hard_addr,ifr.ifr_ifru.ifru_addr.sa_data,8);
 181 #endif
 182
 183
 184     /*
 185      *  Check, if no real, i.e. 00:00:00:00:00:00, address was retrieved.
 186      *  The Linux dummy device has this kind of behaviour
 187      */
 188
 189     ret=osl_checkAddr(hard_addr);
 190
 191     if (ret < 0) {
 192         OSL_TRACE( "SIOCGIFADDR got '00:00:00:00:00:00'" );
 193         return ret;
 194     }
 195
 196     return 1;
 197 }
 198
 199
 200 /*****************************************************************************/
 201 /* osl_checkAddr */
 202 /*****************************************************************************/
 203
 204 static int osl_checkAddr(const char* addr)
 205 {
 206     if (addr[0]==0 && addr[1]==0 &&
 207         addr[2]==0 && addr[3]==0 &&
 208         addr[4]==0 && addr[5]==0)
 209     {
 210         return -1;
 211     }
 212     return 0;
 213 }
 214
 215
 216 #if defined (SPARC)
 217
 218 #if defined (SOLARIS) && !defined(__sparcv8plus) && !defined(__sparcv9)
 219 #include <sys/types.h>
 220 #include <sys/processor.h>
 221
 222 /*****************************************************************************/
 223 /* osl_InitSparcV9 */
 224 /*****************************************************************************/
 225
 226 void osl_InterlockedCountSetV9(sal_Bool bV9);
 227
 228 /*
 229  * osl_InitSparcV9() should be executed as early as possible. We place it in the
 230  * .init section of sal
 231  */
 232 #if defined ( __SUNPRO_C ) || defined ( __SUNPRO_CC )
 233 void osl_InitSparcV9(void);
 234 #pragma init (osl_InitSparcV9)
 235 #elif defined ( __GNUC__ )
 236 void osl_InitSparcV9(void)  __attribute__((constructor));
 237 #endif
 238
 239 void osl_InitSparcV9(void)
 240 {
 241     /* processor_info() identifies SPARCV8 (ie sun4c machines) simply as "sparc"
 242      * and SPARCV9 (ie ultra sparcs, sun4u) as "sparcv9". Since we know that we
 243      * run at least on a SPARCV8 architecture or better, any processor type != "sparc"
 244      * and != "i386" is considered to be SPARCV9 or better
 245      *
 246      * This way we are certain that this will still work if someone names SPARCV10
 247      * "foobar"
 248      */
 249     processor_info_t aInfo;
 250     int rc;
 251
 252     rc = processor_info(0, &aInfo);
 253
 254     if ( rc != -1 ) {
 255         if ( !strcmp( "sparc", aInfo.pi_processor_type )    /* SPARCV8 */
 256             || !strcmp( "i386", aInfo.pi_processor_type ) ) /* can't happen, but ... */
 257             return;
 258         /* we are reasonably certain to be on sparcv9/sparcv8plus or better */
 259         osl_InterlockedCountSetV9(sal_True);
 260     }
 261 }
 262
 263 #endif /* SOLARIS */
 264
 265 #if defined(NETBSD) && defined(__GNUC__) && !defined(__sparcv9) && !defined(__sparc_v9__)
 266
 267 #include <sys/param.h>
 268 #include <sys/sysctl.h>
 269 void osl_InitSparcV9(void)  __attribute__((constructor));
 270 void osl_InterlockedCountSetV9(sal_Bool bV9);
 271
 272 /* Determine which processor we are running on (sparc v8 or v9)
 273  * The approach is very similar to Solaris.
 274  */
 275
 276 void osl_InitSparcV9(void)
 277 {
 278     int mib[2]={CTL_HW,HW_MACHINE};
 279     char processorname[256];
 280     size_t len=256;
 281
 282     /* get the machine name */
 283     sysctl(mib, 2, processorname, &len, NULL, 0);
 284     if (!strncmp("sparc64",processorname, len)) {
 285         osl_InterlockedCountSetV9(sal_True);
 286     }
 287 }
 288
 289 #endif /* NETBSD */
 290
 291 #endif /* SPARC */
 292
 293 #if defined ( LINUX ) && defined ( SPARC )
 294 #include <sys/utsname.h>
 295 void osl_InitSparcV9(void)  __attribute__((constructor));
 296 void osl_InterlockedCountSetV9(sal_Bool bV9);
 297 /* Determine which processor we are running on (sparc v8 or v9)
 298  * The approach is very similar to Solaris.
 299  */
 300 void osl_InitSparcV9(void)
 301 {
 302     struct utsname name;
 303     int rc;
 304     rc = uname(&name);
 305     if ( rc != -1 ) {
 306         if ( !strcmp( "sparc", name.machine ))
 307         return;
 308     osl_InterlockedCountSetV9(sal_True);
 309     }
 310 }
 311 #endif
 312
 313 #if    ( defined(__GNUC__) && (defined(X86) || defined(X86_64)) )\
 314     || ( defined(SOLARIS) && defined(__i386) )
 315
 316 /* Safe default */
 317 int osl_isSingleCPU = 0;
 318
 319 /* Determine if we are on a multiprocessor/multicore/HT x86/x64 system
 320  *
 321  * The lock prefix for atomic operations in osl_[inc|de]crementInterlockedCount()
 322  * comes with a cost and is especially expensive on pre HT x86 single processor
 323  * systems, where it isn't needed at all.
 324  *
 325  * This should be run as early as possible, thus it's placed in the init section
 326  */
 327 #if defined(_SC_NPROCESSORS_CONF) /* i.e. MACOSX for Intel doesn't have this */
 328 #if defined(__GNUC__)
 329 void osl_interlockedCountCheckForSingleCPU(void)  __attribute__((constructor));
 330 #elif defined(__SUNPRO_C)
 331 void osl_interlockedCountCheckForSingleCPU(void);
 332 #pragma init (osl_interlockedCountCheckForSingleCPU)
 333 #endif
 334
 335 void osl_interlockedCountCheckForSingleCPU(void)
 336 {
 337     /* In case sysconfig fails be on the safe side,
 338      * consider it a multiprocessor/multicore/HT system */
 339     if ( sysconf(_SC_NPROCESSORS_CONF) == 1 ) {
 340         osl_isSingleCPU = 1;
 341     }
 342 }
 343 #endif /* defined(_SC_NPROCESSORS_CONF) */
 344 #endif
 345
 346 //might be useful on other platforms, but doesn't compiler under MACOSX anyway
 347 #if defined(__GNUC__) && defined(LINUX)
 348 //force the __data_start symbol to exist in any executables that link against
 349 //libuno_sal so that dlopening of the libgcj provided libjvm.so on some
 350 //platforms where it needs that symbol will succeed. e.g. Debian mips/lenny
 351 //with gcc 4.3. With this in place the smoketest succeeds with libgcj provided
 352 //java. Quite possibly also required/helpful for s390x/s390 and maybe some
 353 //others. Without it the dlopen of libjvm.so will fail with __data_start
 354 //not found
 355 extern int __data_start[] __attribute__((weak));
 356 extern int data_start[] __attribute__((weak));
 357 extern int _end[] __attribute__((weak));
 358 static void *dummy[] __attribute__((used)) = {__data_start, data_start, _end};
 359 #endif
 360
 361 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */