Jansson Consulting

A trivial character search and replace method in C++

2011-11-21T09:27:00.000+01:00

A very long time ago I was searching for ways to replace individual characters in a string and some of the methods was summarized in a small test program. I found that test program in an old folder on my computer which I almost forgot. So, I share that little code with the world. It follows.

#include <algorithm>
#include <string>
#include <iostream>

using namespace std;

bool is_punct( const char& c )
{
 return ispunct( c );
}

bool is_l( const char& c )
{
 return 'l'==c;
}

struct mycomp
{
 bool operator()(const char& o)
 {
  return ispunct( o );
 }
};

int main()
{
 // Remove all characters that "ispunct" using a function.
 string s = "hello, world!";
 s.erase( remove_if( s.begin(), s.end(), &is_punct ), s.end() );
 cout << s << '\n';

 // Remove all characters that "ispunct" using a functor.
 s = "hello, world!";
 s.erase( remove_if( s.begin(), s.end(), mycomp() ), s.end() );
 cout << s << '\n';

 // Replace all 'l' with 'L' using a function.
 s = "hello, world!";
 replace_if( s.begin(), s.end(), &is_l, 'L' );
 cout << s << '\n';
}

Creating a histogram in SQL using event data

2011-11-16T15:02:00.002+01:00

Sometimes you may have gathered some data on event-by-event basis. For instance, the data may look like this when pulses from a radioactive decay have been processed by a peak sensing analog to digital converter (ADC):

A simple table in a relational database may be created to store this data:

CREATE TABLE samples( channel INTEGER NOT NULL );

BEGIN TRANSACTION;
INSERT INTO samples VALUES(2);
INSERT INTO samples VALUES(2);
INSERT INTO samples VALUES(2);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(8);
INSERT INTO samples VALUES(100);
INSERT INTO samples VALUES(100);
INSERT INTO samples VALUES(250);
INSERT INTO samples VALUES(250);
COMMIT;

I found the following SQL statement somewhere on the net (if you find it, please let me know where so that I can pay the appropriate tribute to its source). It is a demonstration of how to create a 1024 channel histogram with the above data. I hope you find it useful.

SELECT bin, COUNT(1) AS cnt
FROM (SELECT CAST((channel-mn) / (1.0*range/1024) AS INTEGER) + 1 AS bin
      FROM (SELECT MIN(channel) AS mn, MAX(channel)-MIN(channel)+1 AS range
            FROM samples) AS R
         CROSS JOIN
           (SELECT * FROM samples) AS S) AS RS
GROUP BY bin;

Using SQLite as database engine, I get the following output after executing the above SQL statements.

Swedens first Radioactive Boyscout? Or, how to boil water with smoke detectors.

2011-08-02T11:54:00.002+02:00

On August 1, 2011, in Swedish on-line news paper Helsingborgs Dagblad, a story was told about a 31 year old man who tried to build his own nuclear reactor using Americium-241 from smoke detectors and other chemicals. The story reminds us of the story from the 1990's about the "Radioactive Boyscout", David Hahn. There is another story from the same source with an interview with Professor Janne Wallenius, Royal Institute of Technology in Sweden, who tries to explain the impossibility of the mans endeavour.

I would like to present to you a small exercise in physics and show the impossibility from another perspective. A nuclear reactors fundamental purpose is to heat water. Most of the time that heated water is used to generate momentum in a turbine which generate electricity so that you can read this blog post. Sometimes that heated water is used as a direct source of heat. But, how many smoke detectors would we need to boil a bucket of water?

Energy needed to boil water

Let us start with a bucket of 1 dm³ of water (i.e. one liter) at 25° Centigrade at normal atmospheric pressure. In order to make it boil we need to raise its temperature with 75 degrees to 100°.

Using measurements performed by others, we know that the specific heat capacity of water at 25° is about 4.2 Joule per Gram per Kelvin. That is, it takes 4.2 Joules of energy to heat one gram of water one degree.

To heat one liter (i.e. 1000 grams) of water 75 degrees from room temperature would take about

4.2 (J/g/K) * 75 (K) * 1000 (g) ≈ 315 kJ

So, using smoke detectors, we need to somehow transfer 315 kJ of energy into our bucket of water.

Energy from smoke detectors

An ordinary smoke detector contain about 1 µCi or 37 kBq of ²⁴¹Am. This unit means that we get about 37000 decays of ²⁴¹Am per second. From one decay of ²⁴¹Am we get about 5.5 MeV of energy. This is the same as about

