Fixing receiveBytes for UDP

Changes to this method meant that when a call to receiveBytes
with num_bytes = 0 meant that the function exited without trying
to read.  Checks were added to make sure, in the case num_bytes = 0
to call at least once.
More formal fix for UDP communication.

This should now make UDP sockets act almost exactly like the
TCP sockets.  The primary difference I notice at the moment
is that makeConnect is necessarily blocking for UDP, while for
TCP it just connects without the need for a handshake.

Here is a list of the changes:

 - UdpSocket now has its own read buffer. For rawReceiveBytes,
     it now only does a RECV_FROM to its UDP-specific buffer when there
     is no data in it.  Then it copies whatever it can from that buffer into the
     requested buffer.  The rawPoll operation acts almost the same as the previous poll,
     except it goes ahead and returns as ready when there is data left in the internal
     buffer. Thus, we should get almost the same functionality overall as the TCP
     code.

 - Removed original "fixes" I put in. receiveBytes acts the same as originally.

 - SimpleSocket::setConnected is now public (this is the only way you can
     encourage a socket to try and connect again, if you timeout in
     cyclic communication, the server should set this to false and
     try connecting again when it gets information on the point)

 - SimpleSocket::poll is now a virtual method named rawPoll to be implemented by *Socket
     (this is due to how UDP does reads now).  TCP's poll code is identical to the original.

 - UdpServer::makeConnect doesn't hard-block waiting for the handshake message anymore.

 - I have refactored most of the utest.cpp code to make it possible to run the same
     tests for both TCP and UDP.  Most of the code is identical, except that the makeConnect
     calls have to be run differently. Since for UDP, each call is blocking until the
     handshake is completed, you must call one of them in a thread.  It seems that this
     works fine for both TCP and UDP though.

 - I have added a new test which enables the UDP_TEST macro in the utest.cpp.
Putting back in timeout for receiveBytes
Merge branch 'hydro-devel' of https://github.com/ros-industrial/industrial_core into hydro-devel
Merge branch 'hydro-devel' into hydro-devel-merge-udp-fix2
Making setConnected protected again, adding setDisconnected to public methods so that that method can be used to flag the connection as disconnected.
robot_simulator: add GetRobotInfo svc server.

Users can override the information returned by the get_robot_info service
server. This can be useful if multiple instances of the simulator are
used in a ROS application, and each needs to be uniquely identified.

Additionally, this makes it possible to return information taken from real
controllers and manipulators, in order to provide a more 'real' simulation.

Users can enable the override by setting the private parameter 'robot_info' in
a launch file like so:

  <node .. type="industrial_robot_simulator" name=".." ..>
    <rosparam param="robot_info">
      controller:
        model: 'My Robot Controller'
        serial_number: 'ABC-123'
        sw_version: 'V1.23/ABC'
      robots:
        - model: 'My Robot Model'
          serial_number: '123456'
          sw_version: 'V4.56/DEF'
    </rosparam>
  </node>

As the Industrial Robot Simulator currently simulates only a single robot /
motion group, specifying multiple robot entries will result in only the first
of the list to be used.

Fields absent from the rosparam parameter will result in empty strings being
assigned to the corresponding fields in the 'controller' and 'robot' parts of
the service response.
Merge pull request #70 from gt-ros-pkg/hydro-devel

Fixing receiveBytes for UDP
Merge pull request #93 from gavanderhoorn/rob_sim_get_robot_info

Add GetRobotInfo service server implementation to Robot Simulator