sysdep.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
     #include "copyrt.h"
     #include <stdio.h>
     #include <memory.h>
     #include <unistd.h>
     #include "sysdep.h"

#ifdef Darwin
#include <mach/thread_act.h>
#include <mach/thread_info.h>
#include <mach/mach_init.h>
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/semaphore.h>
#endif

     /* system dependent call to get IEEE node ID.
        This sample implementation generates a random node ID
        */
     void get_ieee_node_identifier(uuid_node_t *node) {
       char seed[16];
       FILE * fd;
       static int inited = 0;
       static uuid_node_t saved_node;

       if (!inited) {
           fd = fopen("nodeid", "rb");
           if (fd) {
                fread(&saved_node, sizeof(uuid_node_t), 1, fd);
                fclose(fd);
           }
           else {
                get_random_info(seed);
                seed[0] |= 0x80;
                memcpy(&saved_node, seed, sizeof(uuid_node_t));
                fd = fopen("nodeid", "wb");
                if (fd) {
                       fwrite(&saved_node, sizeof(uuid_node_t), 1, fd);
                       fclose(fd);
                };
           };
           inited = 1;
       };


       *node = saved_node;
     };

     /* system dependent call to get the current system time.
        Returned as 100ns ticks since Oct 15, 1582, but resolution may be
        less than 100ns.
     */
     #ifdef _WINDOWS_

     void get_system_time(uuid_time_t *uuid_time) {
       ULARGE_INTEGER time;

       GetSystemTimeAsFileTime((FILETIME *)&time);

         /* NT keeps time in FILETIME format which is 100ns ticks since
          Jan 1, 1601.  UUIDs use time in 100ns ticks since Oct 15, 1582.
          The difference is 17 Days in Oct + 30 (Nov) + 31 (Dec)
          + 18 years and 5 leap days.
       */

         time.QuadPart +=
               (unsigned __int64) (1000*1000*10)       // seconds
             * (unsigned __int64) (60 * 60 * 24)       // days
             * (unsigned __int64) (17+30+31+365*18+5); // # of days

       *uuid_time = time.QuadPart;

     };


     void get_random_info(char seed[16]) {
       MD5_CTX c;
       typedef struct {
           MEMORYSTATUS m;
           SYSTEM_INFO s;
           FILETIME t;
           LARGE_INTEGER pc;
           DWORD tc;
           DWORD l;
           char hostname[MAX_COMPUTERNAME_LENGTH + 1];
       } randomness;
       randomness r;

       MD5Init(&c);
       /* memory usage stats */
       GlobalMemoryStatus(&r.m);
       /* random system stats */
       GetSystemInfo(&r.s);
       /* 100ns resolution (nominally) time of day */
       GetSystemTimeAsFileTime(&r.t);
       /* high resolution performance counter */
       QueryPerformanceCounter(&r.pc);
       /* milliseconds since last boot */
       r.tc = GetTickCount();
       r.l = MAX_COMPUTERNAME_LENGTH + 1;

       GetComputerName(r.hostname, &r.l );
       MD5Update(&c, &r, sizeof(randomness));
       MD5Final(seed, &c);
     };
     #else

     void get_system_time(uuid_time_t *uuid_time)
     {
         struct timeval tp;

         gettimeofday(&tp, (struct timezone *)0);

         /* Offset between UUID formatted times and Unix formatted times.
            UUID UTC base time is October 15, 1582.
            Unix base time is January 1, 1970.
         */
         *uuid_time = (tp.tv_sec * 10000000) + (tp.tv_usec * 10) +
           I64(0x01B21DD213814000);
     };

        #ifdef Darwin

     void get_random_info(char seed[16]) {
       MD5_CTX c;
       typedef struct {
           struct thread_basic_info b;
           struct timeval t;
           char hostname[257];
       } randomness;
       randomness r;

       MD5Init(&c);


                mach_msg_type_number_t my_info_size;
                mach_port_t my_thread_self;
                kern_return_t kr;

                my_thread_self = mach_thread_self();
                my_info_size = sizeof(r.b)/sizeof(int);
                kr = thread_info(my_thread_self, THREAD_BASIC_INFO, (thread_info_t)&r.b,&my_info_size);
                mach_port_deallocate(mach_task_self(), my_thread_self);

                if (kr != KERN_SUCCESS) {
                  //    printf("thread_info returned error... %d\n", kr);
                }
                else {
                  //    printf("thread_info user: %d  kernel: %d  cpu: %d  \n", r.b.user_time, r.b.system_time, r.b.cpu_usage);
                }

       gettimeofday(&r.t, (struct timezone *)0);
       gethostname(r.hostname, 256);
       MD5Update(&c, ((unsigned char*)(&r)), sizeof(randomness));
       MD5Final((unsigned char*)seed, &c);
     };

        #else

     void get_random_info(char seed[16]) {
       MD5_CTX c;
       typedef struct {
           struct sysinfo s;
           struct timeval t;
           char hostname[257];
       } randomness;
       randomness r;

       MD5Init(&c);
       sysinfo(&r.s);
       gettimeofday(&r.t, (struct timezone *)0);
       gethostname(r.hostname, 256);
       MD5Update(&c, ((unsigned char*)(&r)), sizeof(randomness));
       MD5Final((unsigned char*)seed, &c);
     };

     #endif
     #endif

---