5.5 (MeV) * 1.602⋅10⁻¹³ (J/MeV) ≈ 8.8⋅10⁻¹³ Joule

So an ordinary smoke detector generates about

8.8⋅10⁻¹³ (J) * 37⋅10³ (1/s) ≈ 325⋅10⁻¹⁰ Watt

Conclusion: Boiling water with smoke detectors

Lets say we have patience. We can wait one year for our bucket of water to boil. One year is about 315360000 seconds. So, we have this many seconds to generate 315 kJ. To do this we need

315 (kJ) / 315360000 (s) ≈ 0.001 Watt

Each smoke detector gives 325⋅10⁻¹⁰ Watt so we need the following number of smoke detectors:

0.001 (W) / 325⋅10⁻¹⁰ (Watt/detector) ≈ 30⋅10³

I.e. we would need some 30000 smoke detectors to boil our bucket of water if we can wait one year for it to boil. We could not drive a turbine with this.

Say we were in a situation were we need to boil water quickly. For instance if we were lost in the forest and need to get a hot cup of tea made from the sprouts of spruce. Then we only have about one hour and we would need 24*365 times the number of smoke detectors, or about 250 millions.

Clearly, it is impossible to boil water with smoke detectors. You can't find 250 million smoke detectors laying around in the woods.

Convert a boost::posix_time::ptime to a std::time_t value

2011-07-31T11:09:00.001+02:00

Often you need a std::time_t value or a UNIX timestamp which is the number of seconds elapsed since January 1^st 1970 but what you start with is a boost::posix_time::ptime (from the Boost C++ library). Here is how you can convert it:

#include "ctime"
#include "boost/date_time/posix_time/posix_time_types.hpp"
std::time_t convert(const boost::posix_time::ptime& t)
{
   static const boost::posix_time::ptime epoch(
         boost::gregorian::date(1970,1,1) );
   const boost::posix_time::time_duration::sec_type x(
         (t - epoch).total_seconds() );
   return x;
}

Here is a small test program that illustrates it's use by converting the current UTC time:

#include "ctime"
#include "boost/date_time/posix_time/posix_time_types.hpp"
std::time_t convert(const boost::posix_time::ptime& t)
{
   static const boost::posix_time::ptime epoch(
         boost::gregorian::date(1970,1,1) );
   const boost::posix_time::time_duration::sec_type x(
         (t - epoch).total_seconds() );
   return x;
}
#include "iostream"
int main()
{
   const boost::posix_time::ptime t(
         boost::posix_time::second_clock::universal_time() );
   std::cout << convert(t) << std::endl;
   return 0;
}

SSH communication using libssh2 and boost::asio

2011-06-06T10:41:00.003+02:00

I once needed to create a small class to execute a SSH command on a remote server. The environment was Windows XP and Windows Vista and MinGW was the compiler system. So, what I did can be found below. It uses Boost::Asio and the libssh2 library. Below the class code is a small program that make use of the class to execute the command uptime on a remote (*NIX) server.

My intention has been to write the code so that no or very few comments are needed. Let me know if you need more information.

To make this work you would need to compile the boost and libssh2 libraries and link them to your application. For libssh2, you will also need the OpenSSL library (and the zlib library which is optional for OpenSSL). If you need help with this, my consulting company can be of service.

