util/src/platforms/unix/uuid_gen_unix.c - axis-axis2-c-core - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <config.h>

 #include <sys/ioctl.h>
 #include <string.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/time.h>

 #ifdef HAVE_LINUX_IF_H
 # include <linux/if.h>
 #else
 # ifdef HAVE_NET_IF_H
 #  ifdef HAVE_SYS_SOCKIO_H
 #    include <sys/sockio.h>
 #  endif
 #  include <net/if.h>
 #  include <net/if_arp.h>
 # endif
 # ifdef HAVE_NET_IF_TYPES_H
 #  include <net/if_types.h>
 # endif
 # ifdef HAVE_NET_IF_DL_H
 #  include <net/if_dl.h>
 # endif
 #endif
 #ifdef HAVE_GETIFADDRS
 #include <ifaddrs.h>
 #endif
 #include <platforms/unix/axutil_uuid_gen_unix.h>
 #include <platforms/axutil_platform_auto_sense.h>

 #ifdef AXIS2_SSL_ENABLED
 #include <openssl/rand.h>
 #endif


 /* We need these static variables to track throughout the program execution */
 static axis2_bool_t axutil_uuid_gen_is_first = AXIS2_TRUE;
 static struct axutil_uuid_st axutil_uuid_static;

 axutil_uuid_t *AXIS2_CALL
 axutil_uuid_gen_v1()
 {
     struct timeval time_now;
     struct timeval tv;
     unsigned long long time_val;
     unsigned long long time_val2;
     unsigned short int clck = 0;
     axutil_uuid_t *ret_uuid = NULL;
     unsigned short int time_high_version = 0;

     if(AXIS2_TRUE == axutil_uuid_gen_is_first)
     {
         char *mac_addr = axutil_uuid_get_mac_addr();
         if (mac_addr) {
             memcpy(axutil_uuid_static.mac, mac_addr, 6);
             free(mac_addr);
         } else {
             /* Default value, not expected to go there */
 #ifdef AXIS2_SSL_ENABLED
             RAND_bytes(axutil_uuid_static.mac, 6);
 #else
             memset(axutil_uuid_static.mac, 0, 6);
 #endif
         }
         axutil_uuid_static.time_seq = 0;
         axutil_uuid_static.clock = 0;
         axutil_uuid_gen_is_first = AXIS2_FALSE;
     }
     /*
      *  GENERATE TIME
      */

     /* determine current system time and sequence counter */
     if(gettimeofday(&time_now, NULL) == -1)
         return NULL;

     /* check whether system time changed since last retrieve */
     if(!(time_now.tv_sec == axutil_uuid_static.time_last.tv_sec && time_now.tv_usec
         == axutil_uuid_static.time_last.tv_usec))
     {
         /* reset time sequence counter and continue */
         axutil_uuid_static.time_seq = 0;
     }

     /* until we are out of UUIDs per tick, increment
      the time/tick sequence counter and continue */
     while(axutil_uuid_static.time_seq < UUIDS_PER_TICK)
     {
         axutil_uuid_static.time_seq++;
     }
     /* sleep for 1000ns (1us) */
     tv.tv_sec = 0;
     tv.tv_usec = 1;
     /*
      The following select causes severe performance problems.
      Hence commenting out. I am not sure why this is required. - Samisa.
      select(0, NULL, NULL, NULL, &tv); */

     time_val = (unsigned long long)time_now.tv_sec * 10000000ull;
     time_val += (unsigned long long)time_now.tv_usec * 10ull;

     ret_uuid = malloc(sizeof(axutil_uuid_t));

     time_val += UUID_TIMEOFFSET;
     /* compensate for low resolution system clock by adding
      the time/tick sequence counter */
     if(axutil_uuid_static.time_seq > 0)
         time_val += (unsigned long long)axutil_uuid_static.time_seq;

     time_val2 = time_val;
     ret_uuid->time_low = (unsigned long)time_val2;
     time_val2 >>= 32;
     ret_uuid->time_mid = (unsigned short int)time_val2;
     time_val2 >>= 16;
     time_high_version = (unsigned short int)time_val2;

     /* store the 60 LSB of the time in the UUID and make version 1 */
     time_high_version <<= 4;
     time_high_version &= 0xFFF0;
     time_high_version |= 0x0001;
     ret_uuid->time_high_version = time_high_version;

     /*
      *  GENERATE CLOCK
      */

     /* retrieve current clock sequence */
     clck = axutil_uuid_static.clock;

     /* generate new random clock sequence (initially or if the
      time has stepped backwards) or else just increase it */
     if(clck == 0 || (time_now.tv_sec < axutil_uuid_static.time_last.tv_sec || (time_now.tv_sec
         == axutil_uuid_static.time_last.tv_sec && time_now.tv_usec
         < axutil_uuid_static.time_last.tv_usec)))
     {
         srand(time_now.tv_usec);
         clck = rand();
     }
     else
     {
         clck++;
     }
     clck %= (2 << 14);

     /* store back new clock sequence */
     axutil_uuid_static.clock = clck;

     clck &= 0x1FFF;
     clck |= 0x2000;

     /*
      *  FINISH
      */
     /* remember current system time for next iteration */
     axutil_uuid_static.time_last.tv_sec = time_now.tv_sec;
     axutil_uuid_static.time_last.tv_usec = time_now.tv_usec;

     if(!ret_uuid)
     {
         return NULL;
     }
     ret_uuid->clock_variant = clck;
     memcpy(ret_uuid->mac_addr, axutil_uuid_static.mac, 6);
     return ret_uuid;
 }

 axis2_char_t *AXIS2_CALL
 axutil_platform_uuid_gen(
     char *s)
 {
     axutil_uuid_t *uuid_struct = NULL;
     axis2_char_t *uuid_str = NULL;
     unsigned char mac[7];
     char mac_hex[13];

     if(!s)
     {
         return NULL;
     }
     uuid_struct = axutil_uuid_gen_v1();
     if(!uuid_struct)
     {
         return NULL;
     }
     uuid_str = s;
     if(!uuid_str)
     {
         return NULL;
     }
     memcpy(mac, uuid_struct->mac_addr, 6);
     sprintf(mac_hex, "%02x%02x%02x%02x%02x%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
     sprintf(uuid_str, "%08x-%04x-%04x-%04x-%s", uuid_struct->time_low, uuid_struct->time_mid,
         uuid_struct->time_high_version, uuid_struct->clock_variant, mac_hex);
     free(uuid_struct);
     uuid_struct = NULL;
     return uuid_str;
 }

 #ifdef HAVE_LINUX_IF_H          /* Linux */

 char *AXIS2_CALL
 axutil_uuid_get_mac_addr(
 )
 {
     struct ifreq ifr;
     struct ifreq *IFR;
     struct ifconf ifc;
     struct sockaddr *sa;
     int s = 0;
     int i = 0;
     char *buffer = NULL;
     char buf[1024];
     int ok = AXIS2_FALSE;

     if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
     return NULL;

     ifc.ifc_len = sizeof(buf);
     ifc.ifc_buf = buf;
     ioctl(s, SIOCGIFCONF, &ifc);
     IFR = ifc.ifc_req;

     for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; IFR++)
     {
         strcpy(ifr.ifr_name, IFR->ifr_name);
         /*sprintf(ifr.ifr_name, "eth0"); */
         if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0)
         {
             if (!(ifr.ifr_flags & IFF_LOOPBACK))
             {
                 if (ioctl(s, SIOCGIFHWADDR, &ifr) == 0)
                 {
                     ok = AXIS2_TRUE;
                     break;
                 }
             }
         }
     }
     buffer = (char *) malloc(6 * sizeof(char));
     if (ok)
     {
         sa = (struct sockaddr *) &ifr.ifr_addr;
         for (i = 0; i < 6; i++)
         buffer[i] = (unsigned char) (sa->sa_data[i] & 0xff);
     }
     else
     {
         for (i = 0; i < 6; i++)
         buffer[i] = (unsigned char) ((AXIS2_LOCAL_MAC_ADDR[i]) - '0');
     }
     close(s);
     return buffer;
 }

 #else

 #ifdef HAVE_GETIFADDRS   /* NetBSD, MacOSX, etc... */

 #ifndef max
 # define        max(a,b)        ((a) > (b) ? (a) : (b))
 #endif                          /* !max */

 char *AXIS2_CALL
 axutil_uuid_get_mac_addr(
 )
 {
     struct ifaddrs *ifap;
     struct ifaddrs *ifap_head;
     const struct sockaddr_dl *sdl;
     unsigned char *ucp;
     int i;
     char *data_ptr;

     if (getifaddrs(&ifap_head) < 0)
     return NULL;
     for (ifap = ifap_head; ifap != NULL; ifap = ifap->ifa_next)
     {
         if (ifap->ifa_addr != NULL && ifap->ifa_addr->sa_family == AF_LINK)
         {
             sdl = (const struct sockaddr_dl *) (void *) ifap->ifa_addr;
             ucp = (unsigned char *) (sdl->sdl_data + sdl->sdl_nlen);
             if (sdl->sdl_alen > 0)
             {
                 data_ptr = malloc(6 * sizeof(char));
                 for (i = 0; i < 6 && i < sdl->sdl_alen; i++, ucp++)
                 data_ptr[i] = (unsigned char) (*ucp & 0xff);

                 freeifaddrs(ifap_head);
                 return data_ptr;
             }
         }
     }
     freeifaddrs(ifap_head);
     return NULL;
 }
 # else                          /* Solaris-ish */

 /* code modified from that posted on:
  * http://forum.sun.com/jive/thread.jspa?threadID=84804&tstart=30
  */

 char *AXIS2_CALL
 axutil_uuid_get_mac_addr()
 {
     char hostname[MAXHOSTNAMELEN];
     char *data_ptr;
     struct hostent *he;
     struct arpreq ar;
     struct sockaddr_in *sa;
     int s;
     int i;

     if(gethostname(hostname, sizeof(hostname)) < 0)
         return NULL;
     if((he = gethostbyname(hostname)) == NULL)
         return NULL;
     if((s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
         return NULL;
     memset(&ar, 0, sizeof(ar));
     sa = (struct sockaddr_in *)((void *)&(ar.arp_pa));
     sa->sin_family = AF_INET;
     memcpy(&(sa->sin_addr), *(he->h_addr_list), sizeof(struct in_addr));
     if(ioctl(s, SIOCGARP, &ar) < 0)
     {
         close(s);
         return NULL;
     }
     close(s);
     if(!(ar.arp_flags & ATF_COM))
         return NULL;
     data_ptr = malloc(6 * sizeof(char));
     for(i = 0; i < 6; i++)
         data_ptr[i] = (unsigned char)(ar.arp_ha.sa_data[i] & 0xff);

     return data_ptr;
 }
 # endif
 #endif
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <config.h>

	#include <sys/ioctl.h>
	#include <string.h>
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <netdb.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <sys/time.h>

	#ifdef HAVE_LINUX_IF_H
	# include <linux/if.h>
	#else
	# ifdef HAVE_NET_IF_H
	# ifdef HAVE_SYS_SOCKIO_H
	# include <sys/sockio.h>
	# endif
	# include <net/if.h>
	# include <net/if_arp.h>
	# endif
	# ifdef HAVE_NET_IF_TYPES_H
	# include <net/if_types.h>
	# endif
	# ifdef HAVE_NET_IF_DL_H
	# include <net/if_dl.h>
	# endif
	#endif
	#ifdef HAVE_GETIFADDRS
	#include <ifaddrs.h>
	#endif
	#include <platforms/unix/axutil_uuid_gen_unix.h>
	#include <platforms/axutil_platform_auto_sense.h>

	#ifdef AXIS2_SSL_ENABLED
	#include <openssl/rand.h>
	#endif


	/* We need these static variables to track throughout the program execution */
	static axis2_bool_t axutil_uuid_gen_is_first = AXIS2_TRUE;
	static struct axutil_uuid_st axutil_uuid_static;

	axutil_uuid_t *AXIS2_CALL
	axutil_uuid_gen_v1()
	{
	struct timeval time_now;
	struct timeval tv;
	unsigned long long time_val;
	unsigned long long time_val2;
	unsigned short int clck = 0;
	axutil_uuid_t *ret_uuid = NULL;
	unsigned short int time_high_version = 0;

	if(AXIS2_TRUE == axutil_uuid_gen_is_first)
	{
	char *mac_addr = axutil_uuid_get_mac_addr();
	if (mac_addr) {
	memcpy(axutil_uuid_static.mac, mac_addr, 6);
	free(mac_addr);
	} else {
	/* Default value, not expected to go there */
	#ifdef AXIS2_SSL_ENABLED
	RAND_bytes(axutil_uuid_static.mac, 6);
	#else
	memset(axutil_uuid_static.mac, 0, 6);
	#endif
	}
	axutil_uuid_static.time_seq = 0;
	axutil_uuid_static.clock = 0;
	axutil_uuid_gen_is_first = AXIS2_FALSE;
	}
	/*
	* GENERATE TIME
	*/

	/* determine current system time and sequence counter */
	if(gettimeofday(&time_now, NULL) == -1)
	return NULL;

	/* check whether system time changed since last retrieve */
	if(!(time_now.tv_sec == axutil_uuid_static.time_last.tv_sec && time_now.tv_usec
	== axutil_uuid_static.time_last.tv_usec))
	{
	/* reset time sequence counter and continue */
	axutil_uuid_static.time_seq = 0;
	}

	/* until we are out of UUIDs per tick, increment
	the time/tick sequence counter and continue */
	while(axutil_uuid_static.time_seq < UUIDS_PER_TICK)
	{
	axutil_uuid_static.time_seq++;
	}
	/* sleep for 1000ns (1us) */
	tv.tv_sec = 0;
	tv.tv_usec = 1;
	/*
	The following select causes severe performance problems.
	Hence commenting out. I am not sure why this is required. - Samisa.
	select(0, NULL, NULL, NULL, &tv); */

	time_val = (unsigned long long)time_now.tv_sec * 10000000ull;
	time_val += (unsigned long long)time_now.tv_usec * 10ull;

	ret_uuid = malloc(sizeof(axutil_uuid_t));

	time_val += UUID_TIMEOFFSET;
	/* compensate for low resolution system clock by adding
	the time/tick sequence counter */
	if(axutil_uuid_static.time_seq > 0)
	time_val += (unsigned long long)axutil_uuid_static.time_seq;

	time_val2 = time_val;
	ret_uuid->time_low = (unsigned long)time_val2;
	time_val2 >>= 32;
	ret_uuid->time_mid = (unsigned short int)time_val2;
	time_val2 >>= 16;
	time_high_version = (unsigned short int)time_val2;

	/* store the 60 LSB of the time in the UUID and make version 1 */
	time_high_version <<= 4;
	time_high_version &= 0xFFF0;
	time_high_version \|= 0x0001;
	ret_uuid->time_high_version = time_high_version;

	/*
	* GENERATE CLOCK
	*/

	/* retrieve current clock sequence */
	clck = axutil_uuid_static.clock;

	/* generate new random clock sequence (initially or if the
	time has stepped backwards) or else just increase it */
	if(clck == 0 \|\| (time_now.tv_sec < axutil_uuid_static.time_last.tv_sec \|\| (time_now.tv_sec
	== axutil_uuid_static.time_last.tv_sec && time_now.tv_usec
	< axutil_uuid_static.time_last.tv_usec)))
	{
	srand(time_now.tv_usec);
	clck = rand();
	}
	else
	{
	clck++;
	}
	clck %= (2 << 14);

	/* store back new clock sequence */
	axutil_uuid_static.clock = clck;

	clck &= 0x1FFF;
	clck \|= 0x2000;

	/*
	* FINISH
	*/
	/* remember current system time for next iteration */
	axutil_uuid_static.time_last.tv_sec = time_now.tv_sec;
	axutil_uuid_static.time_last.tv_usec = time_now.tv_usec;

	if(!ret_uuid)
	{
	return NULL;
	}
	ret_uuid->clock_variant = clck;
	memcpy(ret_uuid->mac_addr, axutil_uuid_static.mac, 6);
	return ret_uuid;
	}

	axis2_char_t *AXIS2_CALL
	axutil_platform_uuid_gen(
	char *s)
	{
	axutil_uuid_t *uuid_struct = NULL;
	axis2_char_t *uuid_str = NULL;
	unsigned char mac[7];
	char mac_hex[13];

	if(!s)
	{
	return NULL;
	}
	uuid_struct = axutil_uuid_gen_v1();
	if(!uuid_struct)
	{
	return NULL;
	}
	uuid_str = s;
	if(!uuid_str)
	{
	return NULL;
	}
	memcpy(mac, uuid_struct->mac_addr, 6);
	sprintf(mac_hex, "%02x%02x%02x%02x%02x%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	sprintf(uuid_str, "%08x-%04x-%04x-%04x-%s", uuid_struct->time_low, uuid_struct->time_mid,
	uuid_struct->time_high_version, uuid_struct->clock_variant, mac_hex);
	free(uuid_struct);
	uuid_struct = NULL;
	return uuid_str;
	}

	#ifdef HAVE_LINUX_IF_H /* Linux */

	char *AXIS2_CALL
	axutil_uuid_get_mac_addr(
	)
	{
	struct ifreq ifr;
	struct ifreq *IFR;
	struct ifconf ifc;
	struct sockaddr *sa;
	int s = 0;
	int i = 0;
	char *buffer = NULL;
	char buf[1024];
	int ok = AXIS2_FALSE;

	if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
	return NULL;

	ifc.ifc_len = sizeof(buf);
	ifc.ifc_buf = buf;
	ioctl(s, SIOCGIFCONF, &ifc);
	IFR = ifc.ifc_req;

	for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; IFR++)
	{
	strcpy(ifr.ifr_name, IFR->ifr_name);
	/sprintf(ifr.ifr_name, "eth0"); /
	if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0)
	{
	if (!(ifr.ifr_flags & IFF_LOOPBACK))
	{
	if (ioctl(s, SIOCGIFHWADDR, &ifr) == 0)
	{
	ok = AXIS2_TRUE;
	break;
	}
	}
	}
	}
	buffer = (char ) malloc(6 sizeof(char));
	if (ok)
	{
	sa = (struct sockaddr *) &ifr.ifr_addr;
	for (i = 0; i < 6; i++)
	buffer[i] = (unsigned char) (sa->sa_data[i] & 0xff);
	}
	else
	{
	for (i = 0; i < 6; i++)
	buffer[i] = (unsigned char) ((AXIS2_LOCAL_MAC_ADDR[i]) - '0');
	}
	close(s);
	return buffer;
	}

	#else

	#ifdef HAVE_GETIFADDRS /* NetBSD, MacOSX, etc... */

	#ifndef max
	# define max(a,b) ((a) > (b) ? (a) : (b))
	#endif /* !max */

	char *AXIS2_CALL
	axutil_uuid_get_mac_addr(
	)
	{
	struct ifaddrs *ifap;
	struct ifaddrs *ifap_head;
	const struct sockaddr_dl *sdl;
	unsigned char *ucp;
	int i;
	char *data_ptr;

	if (getifaddrs(&ifap_head) < 0)
	return NULL;
	for (ifap = ifap_head; ifap != NULL; ifap = ifap->ifa_next)
	{
	if (ifap->ifa_addr != NULL && ifap->ifa_addr->sa_family == AF_LINK)
	{
	sdl = (const struct sockaddr_dl ) (void ) ifap->ifa_addr;
	ucp = (unsigned char *) (sdl->sdl_data + sdl->sdl_nlen);
	if (sdl->sdl_alen > 0)
	{
	data_ptr = malloc(6 * sizeof(char));
	for (i = 0; i < 6 && i < sdl->sdl_alen; i++, ucp++)
	data_ptr[i] = (unsigned char) (*ucp & 0xff);

	freeifaddrs(ifap_head);
	return data_ptr;
	}
	}
	}
	freeifaddrs(ifap_head);
	return NULL;
	}
	# else /* Solaris-ish */

	/* code modified from that posted on:
	* http://forum.sun.com/jive/thread.jspa?threadID=84804&tstart=30
	*/

	char *AXIS2_CALL
	axutil_uuid_get_mac_addr()
	{
	char hostname[MAXHOSTNAMELEN];
	char *data_ptr;
	struct hostent *he;
	struct arpreq ar;
	struct sockaddr_in *sa;
	int s;
	int i;

	if(gethostname(hostname, sizeof(hostname)) < 0)
	return NULL;
	if((he = gethostbyname(hostname)) == NULL)
	return NULL;
	if((s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
	return NULL;
	memset(&ar, 0, sizeof(ar));
	sa = (struct sockaddr_in )((void )&(ar.arp_pa));
	sa->sin_family = AF_INET;
	memcpy(&(sa->sin_addr), *(he->h_addr_list), sizeof(struct in_addr));
	if(ioctl(s, SIOCGARP, &ar) < 0)
	{
	close(s);
	return NULL;
	}
	close(s);
	if(!(ar.arp_flags & ATF_COM))
	return NULL;
	data_ptr = malloc(6 * sizeof(char));
	for(i = 0; i < 6; i++)
	data_ptr[i] = (unsigned char)(ar.arp_ha.sa_data[i] & 0xff);

	return data_ptr;
	}
	# endif
	#endif