]> Creatis software - gdcm.git/blob - src/gdcmUtil.cxx
STYLE: Cleanup the Mac address stuff (1st pass)
[gdcm.git] / src / gdcmUtil.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmUtil.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/01/15 00:52:36 $
7   Version:   $Revision: 1.90 $
8                                                                                 
9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
10   l'Image). All rights reserved. See Doc/License.txt or
11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
12                                                                                 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notices for more information.
16                                                                                 
17 =========================================================================*/
18
19 #include "gdcmUtil.h"
20 #include "gdcmDebug.h"
21 #include <iostream>
22
23 // For GetCurrentDate, GetCurrentTime
24 #include <time.h>
25 #include <sys/types.h>
26 #include <sys/stat.h>
27
28 #include <stdarg.h>  //only included in implementation file
29 #include <stdio.h>   //only included in implementation file
30
31 #if defined(_MSC_VER)
32    #include <winsock.h>  // for gethostname & gethostbyname
33    #undef GetCurrentTime
34 #else
35 #ifndef __BORLANDC__
36    #include <unistd.h>  // for gethostname
37    #include <netdb.h>   // for gethostbyname
38 #endif
39 #endif
40
41 // For GetMACAddress
42 #include <fcntl.h>
43 #include <stdlib.h>
44 #include <string.h>
45
46 #ifdef _WIN32
47 #include <snmp.h>
48 #include <conio.h>
49 #else
50 #include <strings.h> //for bzero on unix
51 #endif
52
53 #ifdef __linux__
54 #include <sys/ioctl.h>
55 #include <sys/types.h>
56 #include <sys/socket.h>
57 #include <netinet/in.h>
58 #include <linux/if.h>
59 #endif
60
61 #ifdef __FreeBSD__
62 #include <sys/types.h>
63 #include <sys/socket.h>
64 #include <ifaddrs.h>
65 #include <net/if_dl.h>
66 #endif
67
68 #ifdef __HP_aCC
69 #include <netio.h>
70 #endif
71
72 #ifdef _AIX
73 #include <sys/ndd_var.h>
74 #include <sys/kinfo.h>
75 #endif
76
77 #ifdef __APPLE__
78 #include <CoreFoundation/CoreFoundation.h>
79 #include <IOKit/IOKitLib.h>
80 #include <IOKit/network/IOEthernetInterface.h>
81 #include <IOKit/network/IONetworkInterface.h>
82 #include <IOKit/network/IOEthernetController.h>
83 #endif //__APPLE__
84 // End For GetMACAddress
85
86 namespace gdcm 
87 {
88 /**
89  * \ingroup Globals
90  * \brief Provide a better 'c++' approach for sprintf
91  * For example c code is:
92  * sprintf(trash, "%04x|%04x", group , elem);
93  *
94  * c++ code is 
95  * std::ostringstream buf;
96  * buf << std::right << std::setw(4) << std::setfill('0') << std::hex
97  *     << group << "|" << std::right << std::setw(4) << std::setfill('0') 
98  *     << std::hex <<  elem;
99  * buf.str();
100  *
101  * gdcm style code is
102  * Format("%04x|%04x", group , elem);
103  */
104
105 std::string Util::Format(const char *format, ...)
106 {
107    char buffer[2048];
108    va_list args;
109    va_start(args, format);
110    vsprintf(buffer, format, args);  //might be a security flaw
111    va_end(args); // Each invocation of va_start should be matched 
112                  // by a corresponding invocation of va_end
113                  // args is then 'undefined'
114    return buffer;
115 }
116
117
118 /**
119  * \ingroup Globals
120  * \brief Because not available in C++ (?)
121  */
122 void Util::Tokenize (const std::string &str,
123                      std::vector<std::string> &tokens,
124                      const std::string& delimiters)
125 {
126    std::string::size_type lastPos = str.find_first_not_of(delimiters,0);
127    std::string::size_type pos     = str.find_first_of    (delimiters,lastPos);
128    while (std::string::npos != pos || std::string::npos != lastPos)
129    {
130       tokens.push_back(str.substr(lastPos, pos - lastPos));
131       lastPos = str.find_first_not_of(delimiters, pos);
132       pos     = str.find_first_of    (delimiters, lastPos);
133    }
134 }
135
136 /**
137  * \ingroup Globals
138  * \brief Because not available in C++ (?)
139  *        Counts the number of occurences of a substring within a string
140  */
141  
142 int Util::CountSubstring (const std::string &str,
143                           const std::string &subStr)
144 {
145    int count = 0;   // counts how many times it appears
146    std::string::size_type x = 0;       // The index position in the string
147
148    do
149    {
150       x = str.find(subStr,x);       // Find the substring
151       if (x != std::string::npos)   // If present
152       {
153          count++;                  // increase the count
154          x += subStr.length();     // Skip this word
155       }
156    }
157    while (x != std::string::npos);  // Carry on until not present
158
159    return count;
160 }
161
162 /**
163  * \ingroup Globals
164  * \brief  Weed out a string from the non-printable characters (in order
165  *         to avoid corrupting the terminal of invocation when printing)
166  * @param s string to remove non printable characters from
167  */
168 std::string Util::CreateCleanString(std::string const &s)
169 {
170    std::string str = s;
171
172    for(unsigned int i=0; i<str.size(); i++)
173    {
174       if(!isprint((unsigned char)str[i]))
175       {
176          str[i] = '.';
177       }
178    }
179
180    if(str.size() > 0)
181    {
182       if(!isprint((unsigned char)s[str.size()-1]))
183       {
184          if(s[str.size()-1] == 0)
185          {
186             str[str.size()-1] = ' ';
187          }
188       }
189    }
190
191    return str;
192 }
193
194 /**
195  * \ingroup Globals
196  * \brief   Add a SEPARATOR to the end of the name is necessary
197  * @param   pathname file/directory name to normalize 
198  */
199 std::string Util::NormalizePath(std::string const &pathname)
200 {
201    const char SEPARATOR_X      = '/';
202    const char SEPARATOR_WIN    = '\\';
203    const std::string SEPARATOR = "/";
204    std::string name = pathname;
205    int size = name.size();
206
207    if( name[size-1] != SEPARATOR_X && name[size-1] != SEPARATOR_WIN )
208    {
209       name += SEPARATOR;
210    }
211    return name;
212 }
213
214 /**
215  * \ingroup Globals
216  * \brief   Get the (directory) path from a full path file name
217  * @param   fullName file/directory name to extract Path from
218  */
219 std::string Util::GetPath(std::string const &fullName)
220 {
221    std::string res = fullName;
222    int pos1 = res.rfind("/");
223    int pos2 = res.rfind("\\");
224    if( pos1 > pos2)
225    {
226       res.resize(pos1);
227    }
228    else
229    {
230       res.resize(pos2);
231    }
232
233    return res;
234 }
235
236 /**
237  * \ingroup Util
238  * \brief   Get the (last) name of a full path file name
239  * @param   fullName file/directory name to extract end name from
240  */
241 std::string Util::GetName(std::string const &fullName)
242 {   
243   std::string filename = fullName;
244
245   std::string::size_type slash_pos = filename.rfind("/");
246   std::string::size_type backslash_pos = filename.rfind("\\");
247   slash_pos = slash_pos > backslash_pos ? slash_pos : backslash_pos;
248   if(slash_pos != std::string::npos)
249     {
250     return filename.substr(slash_pos + 1);
251     }
252   else
253     {
254     return filename;
255     }
256
257
258 /**
259  * \ingroup Util
260  * \brief   Get the current date of the system in a dicom string
261  */
262 std::string Util::GetCurrentDate()
263 {
264     char tmp[512];
265     time_t tloc;
266     time (&tloc);    
267     strftime(tmp,512,"%Y%m%d", localtime(&tloc) );
268     return tmp;
269 }
270
271 /**
272  * \ingroup Util
273  * \brief   Get the current time of the system in a dicom string
274  */
275 std::string Util::GetCurrentTime()
276 {
277     char tmp[512];
278     time_t tloc;
279     time (&tloc);
280     strftime(tmp,512,"%H%M%S", localtime(&tloc) );
281     return tmp;  
282 }
283
284 /**
285  * \brief Create a /DICOM/ string:
286  * It should a of even length (no odd length ever)
287  * It can contain as many (if you are reading this from your
288  * editor the following character is is backslash followed by zero
289  * that needed to be escaped with an extra backslash for doxygen) \\0
290  * as you want.
291  */
292 std::string Util::DicomString(const char *s, size_t l)
293 {
294    std::string r(s, s+l);
295    gdcmAssertMacro( !(r.size() % 2) ); // == basically 'l' is even
296    return r;
297 }
298
299 /**
300  * \ingroup Util
301  * \brief Create a /DICOM/ string:
302  * It should a of even lenght (no odd length ever)
303  * It can contain as many (if you are reading this from your
304  * editor the following character is is backslash followed by zero
305  * that needed to be escaped with an extra backslash for doxygen) \\0
306  * as you want.
307  * This function is similar to DicomString(const char*), 
308  * except it doesn't take a lenght. 
309  * It only pad with a null character if length is odd
310  */
311 std::string Util::DicomString(const char *s)
312 {
313    size_t l = strlen(s);
314    if( l%2 )
315    {
316       l++;
317    }
318    std::string r(s, s+l);
319    gdcmAssertMacro( !(r.size() % 2) );
320    return r;
321 }
322
323 /**
324  * \ingroup Util
325  * \brief Safely compare two Dicom String:
326  *        - Both string should be of even lenght
327  *        - We allow padding of even lenght string by either a null 
328  *          character of a space
329  */
330 bool Util::DicomStringEqual(const std::string &s1, const char *s2)
331 {
332   // s2 is the string from the DICOM reference: 'MONOCHROME1'
333   std::string s1_even = s1; //Never change input parameter
334   std::string s2_even = DicomString( s2 );
335   if( s1_even[s1_even.size()-1] == ' ')
336   {
337     s1_even[s1_even.size()-1] = '\0'; //replace space character by null
338   }
339   return s1_even == s2_even;
340 }
341
342
343
344 /**
345  * \ingroup Util
346  * \brief   tells us if the processor we are working with is BigEndian or not
347  */
348 bool Util::IsCurrentProcessorBigEndian()
349 {
350 #ifdef GDCM_WORDS_BIGENDIAN
351    return true;
352 #else
353    return false;
354 #endif
355 }
356
357
358
359 #ifdef _WIN32
360 typedef BOOL(WINAPI * pSnmpExtensionInit) (
361         IN DWORD dwTimeZeroReference,
362         OUT HANDLE * hPollForTrapEvent,
363         OUT AsnObjectIdentifier * supportedView);
364
365 typedef BOOL(WINAPI * pSnmpExtensionTrap) (
366         OUT AsnObjectIdentifier * enterprise,
367         OUT AsnInteger * genericTrap,
368         OUT AsnInteger * specificTrap,
369         OUT AsnTimeticks * timeStamp,
370         OUT RFC1157VarBindList * variableBindings);
371
372 typedef BOOL(WINAPI * pSnmpExtensionQuery) (
373         IN BYTE requestType,
374         IN OUT RFC1157VarBindList * variableBindings,
375         OUT AsnInteger * errorStatus,
376         OUT AsnInteger * errorIndex);
377
378 typedef BOOL(WINAPI * pSnmpExtensionInitEx) (
379         OUT AsnObjectIdentifier * supportedView);
380 #endif //_WIN32
381
382
383 #ifdef __APPLE__
384 // Returns an iterator containing the primary (built-in) Ethernet interface. 
385 // The caller is responsible for releasing the iterator after the caller is 
386 // done with it.
387 static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices)
388 {
389    kern_return_t   kernResult; 
390    mach_port_t     masterPort;
391    CFMutableDictionaryRef  matchingDict;
392    CFMutableDictionaryRef  propertyMatchDict;
393    
394    // Retrieve the Mach port used to initiate communication with I/O Kit
395    kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort);
396    if (KERN_SUCCESS != kernResult)
397    {
398        printf("IOMasterPort returned %d\n", kernResult);
399        return kernResult;
400    }
401    
402    // Ethernet interfaces are instances of class kIOEthernetInterfaceClass. 
403    // IOServiceMatching is a convenience function to create a dictionary 
404    // with the key kIOProviderClassKey and 
405    // the specified value.
406    matchingDict = IOServiceMatching(kIOEthernetInterfaceClass);
407
408    // Note that another option here would be:
409    // matchingDict = IOBSDMatching("en0");
410        
411    if (NULL == matchingDict)
412    {
413        printf("IOServiceMatching returned a NULL dictionary.\n");
414    }
415    else 
416    {
417       // Each IONetworkInterface object has a Boolean property with the 
418       // key kIOPrimaryInterface. Only the
419       // primary (built-in) interface has this property set to TRUE.
420       
421       // IOServiceGetMatchingServices uses the default matching criteria 
422       // defined by IOService. This considers
423       // only the following properties plus any family-specific matching 
424       // in this order of precedence 
425       // (see IOService::passiveMatch):
426       //
427       // kIOProviderClassKey (IOServiceMatching)
428       // kIONameMatchKey (IOServiceNameMatching)
429       // kIOPropertyMatchKey
430       // kIOPathMatchKey
431       // kIOMatchedServiceCountKey
432       // family-specific matching
433       // kIOBSDNameKey (IOBSDNameMatching)
434       // kIOLocationMatchKey
435       
436       // The IONetworkingFamily does not define any family-specific 
437       // matching. This means that in order to have 
438       // IOServiceGetMatchingServices consider the kIOPrimaryInterface 
439       // property, we must add that property to a separate dictionary and 
440       // then add that to our matching dictionary specifying 
441       // kIOPropertyMatchKey.
442           
443       propertyMatchDict = 
444          CFDictionaryCreateMutable( kCFAllocatorDefault, 0,
445                                     &kCFTypeDictionaryKeyCallBacks,
446                                     &kCFTypeDictionaryValueCallBacks);
447    
448       if (NULL == propertyMatchDict)
449       {
450           printf("CFDictionaryCreateMutable returned a NULL dictionary.\n");
451       }
452       else 
453       {
454          // Set the value in the dictionary of the property with the given 
455          // key, or add the key to the dictionary if it doesn't exist. 
456          // This call retains the value object passed in.
457          CFDictionarySetValue(propertyMatchDict, CFSTR(kIOPrimaryInterface), 
458                               kCFBooleanTrue); 
459          
460          // Now add the dictionary containing the matching value for 
461          // kIOPrimaryInterface to our main matching dictionary. This call 
462          // will retain propertyMatchDict, so we can release our reference 
463          // on propertyMatchDict after adding it to matchingDict.
464          CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), 
465                               propertyMatchDict);
466          CFRelease(propertyMatchDict);
467       }
468    }
469
470    // IOServiceGetMatchingServices retains the returned iterator, so release
471    // the iterator when we're done with it.
472    // IOServiceGetMatchingServices also consumes a reference on the matching
473    // dictionary so we don't need to release the dictionary explicitly.
474    kernResult = 
475      IOServiceGetMatchingServices(masterPort, matchingDict, matchingServices);
476    if (KERN_SUCCESS != kernResult)
477    {
478        printf("IOServiceGetMatchingServices returned %d\n", kernResult);
479    }
480
481    return kernResult;
482 }
483     
484 // Given an iterator across a set of Ethernet interfaces, return the MAC 
485 // address of the last one.
486 // If no interfaces are found the MAC address is set to an empty string.
487 // In this sample the iterator should contain just the primary interface.
488 static kern_return_t GetMACAddress_MAC(io_iterator_t intfIterator, 
489                                        UInt8 *MACAddress)
490 {
491    io_object_t   intfService;
492    io_object_t   controllerService;
493    kern_return_t kernResult = KERN_FAILURE;
494    
495    // Initialize the returned address
496    bzero(MACAddress, kIOEthernetAddressSize);
497    
498    // IOIteratorNext retains the returned object, so release it when we're 
499    // done with it.
500    while ( (intfService = IOIteratorNext(intfIterator)))
501    {
502       CFTypeRef MACAddressAsCFData;        
503
504       // IONetworkControllers can't be found directly by the 
505       // IOServiceGetMatchingServices call, since they are hardware nubs 
506       // and do not participate in driver matching. In other words,
507       // registerService() is never called on them. So we've found the 
508       // IONetworkInterface and will 
509       // get its parent controller by asking for it specifically.
510       
511       // IORegistryEntryGetParentEntry retains the returned object, so 
512       // release it when we're done with it.
513       kernResult = IORegistryEntryGetParentEntry( intfService,
514                                                   kIOServicePlane,
515                                                   &controllerService );
516
517       if (KERN_SUCCESS != kernResult)
518       {
519          printf("IORegistryEntryGetParentEntry returned 0x%08x\n", kernResult);
520       }
521       else
522       {
523          // Retrieve the MAC address property from the I/O Registry in the 
524          // form of a CFData
525          MACAddressAsCFData = 
526             IORegistryEntryCreateCFProperty( controllerService,
527                                              CFSTR(kIOMACAddress),
528                                              kCFAllocatorDefault,
529                                              0);
530          if (MACAddressAsCFData)
531          {
532             // for display purposes only; output goes to stderr
533             //CFShow(MACAddressAsCFData);
534             
535             // Get the raw bytes of the MAC address from the CFData
536             CFDataGetBytes(MACAddressAsCFData, 
537                            CFRangeMake(0, kIOEthernetAddressSize), 
538                            MACAddress);
539             CFRelease(MACAddressAsCFData);
540          }
541
542          // Done with the parent Ethernet controller object so we release it.
543          (void) IOObjectRelease(controllerService);
544       }
545
546       // Done with the Ethernet interface object so we release it.
547       (void) IOObjectRelease(intfService);
548    }
549
550    return kernResult;
551 }
552 #endif
553
554 long GetMacAddrSys ( u_char *addr)
555 {
556 #ifdef _WIN32
557    WSADATA WinsockData;
558    if (WSAStartup(MAKEWORD(2, 0), &WinsockData) != 0) 
559    {
560       std::cerr << "This program requires Winsock 2.x!" << std::endl;
561       return -1;
562    }
563
564    HANDLE PollForTrapEvent;
565    AsnObjectIdentifier SupportedView;
566    UINT OID_ifEntryType[] = { 1, 3, 6, 1, 2, 1, 2, 2, 1, 3 };
567    UINT OID_ifEntryNum[] = { 1, 3, 6, 1, 2, 1, 2, 1 };
568    UINT OID_ipMACEntAddr[] = { 1, 3, 6, 1, 2, 1, 2, 2, 1, 6 };
569    AsnObjectIdentifier MIB_ifMACEntAddr = {
570        sizeof(OID_ipMACEntAddr) / sizeof(UINT), OID_ipMACEntAddr };
571    AsnObjectIdentifier MIB_ifEntryType = {
572        sizeof(OID_ifEntryType) / sizeof(UINT), OID_ifEntryType };
573    AsnObjectIdentifier MIB_ifEntryNum = {
574        sizeof(OID_ifEntryNum) / sizeof(UINT), OID_ifEntryNum };
575    RFC1157VarBindList varBindList;
576    RFC1157VarBind varBind[2];
577    AsnInteger errorStatus;
578    AsnInteger errorIndex;
579    AsnObjectIdentifier MIB_NULL = { 0, 0 };
580    int ret;
581    int dtmp;
582    int i = 0, j = 0;
583    BOOL found = FALSE;
584
585    // Load the SNMP dll and get the addresses of the functions necessary
586    HINSTANCE m_hInst = LoadLibrary("inetmib1.dll");
587    if (m_hInst < (HINSTANCE) HINSTANCE_ERROR)
588    {
589       m_hInst = NULL;
590       return -1;
591    }
592    pSnmpExtensionInit m_Init =
593        (pSnmpExtensionInit) GetProcAddress(m_hInst, "SnmpExtensionInit");
594    pSnmpExtensionInitEx m_InitEx =
595        (pSnmpExtensionInitEx) GetProcAddress(m_hInst, "SnmpExtensionInitEx");
596    pSnmpExtensionQuery m_Query =
597        (pSnmpExtensionQuery) GetProcAddress(m_hInst, "SnmpExtensionQuery");
598    pSnmpExtensionTrap m_Trap =
599        (pSnmpExtensionTrap) GetProcAddress(m_hInst, "SnmpExtensionTrap");
600    m_Init(GetTickCount(), &PollForTrapEvent, &SupportedView);
601
602    /* Initialize the variable list to be retrieved by m_Query */
603    varBindList.list = varBind;
604    varBind[0].name = MIB_NULL;
605    varBind[1].name = MIB_NULL;
606
607    // Copy in the OID to find the number of entries in the
608    // Inteface table
609    varBindList.len = 1;        // Only retrieving one item
610    SNMP_oidcpy(&varBind[0].name, &MIB_ifEntryNum);
611    ret = m_Query(ASN_RFC1157_GETNEXTREQUEST, &varBindList, &errorStatus,
612                  &errorIndex);
613 //   printf("# of adapters in this system : %i\n",
614 //          varBind[0].value.asnValue.number); varBindList.len = 2;
615
616    // Copy in the OID of ifType, the type of interface
617    SNMP_oidcpy(&varBind[0].name, &MIB_ifEntryType);
618
619    // Copy in the OID of ifPhysAddress, the address
620    SNMP_oidcpy(&varBind[1].name, &MIB_ifMACEntAddr);
621
622    do
623    {
624       // Submit the query.  Responses will be loaded into varBindList.
625       // We can expect this call to succeed a # of times corresponding
626       // to the # of adapters reported to be in the system
627       ret = m_Query(ASN_RFC1157_GETNEXTREQUEST, &varBindList, &errorStatus,
628                     &errorIndex); 
629       if (!ret)
630       {
631          ret = 1;
632       }
633       else
634       {
635          // Confirm that the proper type has been returned
636          ret = SNMP_oidncmp(&varBind[0].name, &MIB_ifEntryType,
637                             MIB_ifEntryType.idLength);
638       }
639       if (!ret)
640       {
641          j++;
642          dtmp = varBind[0].value.asnValue.number;
643          printf("Interface #%i type : %i\n", j, dtmp);
644
645          // Type 6 describes ethernet interfaces
646          if (dtmp == 6)
647          {
648             // Confirm that we have an address here
649             ret = SNMP_oidncmp(&varBind[1].name, &MIB_ifMACEntAddr,
650                                MIB_ifMACEntAddr.idLength);
651             if ( !ret && varBind[1].value.asnValue.address.stream != NULL )
652             {
653                if ( (varBind[1].value.asnValue.address.stream[0] == 0x44)
654                  && (varBind[1].value.asnValue.address.stream[1] == 0x45)
655                  && (varBind[1].value.asnValue.address.stream[2] == 0x53)
656                  && (varBind[1].value.asnValue.address.stream[3] == 0x54)
657                  && (varBind[1].value.asnValue.address.stream[4] == 0x00) )
658                {
659                    // Ignore all dial-up networking adapters
660                    printf("Interface #%i is a DUN adapter\n", j);
661                    continue;
662                }
663                if ( (varBind[1].value.asnValue.address.stream[0] == 0x00)
664                  && (varBind[1].value.asnValue.address.stream[1] == 0x00)
665                  && (varBind[1].value.asnValue.address.stream[2] == 0x00)
666                  && (varBind[1].value.asnValue.address.stream[3] == 0x00)
667                  && (varBind[1].value.asnValue.address.stream[4] == 0x00)
668                  && (varBind[1].value.asnValue.address.stream[5] == 0x00) )
669                {
670                   // Ignore NULL addresses returned by other network
671                   // interfaces
672                   printf("Interface #%i is a NULL address\n", j);
673                   continue;
674                }
675                memcpy( addr, varBind[1].value.asnValue.address.stream, 6);
676             }
677          }
678       }
679    } while (!ret);
680
681    // Free the bindings
682    SNMP_FreeVarBind(&varBind[0]);
683    SNMP_FreeVarBind(&varBind[1]);
684    return 0;
685 #endif //_WIN32
686
687 // implementation for Linux
688 #ifdef __linux__
689    struct ifreq ifr;
690    struct ifreq *IFR;
691    struct ifconf ifc;
692    char buf[1024];
693    int s, i;
694    int ok = 0;
695
696    s = socket(AF_INET, SOCK_DGRAM, 0);
697    if (s == -1)
698    {
699        return -1;
700    }
701
702    ifc.ifc_len = sizeof(buf);
703    ifc.ifc_buf = buf;
704    ioctl(s, SIOCGIFCONF, &ifc);
705  
706    IFR = ifc.ifc_req;
707    for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; IFR++)
708    {
709       strcpy(ifr.ifr_name, IFR->ifr_name);
710       if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0)
711       {
712          if (! (ifr.ifr_flags & IFF_LOOPBACK))
713          {
714             if (ioctl(s, SIOCGIFHWADDR, &ifr) == 0)
715             {
716                ok = 1;
717                break;
718             }
719          }
720       }
721    }
722
723    close(s);
724    if (ok)
725    {
726       bcopy( ifr.ifr_hwaddr.sa_data, addr, 6);
727    }
728    else
729    {
730       return -1;
731    }
732    return 0;
733 #endif
734
735 // implementation for FreeBSD
736 #ifdef __FreeBSD__
737    struct ifaddrs *ifap, *ifaphead;
738    int rtnerr;
739    const struct sockaddr_dl *sdl;
740    caddr_t ap;
741    int alen;
742  
743    rtnerr = getifaddrs(&ifaphead);
744    if (rtnerr)
745    {
746      //perror(NULL);
747      return -1;
748    }
749  
750    for (ifap = ifaphead; ifap; ifap = ifap->ifa_next)
751    {
752       if (ifap->ifa_addr->sa_family == AF_LINK)
753       {
754          sdl = (const struct sockaddr_dl *) ifap->ifa_addr;
755          ap = ((caddr_t)((sdl)->sdl_data + (sdl)->sdl_nlen));
756          alen = sdl->sdl_alen;
757          if (ap && alen > 0) 
758          {
759             //int i;
760  
761             //printf ("%s:", ifap->ifa_name);
762             //for (i = 0; i < alen; i++, ap++)
763               {
764               //printf("%c%02x", i > 0 ? ':' : ' ', 0xff&*ap);
765               }
766             bcopy( ap, addr, 6);
767             //putchar('\n');
768          }
769       }
770    }
771    //putchar('\n');
772  
773    freeifaddrs(ifaphead);
774    return 0;
775 #endif //FreeBSD
776
777 // implementation for HP-UX
778 #ifdef __HP_aCC
779    const char LAN_DEV0[] = "/dev/lan0";
780
781    int fd;
782    struct fis iocnt_block;
783    char net_buf[sizeof(LAN_DEV0)+1];
784
785    (void)sprintf(net_buf, "%s", LAN_DEV0);
786    char *p = net_buf + strlen(net_buf) - 1;
787
788    // 
789    // Get 802.3 address from card by opening the driver and interrogating it.
790    //
791    for (int i = 0; i < 10; i++, (*p)++)
792    {
793       if ((fd = open (net_buf, O_RDONLY)) != -1) 
794       {
795          iocnt_block.reqtype = LOCAL_ADDRESS;
796          ioctl (fd, NETSTAT, &iocnt_block);
797          close (fd);
798
799          if (iocnt_block.vtype == 6) break;
800       }
801    }
802
803    if (fd == -1 || iocnt_block.vtype != 6)
804    {
805       return -1;
806    }
807
808    bcopy( &iocnt_block.value.s[0], addr, 6);
809    return 0;
810 #endif // HP-UX
811
812 /* implementation for AIX */
813 #ifdef _AIX
814    int size = getkerninfo(KINFO_NDD, 0, 0, 0);
815    if (size <= 0)
816    {
817       return -1;
818    }
819    struct kinfo_ndd *nddp = (struct kinfo_ndd *)malloc(size);
820          
821    if (!nddp)
822    {
823       return -1;
824    }
825    if (getkerninfo(KINFO_NDD, nddp, &size, 0) < 0)
826    {
827       free(nddp);
828       return -1;
829    }
830    bcopy(nddp->ndd_addr, addr, 6);
831    free(nddp);
832
833    return 0;
834 #endif //_AIX
835
836 #ifdef __APPLE__
837    io_iterator_t intfIterator;
838    UInt8 MACAddress[ kIOEthernetAddressSize ];
839  
840    kern_return_t kernResult = FindEthernetInterfaces(&intfIterator);
841    
842    if (KERN_SUCCESS != kernResult)
843    {
844        printf("FindEthernetInterfaces returned 0x%08x\n", kernResult);
845    }
846    else
847    {
848       kernResult = GetMACAddress_MAC(intfIterator, MACAddress);
849
850       if (KERN_SUCCESS != kernResult)
851       {
852           printf("GetMACAddress returned 0x%08x\n", kernResult);
853       }
854    }
855
856    (void) IOObjectRelease(intfIterator); // Release the iterator.
857        
858    memcpy(addr, MACAddress, kIOEthernetAddressSize);
859    return kernResult;
860 #endif //APPLE
861
862 /* Not implemented platforms */
863   memset(addr,0,6);
864   return -1;
865 }
866
867 std::string Util::GetMACAddress()
868 {
869    // This is a rip from: http://cplus.kompf.de/macaddr.html for Linux, HPUX and AIX 
870    // and http://tangentsoft.net/wskfaq/examples/src/snmpmac.cpp for windows version
871    // and http://groups-beta.google.com/group/sol.lists.freebsd.hackers/msg/0d0f862e05fce6c0 for the FreeBSD version
872    // and http://developer.apple.com/samplecode/GetPrimaryMACAddress/GetPrimaryMACAddress.html for MacOSX version
873    u_char addr[6];
874    std::string macaddr;
875  
876    long stat = GetMacAddrSys(addr);
877    if (0 == stat)
878    {
879       //printf( "MAC address = ");
880       for (int i=0; i<6; ++i) 
881       {
882          //printf("%2.2x", addr[i]);
883          macaddr += Format("%2.2x", addr[i]);
884       }
885       // printf( "\n");
886       return macaddr;
887    }
888    else
889    {
890       //printf( "No MAC address !\n" );
891       return "";
892    }
893 }
894
895 /**
896  * \ingroup Util
897  * \brief   Return the IP adress of the machine writting the DICOM image
898  */
899 std::string Util::GetIPAddress()
900 {
901   // This is a rip from 
902   // http://www.codeguru.com/Cpp/I-N/internet/network/article.php/c3445/
903 #ifndef HOST_NAME_MAX
904   // SUSv2 guarantees that `Host names are limited to 255 bytes'.
905   // POSIX 1003.1-2001 guarantees that `Host names (not including the
906   // terminating NUL) are limited to HOST_NAME_MAX bytes'.
907 #  define HOST_NAME_MAX 255
908   // In this case we should maybe check the string was not truncated.
909   // But I don't known how to check that...
910 #if defined(_MSC_VER) || defined(__BORLANDC__)
911   // with WinSock DLL we need to initialise the WinSock before using gethostname
912   WORD wVersionRequested = MAKEWORD(1,0);
913   WSADATA WSAData;
914   int err = WSAStartup(wVersionRequested,&WSAData);
915   if (err != 0)
916   {
917       // Tell the user that we could not find a usable
918       // WinSock DLL.
919       WSACleanup();
920       return "127.0.0.1";
921   }
922 #endif
923   
924 #endif //HOST_NAME_MAX
925
926   std::string str;
927   char szHostName[HOST_NAME_MAX+1];
928   int r = gethostname(szHostName, HOST_NAME_MAX);
929
930   if( r == 0 )
931   {
932     // Get host adresses
933     struct hostent *pHost = gethostbyname(szHostName);
934
935     for( int i = 0; pHost!= NULL && pHost->h_addr_list[i]!= NULL; i++ )
936     {
937       for( int j = 0; j<pHost->h_length; j++ )
938       {
939         if( j > 0 ) str += ".";
940
941         str += Util::Format("%u", 
942             (unsigned int)((unsigned char*)pHost->h_addr_list[i])[j]);
943       }
944       // str now contains one local IP address 
945
946 #if defined(_MSC_VER) || defined(__BORLANDC__)
947   WSACleanup();
948 #endif
949   
950     }
951   }
952   // If an error occur r == -1
953   // Most of the time it will return 127.0.0.1...
954   return str;
955 }
956
957 /**
958  * \ingroup Util
959  * \brief Creates a new UID. As stipulate in the DICOM ref
960  *        each time a DICOM image is create it should have 
961  *        a unique identifier (URI)
962  */
963 std::string Util::CreateUniqueUID(const std::string &root)
964 {
965   // The code works as follow:
966   // echo "gdcm" | od -b
967   // 0000000 147 144 143 155 012
968   // Therefore we return
969   // radical + 147.144.143.155 + IP + time()
970   std::string radical = root;
971   if( !root.size() ) //anything better ?
972   {
973     radical = "0.0."; // Is this really usefull ?
974   }
975   // else
976   // A root was specified use it to forge our new UID:
977   radical += "147.144.143.155"; // gdcm
978   radical += ".";
979   radical += Util::GetIPAddress();
980   radical += ".";
981   radical += Util::GetCurrentDate();
982   radical += ".";
983   radical += Util::GetCurrentTime();
984
985   return radical;
986 }
987
988 template <class T>
989 std::ostream &binary_write(std::ostream &os, const T &val)
990 {
991     return os.write(reinterpret_cast<const char*>(&val), sizeof val);
992 }
993
994 std::ostream &binary_write(std::ostream &os, const uint16_t &val)
995 {
996 #ifdef GDCM_WORDS_BIGENDIAN
997     uint16_t swap;
998     swap = ((( val << 8 ) & 0x0ff00 ) | (( val >> 8 ) & 0x00ff ) );
999     return os.write(reinterpret_cast<const char*>(&swap), 2);
1000 #else
1001     return os.write(reinterpret_cast<const char*>(&val), 2);
1002 #endif //GDCM_WORDS_BIGENDIAN
1003 }
1004
1005 std::ostream &binary_write(std::ostream &os, const uint32_t &val)
1006 {
1007 #ifdef GDCM_WORDS_BIGENDIAN
1008     uint32_t swap;
1009     swap = ( ((val<<24) & 0xff000000) | ((val<<8)  & 0x00ff0000) | 
1010              ((val>>8)  & 0x0000ff00) | ((val>>24) & 0x000000ff) );
1011     return os.write(reinterpret_cast<const char*>(&swap), 4);
1012 #else
1013     return os.write(reinterpret_cast<const char*>(&val), 4);
1014 #endif //GDCM_WORDS_BIGENDIAN
1015 }
1016
1017 std::ostream &binary_write(std::ostream &os, const char *val)
1018 {
1019     return os.write(val, strlen(val));
1020 }
1021
1022 std::ostream &binary_write(std::ostream &os, std::string const &val)
1023 {
1024     return os.write(val.c_str(), val.size());
1025 }
1026
1027 } // end namespace gdcm
1028