#include <boost/asio/io_service.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/utility.hpp>
#include <libssh2.h>
#include <ostream>
#include <stdexcept>
using namespace boost::asio;
/// @brief Class to use for communications via the
/// SSH protocol.
/// Dedicated to the public domain.
/// @author Peter Jansson
/// @date 2011-06-06
class SshComm : public boost::noncopyable
{
   typedef std::runtime_error re;
   public:
   /// @brief Create a SSH communications capable object.
   /// @details The SSH session will be initialized to
   /// communicate to the host:port specified in the
   /// arguments to this constructor, using the login
   /// credentials supplied.
   SshComm(
         const char* IP,
         const int & PortNumber,
         const char* user,
         const char* pw)
      :io(),sck(io, ip::tcp::v4()),ss(libssh2_session_init())
   {
      sck.connect(
            ip::tcp::endpoint(
               ip::address::from_string(IP),
               PortNumber) );

      if( 0 > libssh2_session_startup(ss,sck.native()) )
      {
         throw re("Could not startup the SSH communication"
                  " session.");
      }
      if( libssh2_userauth_password(ss,user,pw) )
      {
         throw re("Access denied");
      }
   };
   /// @brief Deallocate memory needed for this object.
   virtual ~SshComm()
   {
      libssh2_session_disconnect(ss,"Goodbye.");
      libssh2_session_free(ss);
   };
   /// @brief Execute a command on the SSH server and expect
   /// a response.
   /// @param cmd[in] The command to execute.
   /// @param response_stream[in,out] The stream to write the
   /// expected response to.
   void ExecuteCmdResponse(
         const char* cmd,
         std::ostream & response_stream) const
   {
      LIBSSH2_CHANNEL* ch = libssh2_channel_open_session(ss);
      if( NULL == ch )
      {
         throw re("Could not open SSH communication channel.");
      }
      libssh2_channel_set_blocking(ch,1);
      if( -1 == libssh2_channel_exec(ch,cmd))
      {
         throw re("Failed to execute command.");
      }
      char buf[1024];
      int num_of_read_bytes;
      do
      {
         num_of_read_bytes = libssh2_channel_read(ch,buf,1024);
         response_stream.write(buf,num_of_read_bytes);
      } while(1==libssh2_poll_channel_read(ch,0)
            || 1024==num_of_read_bytes );
      libssh2_channel_close(ch);
      libssh2_channel_free(ch);
   };
   private:
   /// @brief The io_service needed for boost::asio.
   io_service io;
   /// @brief The underlying socket used for ssh communication.
   ip::tcp::socket sck;
   /// @brief The SSH session structure to use in all
   /// communcations using this instance.
   LIBSSH2_SESSION* ss;
};

#include <iostream>
#include <cstdlib>
#include <sstream>
int main(int ac,char** av)
{
   try
   {
      if( 5 != ac )
      {
         std::ostringstream o;
         o << "Usage: " << av[0] << " IP username password port";
         throw std::invalid_argument(o.str());
      }
      const SshComm ssh(av[1],std::atoi(av[4]),av[2],av[3]);
      ssh.ExecuteCmdResponse("uptime",std::cout);
      return EXIT_SUCCESS;
   }
   catch( const std::exception& e )
   {
      std::cerr << e.what() << '\n';
      return EXIT_FAILURE;
   }
}

Search for a string and print N following lines.

2011-04-19T14:53:00.001+02:00

A litte C++ code snippet to filter some text from standard input to standard output while keeping only N-1 lines following a search string.

#include <sstream>
#include <iostream>
#include <string>
/*
 * If standard input contains a line with the string argv[1],
 * then print up to argv[2] lines, including the one found,
 * on standard output.
 * Dedicated to the public domain.
 * @author Peter Jansson
 * @date 2011-04-19
 */
int main(int argc,char** argv)
{
   using namespace std;
   const string argv1( argv[1] );
   istringstream iss( argv[2] );
   int N(0);
   iss >> N;
   for(string line; getline( cin, line );)
   {
      if( line.find( argv1 ) != string::npos )
      {
         for( ; N > 0 && cin; N-- )
         {
            cout << line << '\n';
            getline( cin, line );
         }
         break;
      }
   }
   return 0;
}

Cs-137 in ground level air in Stockholm (Sweden), before and after Fukushima.

2011-04-03T11:05:00.016+02:00

It is quite a long distance between Fukushima, Japan, and Stockholm (the capital of Sweden). Never the less, using large capacity air pumps to pump air through paper filters followed by gamma radiation measurements on the filters using high-purity Germanium detectors, very small concentrations of particulate bound radionuclides can be measured.

Such measurements are routinely performed by the Swedish Defence Research Agency (FOI). After the Fukushima accident on March 11, 2011, some Cs-137 was evidently released and have been transported around the globe to reach Stockholm. A plot of wind trajectories calculated by the HYSPLIT program at ARL can be found below.

The plot below show how the Cs-137 concentration in ground level air have increased the last few days. It is based on data and references to be found in a Google Docs spreadsheet (data published by FOI and found on the home page of the Swedish Radiation Safety Authority).

(Click on the 1m zoom to get a picture on the increase during the last few days.)

Here is a table showing the data used:

Illustration of the BWR's at Fukushima

2011-03-17T20:36:00.001+01:00

The Nuclear Energy Institute in Washington have published a nice illustration of the BWR design at Fukushima Daiichi:

Risks associated with nuclear power

2011-03-12T18:17:00.003+01:00

In the aftermath of the events at the Fukushima Daiichi nuclear power plant following 11 March 2011, there will probably be a renewed debate on the use of nuclear power compared to other energy sources.

I would like to recommend everybody interested to read the NEA report number 6861 entitled "Comparing Nuclear Accident Risks with Those from Other Energy Sources" (ISBN 978-92-64-99122-4):

