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