]> Creatis software - gdcm.git/blob - src/gdcmUtil.cxx
ENH: Saving temp code until I have time for Win32 version. This will return the MAC...
[gdcm.git] / src / gdcmUtil.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmUtil.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/01/06 18:46:02 $
7   Version:   $Revision: 1.72 $
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
22 // For GetCurrentDate, GetCurrentTime
23 #include <time.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26
27 #include <stdarg.h>  //only included in implementation file
28 #include <stdio.h>   //only included in implementation file
29
30 #if defined(_MSC_VER)
31    #include <winsock.h>  // for gethostname & gethostbyname
32    #undef GetCurrentTime
33 #else
34 #ifndef __BORLANDC__
35    #include <unistd.h>  // for gethostname
36    #include <netdb.h>   // for gethostbyname
37 #endif
38 #endif
39
40 namespace gdcm 
41 {
42 /**
43  * \ingroup Globals
44  * \brief Provide a better 'c++' approach for sprintf
45  * For example c code is:
46  * sprintf(trash, "%04x|%04x", group , element);
47  *
48  * c++ is 
49  * std::ostringstream buf;
50  * buf << std::right << std::setw(4) << std::setfill('0') << std::hex
51  *     << group << "|" << std::right << std::setw(4) << std::setfill('0') 
52  *     << std::hex <<  element;
53  * buf.str();
54  */
55
56 std::string Util::Format(const char* format, ...)
57 {
58    char buffer[2048];
59    va_list args;
60    va_start(args, format);
61    vsprintf(buffer, format, args);  //might be a security flaw
62    va_end(args); // Each invocation of va_start should be matched 
63                  // by a corresponding invocation of va_end
64                  // args is then 'undefined'
65    return buffer;
66 }
67
68
69 /**
70  * \ingroup Globals
71  * \brief Because not available in C++ (?)
72  */
73 void Util::Tokenize (const std::string& str,
74                      std::vector<std::string>& tokens,
75                      const std::string& delimiters)
76 {
77    std::string::size_type lastPos = str.find_first_not_of(delimiters,0);
78    std::string::size_type pos     = str.find_first_of    (delimiters,lastPos);
79    while (std::string::npos != pos || std::string::npos != lastPos)
80    {
81       tokens.push_back(str.substr(lastPos, pos - lastPos));
82       lastPos = str.find_first_not_of(delimiters, pos);
83       pos     = str.find_first_of    (delimiters, lastPos);
84    }
85 }
86
87 /**
88  * \ingroup Globals
89  * \brief Because not available in C++ (?)
90  *        Counts the number of occurences of a substring within a string
91  */
92  
93 int Util::CountSubstring (const std::string& str,
94                           const std::string& subStr)
95 {
96    int count = 0;   // counts how many times it appears
97    std::string::size_type x = 0;       // The index position in the string
98
99    do
100    {
101       x = str.find(subStr,x);       // Find the substring
102       if (x != std::string::npos)   // If present
103       {
104          count++;                  // increase the count
105          x += subStr.length();     // Skip this word
106       }
107    }
108    while (x != std::string::npos);  // Carry on until not present
109
110    return count;
111 }
112
113 /**
114  * \ingroup Globals
115  * \brief  Weed out a string from the non-printable characters (in order
116  *         to avoid corrupting the terminal of invocation when printing)
117  * @param s string to remove non printable characters from
118  */
119 std::string Util::CreateCleanString(std::string const & s)
120 {
121    std::string str = s;
122
123    for(unsigned int i=0; i<str.size(); i++)
124    {
125       if(!isprint((unsigned char)str[i]))
126       {
127          str[i] = '.';
128       }
129    }
130
131    if(str.size() > 0)
132    {
133       if(!isprint((unsigned char)s[str.size()-1]))
134       {
135          if(s[str.size()-1] == 0)
136          {
137             str[str.size()-1] = ' ';
138          }
139       }
140    }
141
142    return str;
143 }
144
145 /**
146  * \ingroup Globals
147  * \brief   Add a SEPARATOR to the end of the name is necessary
148  * @param   pathname file/directory name to normalize 
149  */
150 std::string Util::NormalizePath(std::string const & pathname)
151 {
152    const char SEPARATOR_X      = '/';
153    const char SEPARATOR_WIN    = '\\';
154    const std::string SEPARATOR = "/";
155    std::string name = pathname;
156    int size = name.size();
157
158    if( name[size-1] != SEPARATOR_X && name[size-1] != SEPARATOR_WIN )
159    {
160       name += SEPARATOR;
161    }
162    return name;
163 }
164
165 /**
166  * \ingroup Globals
167  * \brief   Get the (directory) path from a full path file name
168  * @param   fullName file/directory name to extract Path from
169  */
170 std::string Util::GetPath(std::string const & fullName)
171 {
172    std::string res = fullName;
173    int pos1 = res.rfind("/");
174    int pos2 = res.rfind("\\");
175    if( pos1 > pos2)
176    {
177       res.resize(pos1);
178    }
179    else
180    {
181       res.resize(pos2);
182    }
183
184    return res;
185 }
186
187 /**
188  * \ingroup Util
189  * \brief   Get the (last) name of a full path file name
190  * @param   fullName file/directory name to extract end name from
191  */
192 std::string Util::GetName(std::string const & fullName)
193 {   
194   std::string filename = fullName;
195
196   std::string::size_type slash_pos = filename.rfind("/");
197   std::string::size_type backslash_pos = filename.rfind("\\");
198   slash_pos = slash_pos > backslash_pos ? slash_pos : backslash_pos;
199   if(slash_pos != std::string::npos)
200     {
201     return filename.substr(slash_pos + 1);
202     }
203   else
204     {
205     return filename;
206     }
207
208
209 /**
210  * \ingroup Util
211  * \brief   Get the current date of the system in a dicom string
212  */
213 std::string Util::GetCurrentDate()
214 {
215     char tmp[512];
216     time_t tloc;
217     time (&tloc);    
218     strftime(tmp,512,"%Y%m%d", localtime(&tloc) );
219     return tmp;
220 }
221
222 /**
223  * \ingroup Util
224  * \brief   Get the current time of the system in a dicom string
225  */
226 std::string Util::GetCurrentTime()
227 {
228     char tmp[512];
229     time_t tloc;
230     time (&tloc);
231     strftime(tmp,512,"%H%M%S", localtime(&tloc) );
232     return tmp;  
233 }
234
235 /**
236  * \brief Create a /DICOM/ string:
237  * It should a of even length (no odd length ever)
238  * It can contain as many (if you are reading this from your
239  * editor the following character is is backslash followed by zero
240  * that needed to be escaped with an extra backslash for doxygen) \\0
241  * as you want.
242  */
243 std::string Util::DicomString(const char* s, size_t l)
244 {
245    std::string r(s, s+l);
246    assert( !(r.size() % 2) ); // == basically 'l' is even
247    return r;
248 }
249
250 /**
251  * \ingroup Util
252  * \brief Create a /DICOM/ string:
253  * It should a of even lenght (no odd length ever)
254  * It can contain as many (if you are reading this from your
255  * editor the following character is is backslash followed by zero
256  * that needed to be escaped with an extra backslash for doxygen) \\0
257  * as you want.
258  * This function is similar to DicomString(const char*), 
259  * except it doesn't take a lenght. 
260  * It only pad with a null character if length is odd
261  */
262 std::string Util::DicomString(const char* s)
263 {
264    size_t l = strlen(s);
265    if( l%2 )
266    {
267       l++;
268    }
269    std::string r(s, s+l);
270    assert( !(r.size() % 2) );
271    return r;
272 }
273
274 /**
275  * \ingroup Util
276  * \brief Safely compare two Dicom String:
277  *        - Both string should be of even lenght
278  *        - We allow padding of even lenght string by either a null 
279  *          character of a space
280  */
281 bool Util::DicomStringEqual(const std::string& s1, const char *s2)
282 {
283   // s2 is the string from the DICOM reference: 'MONOCHROME1'
284   std::string s1_even = s1; //Never change input parameter
285   std::string s2_even = DicomString( s2 );
286   if( s1_even[s1_even.size()-1] == ' ')
287   {
288     s1_even[s1_even.size()-1] = '\0'; //replace space character by null
289   }
290   return s1_even == s2_even;
291 }
292
293
294
295 /**
296  * \ingroup Util
297  * \brief   tells us if the processor we are working with is BigEndian or not
298  */
299 bool Util::IsCurrentProcessorBigEndian()
300 {
301    uint16_t intVal = 1;
302    uint8_t bigEndianRepr[4] = { 0x00, 0x00, 0x00, 0x01 };
303    int res = memcmp(reinterpret_cast<const void*>(&intVal),
304                     reinterpret_cast<const void*>(bigEndianRepr), 4);
305    if (res == 0)
306       return true;
307    else
308       return false;
309 }
310
311
312 #include <fcntl.h>
313 #include <stdlib.h>
314 #include <string.h>
315 #include <strings.h> //for bzero
316 #include <unistd.h>
317
318 #ifdef __linux__
319 #include <sys/ioctl.h>
320 #include <sys/types.h>
321 #include <sys/socket.h>
322 #include <netinet/in.h>
323 #include <linux/if.h>
324 #endif
325
326 #ifdef __HP_aCC
327 #include <netio.h>
328 #endif
329
330 #ifdef _AIX
331 #include <sys/ndd_var.h>
332 #include <sys/kinfo.h>
333 #endif
334
335 long GetMacAddrSys ( u_char *addr)
336 {
337 /* implementation for Linux */
338 #ifdef __linux__
339     struct ifreq ifr;
340     struct ifreq *IFR;
341     struct ifconf ifc;
342     char buf[1024];
343     int s, i;
344     int ok = 0;
345
346     s = socket(AF_INET, SOCK_DGRAM, 0);
347     if (s==-1) {
348         return -1;
349     }
350
351     ifc.ifc_len = sizeof(buf);
352     ifc.ifc_buf = buf;
353     ioctl(s, SIOCGIFCONF, &ifc);
354  
355     IFR = ifc.ifc_req;
356     for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; IFR++) {
357
358         strcpy(ifr.ifr_name, IFR->ifr_name);
359         if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0) {
360             if (! (ifr.ifr_flags & IFF_LOOPBACK)) {
361                 if (ioctl(s, SIOCGIFHWADDR, &ifr) == 0) {
362                     ok = 1;
363                     break;
364                 }
365             }
366         }
367     }
368
369     close(s);
370     if (ok) {
371         bcopy( ifr.ifr_hwaddr.sa_data, addr, 6);
372     }
373     else {
374         return -1;
375     }
376     return 0;
377 #endif
378
379 /* implementation for HP-UX */
380 #ifdef __HP_aCC
381
382 #define LAN_DEV0 "/dev/lan0"
383
384     int fd;
385     struct fis iocnt_block;
386     int i;
387     char net_buf[sizeof(LAN_DEV0)+1];
388     char *p;
389
390     (void)sprintf(net_buf, "%s", LAN_DEV0);
391     p = net_buf + strlen(net_buf) - 1;
392
393     /* 
394      * Get 802.3 address from card by opening the driver and interrogating it.
395      */
396     for (i = 0; i < 10; i++, (*p)++) {
397         if ((fd = open (net_buf, O_RDONLY)) != -1) {
398       iocnt_block.reqtype = LOCAL_ADDRESS;
399       ioctl (fd, NETSTAT, &iocnt_block);
400       close (fd);
401
402             if (iocnt_block.vtype == 6)
403                 break;
404         }
405     }
406
407     if (fd == -1 || iocnt_block.vtype != 6) {
408         return -1;
409     }
410
411   bcopy( &iocnt_block.value.s[0], addr, 6);
412   return 0;
413
414 #endif /* HPUX */
415
416 /* implementation for AIX */
417 #ifdef _AIX
418
419     int size;
420     struct kinfo_ndd *nddp;
421
422     size = getkerninfo(KINFO_NDD, 0, 0, 0);
423     if (size <= 0) {
424         return -1;
425     }
426     nddp = (struct kinfo_ndd *)malloc(size);
427           
428     if (!nddp) {
429         return -1;
430     }
431     if (getkerninfo(KINFO_NDD, nddp, &size, 0) < 0) {
432         free(nddp);
433         return -1;
434     }
435     bcopy(nddp->ndd_addr, addr, 6);
436     free(nddp);
437     return 0;
438 #endif //_AIX
439
440 /* Not implemented platforms */
441   return -1;
442 }
443
444 //std::string Util::GetMACAddress()
445 //{
446 //   // This is a rip from: http://cplus.kompf.de/macaddr.html for Linux, HPUX and AIX 
447 //   // and http://tangentsoft.net/wskfaq/examples/src/snmpmac.cpp for windows version
448 //   long stat;
449 //   int i;
450 //   u_char addr[6];
451 // 
452 //   stat = mac_addr_sys( addr);
453 //   if (0 == stat)
454 //   {
455 //      printf( "MAC address = ");
456 //      for (i=0; i<6; ++i) {
457 //           printf("%2.2x", addr[i]);
458 //         }
459 //         printf( "\n");
460 //     }
461 //     else {
462 //         fprintf( stderr, "can't get MAC address\n");
463 //         exit( 1);
464 //     }
465 //}
466
467 /**
468  * \ingroup Util
469  * \brief   Return the IP adress of the machine writting the DICOM image
470  */
471 std::string Util::GetIPAddress()
472 {
473   // This is a rip from http://www.codeguru.com/Cpp/I-N/internet/network/article.php/c3445/
474 #ifndef HOST_NAME_MAX
475   // SUSv2 guarantees that `Host names are limited to 255 bytes'.
476   // POSIX 1003.1-2001 guarantees that `Host names (not including the
477   // terminating NUL) are limited to HOST_NAME_MAX bytes'.
478 #  define HOST_NAME_MAX 255
479   // In this case we should maybe check the string was not truncated.
480   // But I don't known how to check that...
481 #if defined(_MSC_VER) || defined(__BORLANDC__)
482   // with WinSock DLL we need to initialise the WinSock before using gethostname
483   WORD wVersionRequested = MAKEWORD(1,0);
484   WSADATA WSAData;
485   int err = WSAStartup(wVersionRequested,&WSAData);
486   if (err != 0) {
487       /* Tell the user that we could not find a usable */
488       /* WinSock DLL.                                  */
489       WSACleanup();
490       return "127.0.0.1";
491   }
492 #endif
493   
494 #endif //HOST_NAME_MAX
495
496   std::string str;
497   char szHostName[HOST_NAME_MAX+1];
498   int r = gethostname(szHostName, HOST_NAME_MAX);
499
500   if( r == 0 )
501   {
502     // Get host adresses
503     struct hostent * pHost = gethostbyname(szHostName);
504
505     for( int i = 0; pHost!= NULL && pHost->h_addr_list[i]!= NULL; i++ )
506     {
507       for( int j = 0; j<pHost->h_length; j++ )
508       {
509         if( j > 0 ) str += ".";
510
511         str += Util::Format("%u", 
512             (unsigned int)((unsigned char*)pHost->h_addr_list[i])[j]);
513       }
514       // str now contains one local IP address 
515
516 #if defined(_MSC_VER) || defined(__BORLANDC__)
517   WSACleanup();
518 #endif
519   
520     }
521   }
522   // If an error occur r == -1
523   // Most of the time it will return 127.0.0.1...
524   return str;
525 }
526
527 /**
528  * \ingroup Util
529  * \brief Creates a new UID. As stipulate in the DICOM ref
530  *        each time a DICOM image is create it should have 
531  *        a unique identifier (URI)
532  */
533 std::string Util::CreateUniqueUID(const std::string& root)
534 {
535   // The code works as follow:
536   // echo "gdcm" | od -b
537   // 0000000 147 144 143 155 012
538   // Therefore we return
539   // radical + 147.144.143.155 + IP + time()
540   std::string radical = root;
541   if( !root.size() ) //anything better ?
542   {
543     radical = "0.0."; // Is this really usefull ?
544   }
545   // else
546   // A root was specified use it to forge our new UID:
547   radical += "147.144.143.155"; // gdcm
548   radical += ".";
549   radical += Util::GetIPAddress();
550   radical += ".";
551   radical += Util::GetCurrentDate();
552   radical += ".";
553   radical += Util::GetCurrentTime();
554
555   return radical;
556 }
557
558 template <class T>
559 std::ostream& binary_write(std::ostream& os, const T& val)
560 {
561     return os.write(reinterpret_cast<const char*>(&val), sizeof val);
562 }
563
564 std::ostream& binary_write(std::ostream& os, const uint16_t& val)
565 {
566 #ifdef GDCM_WORDS_BIGENDIAN
567     uint16_t swap;
568     swap = ((( val << 8 ) & 0x0ff00 ) | (( val >> 8 ) & 0x00ff ) );
569     return os.write(reinterpret_cast<const char*>(&swap), 2);
570 #else
571     return os.write(reinterpret_cast<const char*>(&val), 2);
572 #endif //GDCM_WORDS_BIGENDIAN
573 }
574
575 std::ostream& binary_write(std::ostream& os, const uint32_t& val)
576 {
577 #ifdef GDCM_WORDS_BIGENDIAN
578     uint32_t swap;
579     swap = ( ((val<<24) & 0xff000000) | ((val<<8)  & 0x00ff0000) | 
580              ((val>>8)  & 0x0000ff00) | ((val>>24) & 0x000000ff) );
581     return os.write(reinterpret_cast<const char*>(&swap), 4);
582 #else
583     return os.write(reinterpret_cast<const char*>(&val), 4);
584 #endif //GDCM_WORDS_BIGENDIAN
585 }
586
587 std::ostream& binary_write(std::ostream& os, const char* val)
588 {
589     return os.write(val, strlen(val));
590 }
591
592 std::ostream& binary_write(std::ostream& os, std::string const & val)
593 {
594     return os.write(val.c_str(), val.size());
595 }
596
597 } // end namespace gdcm
598