Grouping and thousands separator in C++

2011-02-28T12:41:00.005+01:00

Learn by doing...

#include <locale>

template <class T>
struct formatter : std::numpunct<T>
{
   protected:
      T do_thousands_sep() const
      {
         return T('-');
      }
      std::basic_string<T> do_grouping() const
      {
         return std::basic_string<T>("\3\2\3");
      }
};

#include <iostream>

int main()
{
   std::locale fmt(std::locale::classic(), new formatter<char>);
   std::cout.imbue(fmt);

   std::cout << 12345678 << std::endl;
   return 0;
}

Output:
123-45-678

Radioactivity in the atmosphere.

2011-01-02T10:54:00.000+01:00

Plots of activity concentrations of ⁷Be and ¹³⁷Cs in the ground level air around Grindsjön (In Sweden at 59°5′6,56″ N 17°52′11,20″ E) follows.

Reference:
C. Söderström, R. Arntsing, P. Jansson, K. Lindh and K. Wilhelmsen. "History of the sampling station at Grindsjön with Quarterly report on measurements of radionuclides in ground level air in Sweden. Fourth quarter 2003." Scientific report no FOI-R--1262--SE from the Swedish Defence Research Agency (FOI). ISSN 1650-1942. June 2004.

Random Points in a Triangle

2010-12-25T15:51:00.010+01:00

Have you ever needed to generate random points in a triangle?

Quite often, such points are needed in compuler simulations and games. I found an article on the subject somwhere and wrote some simple JavaScript code to test it.

Here is the actual algorithm: Given a triangle with vertices A, B and C. Generate two random numbers a and b uniformly between 0 and 1. If the sum a+b is > 1, then set a=1-a and b=1-b. Let c=1-a-b. A random point P distributed uniformly within the triangle is then given by P=aA+bB+cC.

The a, b and c numbers are called the barycentric coordinates of the triangle.

If you have JavaScript enabled in your browser, then you should see a plot below that demonstrates generation of 100 random points within random generated triangles. You can get the source code if you look at the source to this page.

Reading a memory mapped file as a normal C++ std::istream.

2010-11-21T11:59:00.011+01:00

I was working on an entry to a programming challenge that was all about reading numbers from an file as fast as possible. In that work, I did some experimentation with specializing a std::streambuf object to be able to read from a memory map of that file as if it was a normal C++ input stream (std::istream).

It turned out that it was not the fastest way to use the memory map since the istream machinery generated by my C++ compiler was not that very efficient compared to parsing the memory more directly. Nevertheless, I thought it was a neat solution so I would like to share the code with the world in case someone else needs it.

Here it is:

/// Streambuf specialization to read (only) from
/// a file using a memory map of the file.
/// This is Microsoft Windows specific but could
/// relatively easy be ported to a Linux variant.
/// Also, the whole file is mapped to memory. There
/// is room for optimization with reading only one
/// page at the time...
///
/// Usage example to read all lines from a file:
///
///     membuf mb("a_file.txt");
///     std::istream i(&mb);
///     for( std::string line; std::getline(i,line); )
///     {
///        // do something with the line.
///     }
///
/// Author: Peter Jansson (http://www.p-jansson.com)
/// Date: 2010-11-21
/// Dedicated to the public domain.
///
#include "streambuf"
#include "windows.h"
class membuf: public std::streambuf
{
   public:
      membuf(const char* filename)
         :std::streambuf()
      {
         hFile = CreateFileA(
               filename,
               GENERIC_READ,
               0,
               NULL,
               OPEN_EXISTING,
               FILE_ATTRIBUTE_READONLY,
               NULL);
         hFileMappingObject = CreateFileMapping(
               hFile,
               NULL,
               PAGE_READONLY,
               0,
               0,
               NULL);
         beg = MapViewOfFile(hFileMappingObject,
               FILE_MAP_READ,
               0,
               0,
               0);
         char* e = (char*)beg;
         e += GetFileSize( hFile, NULL );
         setg((char*)beg,(char*)beg,e);
         setp(&outBuf,&outBuf);
      }
      /// Close the memory mapping and the opened
      /// file.
      ~membuf()
      {
         UnmapViewOfFile(beg);
         CloseHandle( hFileMappingObject );
         CloseHandle( hFile );
      }
   private:
      /// We can't copy this.
      membuf(const membuf&);
      membuf& operator=(const membuf&);
      /// Outbuf buffer that is not used since we
      /// don't write to the memory map.
      char outBuf;
      HANDLE hFile,hFileMappingObject;
      /// Pointer to the beginning of the mapped
      /// memory area.
      LPVOID beg;
};

