+ memset(psa, 0, sizeof(struct sockaddr_in));
+ psa->sin_family = AF_INET;
+ memcpy(&psa->sin_addr, *paddrs, sizeof(struct in_addr));
+
+ status = ioctl(sock, SIOCGARP, &parpreq);
+ if(status == -1)
+ {
+ perror("SIOCGARP");
+ return -1;
+ }
+ memcpy(addr, parpreq.arp_ha.sa_data, 6);
+
+ return 0;
+#else
+#ifdef CMAKE_HAVE_NET_IF_H
+ int sd;
+ struct ifreq ifr, *ifrp;
+ struct ifconf ifc;
+ char buf[1024];
+ int n, i;
+ unsigned char *a;
+#if defined(AF_LINK) && (!defined(SIOCGIFHWADDR) && !defined(SIOCGENADDR))
+ struct sockaddr_dl *sdlp;
+#endif
+
+//
+// BSD 4.4 defines the size of an ifreq to be
+// max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
+// However, under earlier systems, sa_len isn't present, so the size is
+// just sizeof(struct ifreq)
+// We should investiage the use of SIZEOF_ADDR_IFREQ
+//
+#ifdef HAVE_SA_LEN
+ #ifndef max
+ #define max(a,b) ((a) > (b) ? (a) : (b))
+ #endif
+ #define ifreq_size(i) max(sizeof(struct ifreq),\
+ sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
+#else
+ #define ifreq_size(i) sizeof(struct ifreq)
+#endif // HAVE_SA_LEN
+
+ if( (sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) < 0 )
+ {
+ return -1;
+ }
+ memset(buf, 0, sizeof(buf));
+ ifc.ifc_len = sizeof(buf);
+ ifc.ifc_buf = buf;
+ if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0)
+ {
+ close(sd);
+ return -1;
+ }
+ n = ifc.ifc_len;
+ for (i = 0; i < n; i+= ifreq_size(*ifrp) )
+ {
+ ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
+ strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ);
+#ifdef SIOCGIFHWADDR
+ if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
+ continue;
+ a = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
+#else
+#ifdef SIOCGENADDR
+ // In theory this call should also work on Sun Solaris, but apparently
+ // SIOCGENADDR is not implemented properly thus the call
+ // ioctl(sd, SIOCGENADDR, &ifr) always returns errno=2
+ // (No such file or directory)
+ // Furthermore the DLAPI seems to require full root access
+ if (ioctl(sd, SIOCGENADDR, &ifr) < 0)
+ continue;
+ a = (unsigned char *) ifr.ifr_enaddr;
+#else
+#ifdef AF_LINK
+ sdlp = (struct sockaddr_dl *) &ifrp->ifr_addr;
+ if ((sdlp->sdl_family != AF_LINK) || (sdlp->sdl_alen != 6))
+ continue;
+ a = (unsigned char *) &sdlp->sdl_data[sdlp->sdl_nlen];
+#else
+ perror("No way to access hardware");
+ close(sd);
+ return -1;
+#endif // AF_LINK
+#endif // SIOCGENADDR
+#endif // SIOCGIFHWADDR
+ if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5]) continue;
+
+ if (addr)
+ {
+ memcpy(addr, a, 6);
+ close(sd);
+ return 0;
+ }
+ }
+ close(sd);
+#endif
+ // Not implemented platforms
+ perror("There was a configuration problem on your plateform");
+ memset(addr,0,6);
+ return -1;
+#endif //__sun
+}
+
+/**
+ * Mini function to return the last digit from a number express in base 256
+ * pre condition data contain an array of 6 unsigned char
+ * post condition carry contain the last digit
+ */
+inline int getlastdigit(unsigned char *data)
+{
+ int extended, carry = 0;
+ for(int i=0;i<6;i++)
+ {
+ extended = (carry << 8) + data[i];
+ data[i] = extended / 10;
+ carry = extended % 10;
+ }
+ return carry;
+}
+
+/**
+ * \brief Encode the mac address on a fixed lenght string of 15 characters.
+ * we save space this way.
+ */
+std::string Util::GetMACAddress()
+{
+ // This code is the result of a long internet search to find something
+ // as compact as possible (not OS independant). We only have to separate
+ // 3 OS: Win32, SunOS and 'real' POSIX
+ // http://groups-beta.google.com/group/comp.unix.solaris/msg/ad36929d783d63be
+ // http://bdn.borland.com/article/0,1410,26040,00.html
+ unsigned char addr[6];
+
+ int stat = GetMacAddrSys(addr);
+ if (stat == 0)
+ {
+ // We need to convert a 6 digit number from base 256 to base 10, using integer
+ // would requires a 48bits one. To avoid this we have to reimplement the div + modulo
+ // with string only
+ bool zero = false;
+ int res;
+ std::string sres;
+ while(!zero)
+ {
+ res = getlastdigit(addr);
+ sres.insert(sres.begin(), '0' + res);
+ zero = (addr[0] == 0) && (addr[1] == 0) && (addr[2] == 0) && (addr[3] == 0) && (addr[4] == 0) && (addr[5] == 0);
+ }
+
+ return sres;
+ }
+ else
+ {
+ gdcmVerboseMacro("Problem in finding the MAC Address");
+ return "";
+ }
+}
+
+/**
+ * \brief Return the IP adress of the machine writting the DICOM image
+ */
+std::string Util::GetIPAddress()
+{
+ // This is a rip from
+ // http://www.codeguru.com/Cpp/I-N/internet/network/article.php/c3445/
+#ifndef HOST_NAME_MAX
+ // SUSv2 guarantees that `Host names are limited to 255 bytes'.
+ // POSIX 1003.1-2001 guarantees that `Host names (not including the
+ // terminating NUL) are limited to HOST_NAME_MAX bytes'.
+#define HOST_NAME_MAX 255
+ // In this case we should maybe check the string was not truncated.
+ // But I don't known how to check that...
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__)
+ // with WinSock DLL we need to initialize the WinSock before using gethostname
+ WORD wVersionRequested = MAKEWORD(1,0);
+ WSADATA WSAData;
+ int err = WSAStartup(wVersionRequested,&WSAData);
+ if (err != 0)
+ {
+ // Tell the user that we could not find a usable
+ // WinSock DLL.
+ WSACleanup();
+ return "127.0.0.1";
+ }
+#endif
+
+#endif //HOST_NAME_MAX
+
+ std::string str;
+ char szHostName[HOST_NAME_MAX+1];
+ int r = gethostname(szHostName, HOST_NAME_MAX);
+
+ if( r == 0 )
+ {
+ // Get host adresses
+ struct hostent *pHost = gethostbyname(szHostName);
+
+ for( int i = 0; pHost!= NULL && pHost->h_addr_list[i]!= NULL; i++ )
+ {
+ for( int j = 0; j<pHost->h_length; j++ )
+ {
+ if( j > 0 ) str += ".";
+
+ str += Util::Format("%u",
+ (unsigned int)((unsigned char*)pHost->h_addr_list[i])[j]);
+ }
+ // str now contains one local IP address
+
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__)
+ WSACleanup();
+#endif
+
+ }
+ }
+ // If an error occur r == -1
+ // Most of the time it will return 127.0.0.1...
+ return str;
+}
+
+unsigned int Util::GetCurrentThreadID()
+{
+// FIXME the implementation is far from complete
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__)
+ return (unsigned int)GetCurrentThreadId();
+#endif
+#ifdef __linux__
+ return 0;
+ // Doesn't work on fedora, but is in the man page...
+ //return (unsigned int)gettid();
+#endif
+#ifdef __sun
+ return (unsigned int)thr_self();
+#else
+ //default implementation
+ return 0;
+#endif
+}
+
+unsigned int Util::GetCurrentProcessID()
+{
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__)
+ // NOTE: There is also a _getpid()...
+ return (unsigned int)GetCurrentProcessId();
+#else
+ // get process identification, POSIX
+ return (unsigned int)getpid();
+#endif
+}
+
+/**
+ * \brief Creates a new UID. As stipulate in the DICOM ref
+ * each time a DICOM image is create it should have
+ * a unique identifier (URI)
+ * @param root is the DICOM prefix assigned by IOS group
+ */
+std::string Util::CreateUniqueUID(const std::string &root)
+{
+ std::string prefix;
+ std::string append;
+ if( root.empty() )
+ {
+ // gdcm UID prefix, as supplied by http://www.medicalconnections.co.uk
+ prefix = RootUID;
+ }
+ else
+ {
+ prefix = root;
+ }
+
+ // A root was specified use it to forge our new UID:
+ append += ".";
+ append += Util::GetMACAddress();
+ append += ".";
+ append += Util::GetCurrentDateTime();
+
+ //Also add a mini random number just in case:
+ int r = (int) (100.0*rand()/RAND_MAX);
+ append += Format("%02d", r);
+
+ // If append is too long we need to rehash it
+ if( (prefix + append).size() > 64 )
+ {
+ gdcmErrorMacro( "Size of UID is too long." );
+ // we need a hash function to truncate this number
+ // if only md5 was cross plateform
+ // MD5(append);
+ }
+
+ return prefix + append;
+}
+
+void Util::SetRootUID(const std::string &root)
+{
+ if( root.empty() )
+ RootUID = GDCM_UID;
+ else
+ RootUID = root;
+}
+
+const std::string &Util::GetRootUID()
+{
+ return RootUID;
+}
+
+//-------------------------------------------------------------------------
+/**
+ * \brief
+ * @param os ostream to write to
+ * @param val val
+ */
+template <class T>
+std::ostream &binary_write(std::ostream &os, const T &val)
+{
+ return os.write(reinterpret_cast<const char*>(&val), sizeof val);
+}
+
+/**
+ * \brief binary_write binary_write
+ * @param os ostream to write to
+ * @param val val
+ */
+std::ostream &binary_write(std::ostream &os, const uint16_t &val)
+{
+#ifdef GDCM_WORDS_BIGENDIAN
+ uint16_t swap;
+ swap = ((( val << 8 ) & 0x0ff00 ) | (( val >> 8 ) & 0x00ff ) );
+ return os.write(reinterpret_cast<const char*>(&swap), 2);
+#else
+ return os.write(reinterpret_cast<const char*>(&val), 2);
+#endif //GDCM_WORDS_BIGENDIAN
+}
+
+/**
+ * \brief binary_write binary_write
+ * @param os ostream to write to
+ * @param val val
+ */
+std::ostream &binary_write(std::ostream &os, const uint32_t &val)
+{
+#ifdef GDCM_WORDS_BIGENDIAN
+ uint32_t swap;
+ swap = ( ((val<<24) & 0xff000000) | ((val<<8) & 0x00ff0000) |
+ ((val>>8) & 0x0000ff00) | ((val>>24) & 0x000000ff) );
+ return os.write(reinterpret_cast<const char*>(&swap), 4);
+#else
+ return os.write(reinterpret_cast<const char*>(&val), 4);
+#endif //GDCM_WORDS_BIGENDIAN
+}
+
+/**
+ * \brief binary_write binary_write
+ * @param os ostream to write to
+ * @param val val
+ */
+std::ostream &binary_write(std::ostream &os, const char *val)
+{
+ return os.write(val, strlen(val));
+}
+
+/**
+ * \brief
+ * @param os ostream to write to
+ * @param val val
+ */
+std::ostream &binary_write(std::ostream &os, std::string const &val)
+{
+ return os.write(val.c_str(), val.size());
+}