Traceroute in C++ using boost::asio

2010-08-11T20:31:00.010+02:00

The other week, I was experimenting with raw sockets and learning the structure of IP packets (version 4). It is always good to learn by doing and to learn better in this case, I built a simple traceroute program. Of course, this version of traceroute is very simple compared to the more advanced version distributed with various *NIX systems but it demonstrates nicely how to work with raw sockets using boost::asio.

Traceroute works by sending IP packets with the time-to-live-field initially set to zero and then increasing it by one for each hop along the way to a target host. Routers along the route will reply with a ICMP packet with the time exceeded message code since the TTL field is too low. This is the reason why we can learn the address of routers along the route.

The program that can be found below read the raw data received on the wire and parses out the source IP address from the IP packet. Looking at the IP header structure, this information is located at bit offset 96 in the header:

0               8               16                             31
 +-------+-------+---------------+------------------------------+      ---
 |       |       |               |                              |       ^
 |version|header |    type of    |    total length in bytes     |       |
 |  (4)  |length |    service    |                              |       |
 +-------+-------+---------------+-+-+-+------------------------+       |
 |                               | | | |                        |       |
 |        identification         |0|D|M|    fragment offset     |       |
 |                               | |F|F|                        |       |
 +---------------+---------------+-+-+-+------------------------+       |
 |               |               |                              |       |
 | time to live  |   protocol    |       header checksum        |   20 bytes
 |               |               |                              |       |
 +---------------+---------------+------------------------------+       |
 |                                                              |       |
 |                      source IPv4 address                     |       |
 |                                                              |       |
 +--------------------------------------------------------------+       |
 |                                                              |       |
 |                   destination IPv4 address                   |       |
 |                                                              |       v
 +--------------------------------------------------------------+      ---

I should mention that, even though boost::asio should be highly platform independent, I could not get this program to do its job properly on Windows (Vista). It turns out that setting the TTL fails on that system using boost version 1.43. On a Linux Ubuntu box with boost version 1.42 it works as expected. (You can read more about the evolution of this problem on the ticket created for it.)

The code follows. Please read it and you will understand what has been done.

#include <iostream>
#include <sstream>
#include <stdexcept>
#include <vector>
#include <boost/asio.hpp>
#include "icmp_header.hpp"

using boost::asio::ip::icmp;

class traceroute: public boost::noncopyable
{
   public:
      traceroute(const char* host):
         io(),
         resolver(io),
         socket(io, icmp::v4()),
         sequence_number(0)
      {
        icmp::resolver::query query(icmp::v4(), host, "");
        destination = *resolver.resolve(query);
      }
      ~traceroute() { socket.close(); }
      void trace()
      {
         for( int ttl(1); ttl < 31 ; ttl++)
         {
            const boost::asio::ip::unicast::hops option( ttl );
            socket.set_option(option);

            boost::asio::ip::unicast::hops op;
            socket.get_option(op);
            if( ttl !=  op.value() )
            {
               std::ostringstream o;
               o << "TTL not set properly. Should be "
                 << ttl << " but was set to "
                 << op.value() << '.';
               throw std::runtime_error(o.str());
            }

            // Create an ICMP header for an echo request.
            icmp_header echo_request;
            echo_request.type(icmp_header::echo_request);
            echo_request.code(0);
            echo_request.identifier(get_identifier());
            echo_request.sequence_number(++sequence_number);
            const std::string body("");
            compute_checksum(echo_request, body.begin(), body.end());

            // Encode the request packet.
            boost::asio::streambuf request_buffer;
            std::ostream os(&request_buffer);
            os << echo_request << body;

            // Send the request.
            socket.send_to(request_buffer.data(), destination);

            // Recieve some data and parse it.
            std::vector<boost::uint8_t> data(64,0);
            const std::size_t nr(
               socket.receive(
                  boost::asio::buffer(data) ) );
            if( nr < 16 )
            {
               throw std::runtime_error("To few bytes returned.");
            }
            std::ostringstream remote_ip;
            remote_ip  
               << (int)data[12] << '.'
               << (int)data[13] << '.'
               << (int)data[14] << '.'
               << (int)data[15];
            std::cout << remote_ip.str() << '\n';
            if( boost::asio::ip::address_v4::from_string( remote_ip.str() )
                  == destination.address() )
            {
               break;
            }
         }
      }
   private:
      static const int port = 33434;
      boost::asio::io_service io;
      boost::asio::ip::icmp::resolver resolver;
      boost::asio::ip::icmp::socket socket ;
      unsigned short sequence_number;
      boost::asio::ip::icmp::endpoint destination;
      static unsigned short get_identifier()
      {
#if defined(BOOST_WINDOWS)
         return static_cast<unsigned short>(::GetCurrentProcessId());
#else
         return static_cast<unsigned short>(::getpid());
#endif
      }
};

int main( int argc, char** argv)
{
   try
   {
      if( argc != 2 )
      {
         throw std::invalid_argument("Usage: traceroute host");
      }
      traceroute T( argv[1] );
      T.trace();
   }
   catch( const std::exception& e )
   {
      std::cerr << e.what() << '\n';
   }
}

The class icmp_header that is included was simply copied from the boost website:

//
// icmp_header.hpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef ICMP_HEADER_HPP
#define ICMP_HEADER_HPP

#include <istream>
#include <ostream>
#include <algorithm>

// ICMP header for both IPv4 and IPv6.
//
// The wire format of an ICMP header is:
// 
// 0               8               16                             31
// +---------------+---------------+------------------------------+      ---
// |               |               |                              |       ^
// |     type      |     code      |          checksum            |       |
// |               |               |                              |       |
// +---------------+---------------+------------------------------+    8 bytes
// |                               |                              |       |
// |          identifier           |       sequence number        |       |
// |                               |                              |       v
// +-------------------------------+------------------------------+      ---

class icmp_header
{
public:
  enum { echo_reply = 0, destination_unreachable = 3, source_quench = 4,
    redirect = 5, echo_request = 8, time_exceeded = 11, parameter_problem = 12,
    timestamp_request = 13, timestamp_reply = 14, info_request = 15,
    info_reply = 16, address_request = 17, address_reply = 18 };

  icmp_header() { std::fill(rep_, rep_ + sizeof(rep_), 0); }

  unsigned char type() const { return rep_[0]; }
  unsigned char code() const { return rep_[1]; }
  unsigned short checksum() const { return decode(2, 3); }
  unsigned short identifier() const { return decode(4, 5); }
  unsigned short sequence_number() const { return decode(6, 7); }

  void type(unsigned char n) { rep_[0] = n; }
  void code(unsigned char n) { rep_[1] = n; }
  void checksum(unsigned short n) { encode(2, 3, n); }
  void identifier(unsigned short n) { encode(4, 5, n); }
  void sequence_number(unsigned short n) { encode(6, 7, n); }

  friend std::istream& operator>>(std::istream& is, icmp_header& header)
    { return is.read(reinterpret_cast<char*>(header.rep_), 8); }

  friend std::ostream& operator<<(std::ostream& os, const icmp_header& header)
    { return os.write(reinterpret_cast<const char*>(header.rep_), 8); }

private:
  unsigned short decode(int a, int b) const
    { return (rep_[a] << 8) + rep_[b]; }

  void encode(int a, int b, unsigned short n)
  {
    rep_[a] = static_cast<unsigned char>(n >> 8);
    rep_[b] = static_cast<unsigned char>(n & 0xFF);
  }

  unsigned char rep_[8];
};

template <typename Iterator>
void compute_checksum(icmp_header& header,
    Iterator body_begin, Iterator body_end)
{
  unsigned int sum = (header.type() << 8) + header.code()
    + header.identifier() + header.sequence_number();

  Iterator body_iter = body_begin;
  while (body_iter != body_end)
  {
    sum += (static_cast<unsigned char>(*body_iter++) << 8);
    if (body_iter != body_end)
      sum += static_cast<unsigned char>(*body_iter++);
  }

  sum = (sum >> 16) + (sum & 0xFFFF);
  sum += (sum >> 16);
  header.checksum(static_cast<unsigned short>(~sum));
}

#endif // ICMP_HEADER_HPP

Peak search in a gamma-ray energy spectrum

2010-07-29T18:12:00.007+02:00

In this post, a method for finding peaks in energy spectra obtained in high resolution gamma-ray spectroscopy is presented. The method is straightforward and involves no iterative procedures and is widely used in many software packages. The basic idea is to study the derivatives of the spectrum to find out where the peaks are located.

The method is presented by an example. We use one HPGe spectrum from the 2002 IAEA inter-comparison spectra. This spectrum, identified by the name "mix2eq", was acquired during one hour with the detector aimed at at mixture of nuclides.

Channel

The peak positions are located at places where the 1^st derivative of the spectrum is zero and the 2^nd derivative is negative. The 1^st and 2^nd derivative is approximated by finite differences as follows. In our spectrum, we have h = 1 since we are dealing with channels.

If you were to plot the 1^st or the 2^nd derivative and zoom in, you would notice a lot of noise where the data fluctuates around zero. To avoid detecting false peaks, we will only use 1^st derivative data that are within a band around zero and only use 2^nd derivative data that are below a certain negative threshold. For this example, you can experiment with the limits using the sliders below:

1^st derivative limit:

2^nd derivative limit:

Plotting the 2^nd derivative data only for those channels that fulfill these limits provides a visual tool to see where the peaks are located. This plot is updated when the sliders above are moved.

Channel

The dynamic updating of the plot demonstrated above may not be necessary for your application. As it is implemented here, it may cause a bad flickering effect especially on slower computers.

This post contained one example of how peaks may be located in a high resolution gamma-ray energy spectrum. The interested reader may find the following list of references useful for further study:

A. Likar and T. Vidmar; "A peak-search method based on spectrum convolution"; J. Phys. D: Appl. Phys. 36 (2003) 1903–1909.
K. Debertin and R. Helmer; "Gamma- and X-Ray Spectrometry with Semiconductor Detectors"; North-Holland, 1988. ISBN-10: 0444871071, ISBN-13: 978-0444871077

Safeguards Glossary

2010-07-27T23:22:00.004+02:00

Ever wondered what all those (nuclear) Safeguards words mean and really have no one to ask?

Don't worry, be happy, the International Atomic Energy Agency (IAEA) has put together a report in 2001 with a Safeguards Glossary that you can read here.

Running out of IP v4 numbers.

2010-07-24T17:19:00.003+02:00

As you may know, the number of available IP version 4 numbers are rapidly approaching zero. Some estimates that there is less than one year until the numbers run out. The American Registry for Internet Numbers (ARIN) have produced presentation material that can be used to spread the word about this issue. I would recommend you to influence your local internet service provider to take action to use IP version 6 if it is not already in place.

For an application developer involved in programming for communications over the wire, the future will most certainly contain requirements on software to be able to work over both IP v4 and v6. If you are into Boost; The Boost::Asio library provides a nice interface which is transparent with regards to what version of IP is used. The class boost::asio::ip::address implements version-independent IP addresses.

Here are some articles from elsewhere on this issue:

Using the FileManager PHP class

2010-07-06T19:27:00.000+02:00

Today, I had reasons for needing a file manager on one of the web sites that I maintain. The requirements on the file manager were as follows:

To enable upload and download of files from/to the hard drive of the client.
To enable deletion and renaming of files on the web server.
To enable folder creation and deletion on the web server.

After some research using a popular search engine, I ended up downloading the PHP application FileManager. This is a PHP class that uses AJAX techniques for communication between the client and the web server.

A quote from the readme file in the distribution:

Use this software to manage files and directories on your webserver or on an FTP server. You can create, rename and delete directories, upload, download, edit, rename, delete and search files, and change file and directory permissions

So, it seemed as though all the requirements should be fulfilled using FileManager. Installation was relatively easy:

Unzip an archive and copy the contents to some location on the web server.
Configure the default behavior of the FileManager class using a config file.
Set some directory permissions.
Edit the page or pages where you want to have the functionality, include the FileManager.php class and create an instance of it. Make sure that you don't prematurely change the header information sent by PHP before you create a FileManager instance.

Objects of the FileManager class can be instantiated with an argument specifying the root folder of the hierarchy that you want to publish. In this way, it is relatively easy to have various root's depending on who is calling the PHP script.

I did came across one obstacle with the FileManager. I was using a specialized session handler on the web site that did not function well in cooperating with the FileManager's use of session cookies. So, I had to skip the special session handler and use the default one for the pages including the FileManager functionality. This was not a big loss since they could be nicely integrated into IFRAME's and using the normal session handling used for the rest of site was not needed.

I would recommend using the FileManager class for anybody with the same requirements as specified above.

NTP client in C++ using boost::asio, Windows build

2010-06-15T19:31:00.008+02:00

In a previous post, I published some code for a client NTP that can write the current date and time on standard output. Now, it has been compiled for Windows and you can download it here.

The program was built with MinGW that includes g++ version 4.4.0 and using Boost version 1.43 with multithreading and static linking. The _WIN32_WINNT variable is defined to be 0x0501 which indicates that the program is built for a Windows XP target. The command line used was:

g++ -D_WIN32_WINNT=0x0501 -s -O2 NtpClient.cpp -o NtpClient.exe \
   -IC:/Boost/include/boost-1_43 \
   -LC:/Boost/lib \
   -lboost_date_time-mgw44-mt-s-1_43 \
   -lboost_system-mgw44-mt-s-1_43 \
   -lwsock32 \
   -lws2_32

Of course, you have to copy and paste the code from the previous post into the file NtpClient.cpp :-)

NTP client in C++ using boost::asio

2010-05-11T16:10:00.008+02:00

For your convenience, I wrote a simple NTP client using nothing but standard C++ and the boost::asio library. The code for it is attached below. Using the static method NtpClient::GetTime(), the current time as reported by pool.ntp.org is retreaved as in the following program:

#include <iostream>
#include "NtpClient.hpp"
#include <boost/date_time/posix_time/posix_time.hpp> // Need I/O.
int main(int argc,char** argv)
{
   if( 1 == argc )
   {
      std::cout << NtpClient::GetTime() << '\n';
   }
   else if( 2 == argc )
   {
      std::cout << NtpClient::GetTime( argv[1] ) << '\n';
   }
   else
   {
      std::cerr
        << "Usage: " << argv[0]
        << " NTP-server\n  NTP-server is pool.ntp.org if not specified\n";
      return 1;
   }
   return 0;
}

The NtpClient class is coded as follows:

// NTP client uaing Boost::Asio.
// 2010-05-11
// Jansson Consulting
// http://www.p-jansson.com
// Dedicated to the Public Domain.
#ifndef NTPCLIENT_HPP
#define NTPCLIENT_HPP
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
class NtpClient
{
   public:
      static boost::posix_time::ptime GetTime()
      {
         return GetTime("pool.ntp.org");
      };
      static boost::posix_time::ptime GetTime( const char* ntpServer )
      {
         using boost::asio::ip::udp;
         boost::asio::io_service io_service;

         udp::resolver resolver(io_service);
         udp::resolver::query query(udp::v4(), ntpServer, "ntp");
         udp::endpoint receiver_endpoint = *resolver.resolve(query);

         udp::endpoint sender_endpoint;

         boost::uint8_t data[48] = {
            0x1B,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
         };

         udp::socket socket(io_service);
         socket.open(udp::v4());

         socket.send_to(
               boost::asio::buffer(data),
               receiver_endpoint);
         socket.receive_from(
               boost::asio::buffer(data),
               sender_endpoint);

         typedef boost::uint32_t u32;
         const u32 iPart(
               static_cast<u32>(data[40]) << 24
               | static_cast<u32>(data[41]) << 16
               | static_cast<u32>(data[42]) << 8
               | static_cast<u32>(data[43])
               );
         const u32 fPart(
               static_cast<u32>(data[44]) << 24
               | static_cast<u32>(data[45]) << 16
               | static_cast<u32>(data[46]) << 8
               | static_cast<u32>(data[47])
               );

         using namespace boost::posix_time;
         const ptime pt(
               boost::gregorian::date(1900,1,1),
               milliseconds(
                  iPart * 1.0E3
                  + fPart * 1.0E3 / 0x100000000ULL )
               );
         return pt;
      };
};
#endif

When linking, you have to include the boost_date_time and boost_system libraries.

Update 2010-06-15: I have built this program for Microsoft Windows in another post.

Boost C++ Libraries version 1.43 released

2010-05-06T23:19:00.001+02:00

Just for your information: On May 6, 2010, version 1.43 of the Boost C++ Libraries was released.

Boost C++ Libraries version 1.42.0 released

2010-02-03T08:29:00.001+01:00

Just for your information: On February 2, 2010, version 1.42.0 of the Boost C++ Libraries was released.

RSA-768 is no longer secure

2010-01-08T14:41:00.001+01:00

A quickie: You should probably go way beyond 1024 bits now that 768-bit RSA encryption is factorable. I would not recommend using encryption that is scheduled to be decrypted within the next 10 years.

Detecting when you've been hacked

2009-12-19T18:26:00.002+01:00

Suppose your LINUX box is being targeted by a clumsy adversary that does not hide tracks very well. How do you detect it?

Put the following command in your login shell script, e.g /root/.bash_profile if your'e into Bash. It will report the root shell access to your email.

echo 'ALERT - Root Shell Access on:' `date` `who` | \
  mail -s "Alert: Root Access from `who | awk '{print $6}'`" YOUR_EMAIL_HERE

Do you want a C++ t-shirt?

2009-12-13T12:14:00.002+01:00

If you do, you can buy one here: