dicom 0.6.1 → 0.7

data/lib/dicom/FileHandler.rb

@@ -0,0 +1,50 @@
+#    Copyright 2010 Christoffer Lervag
+
+# The purpose of this file is to make it very easy for users to customise the way
+# DICOM files are handled when they are received through the network.
+# The default behaviour is to save the file to disk using a folder structure determined by the file's DICOM tags.
+# Some suggested alternatives:
+# - Analyzing tags and/or image data to determine further actions.
+# - Modify the DICOM object before it is saved to disk.
+# - Modify the folder structure in which DICOM files are saved to disk.
+# - Store DICOM contents in a database (highly relevant if you are building a Ruby on Rails application).
+# - Retransmit the DICOM object to another network destination using the DClient class.
+# - Write information to a log file.
+
+module DICOM
+
+  # This class handles DICOM files that have been received through network communication.
+  class FileHandler
+
+    # Handles the reception of a DICOM file.
+    # Default action: Save to disk.
+    # Modify this method if you want a different behaviour!
+    def self.receive_file(obj, path_prefix, transfer_syntax)
+      # Did we receive a valid DICOM file?
+      if obj.read_success
+        # File name is set using the SOP Instance UID
+        file_name = obj.get_value("0008,0018") || "no_SOP_UID.dcm"
+        # File will be saved with the following path:
+        # path_prefix/<PatientID>/<StudyDate>/<Modality>/
+        folders = Array.new(3)
+        folders[0] = obj.get_value("0010,0020") || "PatientID"
+        folders[1] = obj.get_value("0008,0020") || "StudyDate"
+        folders[2] = obj.get_value("0008,0060") || "Modality"
+        local_path = folders.join(File::SEPARATOR) + File::SEPARATOR + file_name
+        full_path = path_prefix + local_path
+        # Save the DICOM object to disk:
+        obj.write(full_path, transfer_syntax)
+        # As the file has been received successfully, set the success boolean and a corresponding 'success string':
+        success = true
+        message = "DICOM file saved to: #{full_path}"
+      else
+        # Received data was not successfully read as a DICOM file.
+        success = false
+        message = "Error: The received file was not successfully parsed as a DICOM object."
+      end
+      # A boolean indicating success/failure, and a message string must be returned:
+      return success, message
+    end
+
+  end # of class
+end # of module

data/lib/{Link.rb → dicom/Link.rb}

@@ -1,4 +1,4 @@
-#    Copyright 2009 Christoffer Lervag
+#    Copyright 2009-2010 Christoffer Lervag
 
 module DICOM
 
@@ -6,15 +6,15 @@ module DICOM
   # as well as network communication.
   class Link
 
-    attr_accessor :max_package_size, :verbose
+    attr_accessor :max_package_size, :verbose, :file_handler
     attr_reader :errors, :notices
 
     # Initialize the instance with a host adress and a port number.
     def initialize(options={})
       require 'socket'
       # Optional parameters (and default values):
+      @file_handler = options[:file_handler] || FileHandler
       @ae =  options[:ae]  || "RUBY_DICOM"
-      @lib =  options[:lib]  || DLibrary.new
       @host_ae =  options[:host_ae]  || "DEFAULT"
       @max_package_size = options[:max_package_size] || 32768 # 16384
       @max_receive_size = @max_package_size
@@ -38,36 +38,47 @@ module DICOM
 
     # Build the abort message which is transmitted when the server wishes to (abruptly) abort the connection.
     # For the moment: NO REASONS WILL BE PROVIDED. (and source of problems will always be set as client side)
-    def build_abort(message)
+    def build_association_abort
       # Big endian encoding:
       @outgoing.set_endian(@net_endian)
       # Clear the outgoing binary string:
       @outgoing.reset
+      pdu = "07"
       # Reserved (2 bytes)
-      @outgoing.encode_first("00"*2, "HEX")
+      @outgoing.encode_last("00"*2, "HEX")
       # Source (1 byte)
       source = "00" # (client side error)
-      @outgoing.encode_first(source, "HEX")
+      @outgoing.encode_last(source, "HEX")
       # Reason/Diag. (1 byte)
       reason = "00" # (Reason not specified)
-      @outgoing.encode_first(reason, "HEX")
+      @outgoing.encode_last(reason, "HEX")
+      append_header(pdu)
     end
 
 
     # Build the binary string that will be sent as TCP data in the Association accept response.
-    def build_association_accept(ac_uid, ts, ui, result)
+    def build_association_accept(info, ac_uid, ui, result)
       # Big endian encoding:
       @outgoing.set_endian(@net_endian)
       # Clear the outgoing binary string:
       @outgoing.reset
       # Set item types (pdu and presentation context):
       pdu = "02"
-      pc = "21"
+      pc_type = "21"
       # No abstract syntax in association response:
-      as = nil
+      abstract_syntax = nil
       # Note: The order of which these components are built is not arbitrary.
       append_application_context(ac_uid)
-      append_presentation_context(as, pc, ts, result)
+      # Return one presentation context for each of the proposed abstract syntaxes:
+      abstract_syntaxes = Array.new
+      info[:pc].each do |pc|
+        unless abstract_syntaxes.include?(pc[:abstract_syntax])
+          abstract_syntaxes << pc[:abstract_syntax]
+          context_id = pc[:presentation_context_id]
+          transfer_syntax = pc[:ts].first[:transfer_syntax]
+          append_presentation_context(abstract_syntax, pc_type, transfer_syntax, context_id, result)
+        end
+      end
       append_user_information(ui)
       # Header must be built last, because we need to know the length of the other components.
       append_association_header(pdu)
@@ -76,7 +87,7 @@ module DICOM
 
     # Build the binary string that will be sent as TCP data in the association rejection.
     # NB: For the moment, this method will only customize the "reason" value.
-    # For a list of error codes, see the official dicom 08_08.pdf, page 41.
+    # For a list of error codes, see the official dicom PS3.8 document, page 41.
     def build_association_reject(info)
       # Big endian encoding:
       @outgoing.set_endian(@net_endian)
@@ -107,6 +118,7 @@ module DICOM
       pdu = "01"
       pc = "20"
       # Note: The order of which these components are built is not arbitrary.
+      # (The first three are built 'in order of appearance', the header is built last, but is put first in the message)
       append_application_context(ac_uid)
       append_presentation_context(as, pc, ts)
       append_user_information(ui)
@@ -161,10 +173,9 @@ module DICOM
 
 
     # Build the binary string that will be sent as TCP data in the query data fragment.
-    # NB!! This method does not (yet) take explicitness into consideration when building content.
-    # It might go wrong if an implicit data stream is encountered!
+    # The style of encoding will depend on whether we have an implicit or explicit transfer syntax.
     def build_data_fragment(data_elements)
-      # Little endian encoding:
+      # Endianness of data fragment:
       @outgoing.set_endian(@data_endian)
       # Clear the outgoing binary string:
       @outgoing.reset
@@ -174,13 +185,19 @@ module DICOM
         # Encode all tags (even tags which are empty):
         # Tag (4 bytes)
         @outgoing.add_last(@outgoing.encode_tag(element[0]))
-        # Type (VR) (2 bytes)
-        vr = @lib.get_name_vr(element[0])[1]
-        @outgoing.encode_last(vr, "STR")
-        # Encode the value first, so we know its length:
+        # Encode the value in advance of putting it into the message, so we know its length:
+        vr = LIBRARY.get_name_vr(element[0])[1]
         value = @outgoing.encode_value(element[1], vr)
-        # Length (2 bytes)
-        @outgoing.encode_last(value.length, "US")
+        if @explicit
+          # Type (VR) (2 bytes)
+          @outgoing.encode_last(vr, "STR")
+          # Length (2 bytes)
+          @outgoing.encode_last(value.length, "US")
+        else
+          # Implicit:
+          # Length (4 bytes)
+          @outgoing.encode_last(value.length, "UL")
+        end
         # Value (variable length)
         @outgoing.add_last(value)
       end
@@ -247,6 +264,18 @@ module DICOM
     end
 
 
+    # Extracts the abstrax syntax from the first presentation context in the info hash object:
+    def extract_abstract_syntax(info)
+      return info[:pc].first[:abstract_syntax]
+    end
+
+
+    # Extracts the (first) transfer syntax from the first presentation context in the info hash object:
+    def extract_transfer_syntax(info)
+      return info[:pc].first[:ts].first[:transfer_syntax]
+    end
+
+
     # Delegates an incoming message to its correct interpreter method, based on pdu type.
     def forward_to_interpret(message, pdu, file = nil)
       case pdu
@@ -282,10 +311,11 @@ module DICOM
 
     # Handles the association accept.
     def handle_association_accept(session, info, syntax_result)
+      # Update the variable for calling ae (information gathered in the association request):
+      @ae = info[:calling_ae]
       application_context = info[:application_context]
-      abstract_syntax = info[:abstract_syntax]
-      transfer_syntax = info[:ts].first[:transfer_syntax]
-      build_association_accept(application_context, transfer_syntax, @user_information, syntax_result)
+      set_user_information_array(info)
+      build_association_accept(info, application_context, @user_information, syntax_result)
       transmit(session)
     end
 
@@ -315,19 +345,19 @@ module DICOM
         end
       end
       data = file_data.join
-      # Read the received data stream and load it as a DICOM object:
-      obj = DObject.new(data, :bin => true, :syntax => @transfer_syntax)
-      # File will be saved with the following path:
-      # original_path/<PatientID>/<StudyDate>/<Modality>/
-      # File name will be equal to the SOP Instance UID
-      file_name = obj.get_value("0008,0018")
-      folders = Array.new(3)
-      folders[0] = obj.get_value("0010,0020") || "PatientID"
-      folders[1] = obj.get_value("0008,0020") || "StudyDate"
-      folders[2] = obj.get_value("0008,0060") || "Modality"
-      full_path = path + folders.join(File::SEPARATOR) + File::SEPARATOR + file_name
-      obj.write(full_path, @transfer_syntax)
-      return full_path
+      if data.length > 8
+        # Read the received data stream and load it as a DICOM object:
+        obj = DObject.new(data, :bin => true, :syntax => @transfer_syntax)
+        # The actual handling of the DICOM object and (processing, saving, database storage, retransmission, etc)
+        # is handled by the external FileHandler class, in order to make it as easy as possible for users to write
+        # their own customised solutions for handling the incoming DICOM files:
+        success, message = @file_handler.receive_file(obj, path, @transfer_syntax)
+      else
+        # Valid DICOM data not received:
+        success = false
+        message = "Error: Invalid data received (the data was too small to be a valid DICOM file)."
+      end
+      return success, message
     end
 
 
@@ -403,9 +433,14 @@ module DICOM
           fragment = msg.extract(specified_length)
           info = forward_to_interpret(fragment, pdu, file)
           info[:pdu] = pdu
+          segments << info
+          # It is possible that a fragment contains both a command and a data fragment. If so, we need to make sure we collect all the information:
+          if info[:rest_string]
+            additional_info = forward_to_interpret(info[:rest_string], pdu, file)
+            segments << additional_info
+          end
           # The information gathered from the interpretation is appended to a segments array,
           # and in the case of a recursive call some special logic is needed to build this array in the expected fashion.
-          segments << info
           remaining_segments = interpret(msg.rest_string, file)
           remaining_segments.each do |remaining|
             segments << remaining
@@ -416,8 +451,13 @@ module DICOM
           info = forward_to_interpret(fragment, pdu, file)
           info[:pdu] = pdu
           segments << info
+          # It is possible that a fragment contains both a command and a data fragment. If so, we need to make sure we collect all the information:
+          if info[:rest_string]
+            additional_info = forward_to_interpret(info[:rest_string], pdu, file)
+            segments << additional_info
+          end
         else
-          # Length of the message is less than what is specified in the message. Throw error:
+          # Length of the message is less than what is specified in the message. Need to listen for more. This is hopefully handled properly now.
           #add_error("Error. The length of the received message (#{msg.rest_length}) is smaller than what it claims (#{specified_length}). Aborting.")
           @first_part = msg.string
         end
@@ -440,34 +480,9 @@ module DICOM
       # Reason/Diag. (1 byte)
       info[:reason] = msg.decode(1, "HEX")
       # Analyse the results:
-      if info[:source] == "00"
-        add_error("Warning: Connection has been aborted by the service provider because of an error by the service user (client side).")
-      elsif info[:source] == "02"
-        add_error("Warning: Connection has been aborted by the service provider because of an error by the service provider (server side).")
-      else
-        add_error("Warning: Connection has been aborted by the service provider, with an unknown cause of the problems. (error code: #{info[:source]})")
-      end
-      if info[:source] != "00"
-        # Display reason for error:
-        case info[:reason]
-          when "00"
-            add_error("Reason specified for abort: Reason not specified")
-          when "01"
-            add_error("Reason specified for abort: Unrecognized PDU")
-          when "02"
-            add_error("Reason specified for abort: Unexpected PDU")
-          when "04"
-            add_error("Reason specified for abort: Unrecognized PDU parameter")
-          when "05"
-            add_error("Reason specified for abort: Unexpected PDU parameter")
-          when "06"
-            add_error("Reason specified for abort: Invalid PDU parameter value")
-          else
-            add_error("Reason specified for abort: Unknown reason (Error code: #{info[:reason]})")
-        end
-      end
-      @listen = false
-      @receive = false
+      process_source(info[:source])
+      process_reason(info[:reason])
+      stop_receiving
       @abort = true
       info[:valid] = true
       return info
@@ -510,21 +525,7 @@ module DICOM
       msg.skip(1)
       # Result (& Reason) (1 byte)
       info[:result] = msg.decode(1, "BY")
-      # Analyse the results:
-      unless info[:result] == 0
-        case info[:result]
-          when 1
-            add_error("Warning: DICOM Request was rejected by the host, reason: 'User-rejection'")
-          when 2
-            add_error("Warning: DICOM Request was rejected by the host, reason: 'No reason (provider rejection)'")
-          when 3
-            add_error("Warning: DICOM Request was rejected by the host, reason: 'Abstract syntax not supported'")
-          when 4
-            add_error("Warning: DICOM Request was rejected by the host, reason: 'Transfer syntaxes not supported'")
-          else
-            add_error("Warning: DICOM Request was rejected by the host, reason: 'UNKNOWN (#{info[:result]})' (Illegal reason provided)")
-        end
-      end
+      process_result(info[:result])
       # Reserved (1 byte)
       msg.skip(1)
       # Transfer syntax sub-item:
@@ -537,7 +538,7 @@ module DICOM
       # Transfer syntax name (variable length)
       info[:transfer_syntax] = msg.decode(info[:transfer_syntax_item_length], "STR")
       # USER INFORMATION:
-      # Item type (1 byte)
+      # Item type (1 byte) ("50")
       info[:user_info_item_type] = msg.decode(1, "HEX")
       # Reserved (1 byte)
       msg.skip(1)
@@ -556,14 +557,21 @@ module DICOM
             @max_receive_size = info[:max_pdu_length]
           when "52"
             info[:implementation_class_uid] = msg.decode(item_length, "STR")
+          when "53"
+            # Asynchronous operations window negotiation (PS 3.7: D.3.3.3) (2*2 bytes)
+            info[:maxnum_operations_invoked] = msg.decode(2, "US")
+            info[:maxnum_operations_performed] = msg.decode(2, "US")
           when "55"
             info[:implementation_version] = msg.decode(item_length, "STR")
           else
+            # Value (variable length)
+            value = msg.decode(item_length, "STR")
             add_error("Unknown user info item type received. Please update source code or contact author. (item type: " + item_type + ")")
         end
       end
+      stop_receiving
       info[:valid] = true
-      # Update key values for this instance:
+      # Update transfer syntax settings for this instance:
       set_transfer_syntax(info[:transfer_syntax])
       return info
     end # of interpret_association_accept
@@ -581,7 +589,8 @@ module DICOM
       info[:source] = msg.decode(1, "BY")
       # Reason (1 byte)
       info[:reason] = msg.decode(1, "BY")
-      add_error("Warning: ASSOCIATE Request was rejected by the host. Error codes: Result: #{info[:result]}, Source: #{info[:source]}, Reason: #{info[:reason]} (See DICOM 08_08, page 41: Table 9-21 for details.)")
+      add_error("Warning: ASSOCIATE Request was rejected by the host. Error codes: Result: #{info[:result]}, Source: #{info[:source]}, Reason: #{info[:reason]} (See DICOM PS3.8: Table 9-21 for details.)")
+      stop_receiving
       info[:valid] = true
       return info
     end
@@ -611,49 +620,71 @@ module DICOM
       # Application context (variable length)
       info[:application_context] = msg.decode(info[:application_item_length], "STR")
       # PRESENTATION CONTEXT:
-      # Item type (1 byte)
-      info[:presentation_item_type] = msg.decode(1, "HEX") # "20"
-      # Reserved (1 byte)
-      msg.skip(1)
-      # Presentation context item length (2 bytes)
-      info[:presentation_item_length] = msg.decode(2, "US")
-      # Presentation context ID (1 byte)
-      info[:presentation_context_id] = msg.decode(1, "HEX")
-      # Reserved (3 bytes)
-      msg.skip(3)
-      # ABSTRACT SYNTAX SUB-ITEM:
-      # Abstract syntax item type (1 byte)
-      info[:abstract_syntax_item_type] = msg.decode(1, "HEX") # "30"
-      # Reserved (1 byte)
-      msg.skip(1)
-      # Abstract syntax item length (2 bytes)
-      info[:abstract_syntax_item_length] = msg.decode(2, "US")
-      # Abstract syntax (variable length)
-      info[:abstract_syntax] = msg.decode(info[:abstract_syntax_item_length], "STR")
-      ## TRANSFER SYNTAX SUB-ITEM(S):
-      item_type = "40"
-      # As multiple TS may occur, we need a loop to catch them all:
-      # Each TS Hash will be put in an array, which will be put in the info hash.
-      ts_array = Array.new
-      while item_type == "40" do
+      # As multiple presentation contexts may occur, we need a loop to catch them all:
+      # Each presentation context hash will be put in an array, which will be put in the info hash.
+      presentation_contexts = Array.new
+      pc_loop = true
+      while pc_loop do
         # Item type (1 byte)
         item_type = msg.decode(1, "HEX")
-        if item_type == "40"
-          ts = Hash.new
-          ts[:transfer_syntax_item_type] = item_type
+        if item_type == "20"
+          pc = Hash.new
+          pc[:presentation_item_type] = item_type
+          # Reserved (1 byte)
+          msg.skip(1)
+          # Presentation context item length (2 bytes)
+          pc[:presentation_item_length] = msg.decode(2, "US")
+          # Presentation context id (1 byte)
+          pc[:presentation_context_id] = msg.decode(1, "HEX")
+          # Reserved (3 bytes)
+          msg.skip(3)
+          presentation_contexts << pc
+          # A presentation context contains an abstract syntax and one or more transfer syntaxes.
+          # ABSTRACT SYNTAX SUB-ITEM:
+          # Abstract syntax item type (1 byte)
+          pc[:abstract_syntax_item_type] = msg.decode(1, "HEX") # "30"
           # Reserved (1 byte)
           msg.skip(1)
-          # Transfer syntax item length (2 bytes)
-          ts[:transfer_syntax_item_length] = msg.decode(2, "US")
-          # Transfer syntax name (variable length)
-          ts[:transfer_syntax] = msg.decode(ts[:transfer_syntax_item_length], "STR")
-          ts_array << ts
+          # Abstract syntax item length (2 bytes)
+          pc[:abstract_syntax_item_length] = msg.decode(2, "US")
+          # Abstract syntax (variable length)
+          pc[:abstract_syntax] = msg.decode(pc[:abstract_syntax_item_length], "STR")
+          ## TRANSFER SYNTAX SUB-ITEM(S):
+          # As multiple transfer syntaxes may occur, we need a loop to catch them all:
+          # Each transfer syntax hash will be put in an array, which will be put in the presentation context hash.
+          transfer_syntaxes = Array.new
+          ts_loop = true
+          while ts_loop do
+            # Item type (1 byte)
+            item_type = msg.decode(1, "HEX")
+            if item_type == "40"
+              ts = Hash.new
+              ts[:transfer_syntax_item_type] = item_type
+              # Reserved (1 byte)
+              msg.skip(1)
+              # Transfer syntax item length (2 bytes)
+              ts[:transfer_syntax_item_length] = msg.decode(2, "US")
+              # Transfer syntax name (variable length)
+              ts[:transfer_syntax] = msg.decode(ts[:transfer_syntax_item_length], "STR")
+              transfer_syntaxes << ts
+            else
+              # Break the transfer syntax loop, as we have probably reached the next stage,
+              # which is either user info or a new presentation context entry. Rewind:
+              msg.skip(-1)
+              ts_loop = false
+            end
+          end
+          pc[:ts] = transfer_syntaxes
         else
-          info[:user_info_item_type] = item_type # "50"
+          # Break the presentation context loop, as we have probably reached the next stage, which is user info. Rewind:
+          msg.skip(-1)
+          pc_loop = false
         end
       end
-      info[:ts] = ts_array
+      info[:pc] = presentation_contexts
       # USER INFORMATION:
+      # Item type (1 byte)
+      info[:user_info_item_type] = msg.decode(1, "HEX")
       # Reserved (1 byte)
       msg.skip(1)
       # User information item length (2 bytes)
@@ -671,25 +702,34 @@ module DICOM
             info[:max_pdu_length] = msg.decode(item_length, "UL")
           when "52"
             info[:implementation_class_uid] = msg.decode(item_length, "STR")
+          when "53"
+            # Asynchronous operations window negotiation (PS 3.7: D.3.3.3) (2*2 bytes)
+            info[:maxnum_operations_invoked] = msg.decode(2, "US")
+            info[:maxnum_operations_performed] = msg.decode(2, "US")
           when "55"
             info[:implementation_version] = msg.decode(item_length, "STR")
           else
-            add_error("Unknown user info item type received. Please update source code or contact author. (item type: " + item_type + ")")
+            # Unknown item type:
+            # Value (variable length)
+            value = msg.decode(item_length, "STR")
+            add_error("Notice: Unknown user info item type received. Please update source code or contact author. (item type: " + item_type + ")")
         end
       end
+      stop_receiving
       info[:valid] = true
       return info
     end # of interpret_association_request
 
 
-    # Decode the binary string received in the query response, and interpret its content.
-    # NB!! This method does not (yet) take explicitness into consideration when decoding content.
-    # It might go wrong if an implicit data stream is encountered!
+    # Decode the received command/data binary string, and interpret its content.
+    # Decoding of data fragment will depend on the explicitness of the transmission.
     def interpret_command_and_data(message, file = nil)
       info = Hash.new
       msg = Stream.new(message, @net_endian, @explicit)
       # Length (of remaining PDV data) (4 bytes)
       info[:presentation_data_value_length] = msg.decode(4, "UL")
+      # Calculate the last index position of this message element:
+      last_index = info[:presentation_data_value_length] + msg.index
       # Presentation context ID (1 byte)
       info[:presentation_context_id] = msg.decode(1, "HEX") # "01" expected
       # Flags (1 byte)
@@ -700,7 +740,7 @@ module DICOM
       results = Hash.new
       if info[:presentation_context_flag] == "03"
         # COMMAND, LAST FRAGMENT:
-        while msg.index < msg.length do
+        while msg.index < last_index do
           # Tag (4 bytes)
           tag = msg.decode_tag
           # Length (2 bytes)
@@ -711,7 +751,7 @@ module DICOM
           # Reserved (2 bytes)
           msg.skip(2)
           # Type (VR) (from library - not the stream):
-          result = @lib.get_name_vr(tag)
+          result = LIBRARY.get_name_vr(tag)
           name = result[0]
           type = result[1]
           # Value (variable length)
@@ -724,20 +764,8 @@ module DICOM
         # Check if the command fragment indicates that this was the last of the response fragments for this query:
         status = results["0000,0900"]
         if status
-          if status == 0
-            # Last fragment (Break the while loop that listens continuously for incoming packets):
-            add_notice("Receipt for successful execution of the desired request has been received. Closing communication.")
-            @listen = false
-            @receive = false
-          elsif status == 65281
-            # Status = "01 ff": More command/data fragments to follow.
-            # (No particular action taken, the program will listen for and receive the coming fragments)
-          elsif status == 65280
-            # Status = "00 ff": Sub-operations are continuing.
-            # (No particular action taken, the program will listen for and receive the coming fragments)
-          else
-            add_error("Error! Something was NOT successful regarding the desired operation. (SCP responded with error code: #{status}) (tag: 0000,0900)")
-          end
+          # Note: This method will also stop the packet receiver if indicated by the status mesasge.
+          process_status(status)
         end
       elsif info[:presentation_context_flag] == "00" or info[:presentation_context_flag] == "02"
         # DATA FRAGMENT:
@@ -747,25 +775,33 @@ module DICOM
           info[:bin] = msg.rest_string
           # Abort the listening if this is last data fragment:
           if info[:presentation_context_flag] == "02"
-            @listen = false
-            @receive = false
+            stop_receiving
           end
         else
           # Decode data elements:
-          while msg.index < msg.length do
+          while msg.index < last_index do
             # Tag (4 bytes)
             tag = msg.decode_tag
-            # Type (VR) (2 bytes):
-            type = msg.decode(2, "STR")
-            # Length (2 bytes)
-            length = msg.decode(2, "US")
+            if @explicit
+              # Type (VR) (2 bytes):
+              type = msg.decode(2, "STR")
+              # Length (2 bytes)
+              length = msg.decode(2, "US")
+            else
+              # Implicit:
+              type = nil # (needs to be defined as nil here or it will take the value from the previous step in the loop)
+              # Length (4 bytes)
+              length = msg.decode(4, "UL")
+            end
             if length > msg.rest_length
               add_error("Error: Specified length of data element value exceeds remaining length of the received message! Something is wrong.")
             end
+            # Fetch the name (& type if not defined already) for this data element:
+            result = LIBRARY.get_name_vr(tag)
+            name = result[0]
+            type = result[1] unless type
             # Value (variable length)
             value = msg.decode(length, type)
-            result = @lib.get_name_vr(tag)
-            name = result[0]
             # Put tag and value in a hash:
             results[tag] = value
           end
@@ -775,9 +811,10 @@ module DICOM
       else
         # Unknown.
         add_error("Error: Unknown presentation context flag received in the query/command response. (#{info[:presentation_context_flag]})")
-        @listen = false
-        @receive = false
+        stop_receiving
       end
+      # If only parts of the string was read, return the rest:
+      info[:rest_string] = msg.rest_string if last_index < msg.length
       info[:valid] = true
       return info
     end
@@ -789,6 +826,7 @@ module DICOM
       msg = Stream.new(message, @net_endian, @explicit)
       # Reserved (4 bytes)
       reserved_bytes = msg.decode(4, "HEX")
+      stop_receiving
       info[:valid] = true
       return info
     end
@@ -800,6 +838,7 @@ module DICOM
       msg = Stream.new(message, @net_endian, @explicit)
       # Reserved (4 bytes)
       reserved_bytes = msg.decode(4, "HEX")
+      stop_receiving
       info[:valid] = true
       return info
     end
@@ -908,8 +947,8 @@ module DICOM
 
 
     # Build the binary string that makes up the presentation context part (part of the association request).
-    # For a list of error codes, see the official dicom 08_08.pdf, page 39.
-    def append_presentation_context(as, pc, ts, result = "00")
+    # For a list of error codes, see the official DICOM PS3.8 document, (page 39).
+    def append_presentation_context(as, pc, ts, context_id = "01", result = "00")
       # PRESENTATION CONTEXT:
       # Presentation context item type (1 byte)
       @outgoing.encode_last(pc, "HEX") # "20" (request) & "21" (response)
@@ -928,7 +967,7 @@ module DICOM
       end
       @outgoing.encode_last(items_length, "US")
       # Presentation context ID (1 byte)
-      @outgoing.encode_last("01", "HEX")
+      @outgoing.encode_last(context_id, "HEX")
       # Reserved (1 byte)
       @outgoing.encode_last("00", "HEX")
       # (1 byte) Reserved (for association request) & Result/reason (for association accept response)
@@ -958,7 +997,7 @@ module DICOM
         # Transfer syntax (variable length)
         @outgoing.encode_last(t, "STR")
       end
-      # Update key values for this instance:
+      # Update transfer syntax settings for this instance:
       set_transfer_syntax(ts.first)
     end
 
@@ -992,6 +1031,102 @@ module DICOM
     end
 
 
+    # Process the value of the reason byte (in an association abort).
+    # This will provide information on what is the reason for the error.
+    def process_reason(reason)
+      case reason
+        when "00"
+          add_error("Reason specified for abort: Reason not specified")
+        when "01"
+          add_error("Reason specified for abort: Unrecognized PDU")
+        when "02"
+          add_error("Reason specified for abort: Unexpected PDU")
+        when "04"
+          add_error("Reason specified for abort: Unrecognized PDU parameter")
+        when "05"
+          add_error("Reason specified for abort: Unexpected PDU parameter")
+        when "06"
+          add_error("Reason specified for abort: Invalid PDU parameter value")
+        else
+          add_error("Reason specified for abort: Unknown reason (Error code: #{reason})")
+      end
+    end
+
+
+    # Process the value of the result byte (in the association response).
+    # Something is wrong if result is different from 0.
+    def process_result(result)
+      unless result == 0
+        # Analyse the result and report what is wrong:
+        case result
+          when 1
+            add_error("Warning: DICOM Request was rejected by the host, reason: 'User-rejection'")
+          when 2
+            add_error("Warning: DICOM Request was rejected by the host, reason: 'No reason (provider rejection)'")
+          when 3
+            add_error("Warning: DICOM Request was rejected by the host, reason: 'Abstract syntax not supported'")
+          when 4
+            add_error("Warning: DICOM Request was rejected by the host, reason: 'Transfer syntaxes not supported'")
+          else
+            add_error("Warning: DICOM Request was rejected by the host, reason: 'UNKNOWN (#{result})' (Illegal reason provided)")
+        end
+      end
+    end
+
+
+    # Process the value of the source byte (in an association abort).
+    # This will provide information on who is the source of the error.
+    def process_source(source)
+      if source == "00"
+        add_error("Warning: Connection has been aborted by the service provider because of an error by the service user (client side).")
+      elsif source == "02"
+        add_error("Warning: Connection has been aborted by the service provider because of an error by the service provider (server side).")
+      else
+        add_error("Warning: Connection has been aborted by the service provider, with an unknown cause of the problems. (error code: #{source})")
+      end
+    end
+
+
+    # Process the value of the status tag 0000,0900 received in the command fragment.
+    # Note: The status tag has vr 'US', and the status as reported here is therefore a number.
+    # In the official DICOM documents however, the value of the various status options is given in hex format.
+    # Resources: DICOM PS3.4 Annex Q 2.1.1.4, DICOM PS3.7 Annex C 4.
+    def process_status(status)
+      case status
+        when 0 # "0000"
+          # Last fragment (Break the while loop that listens continuously for incoming packets):
+          add_notice("Receipt for successful execution of the desired request has been received. Closing communication.")
+          stop_receiving
+        when 42752 # "a700"
+          # Failure: Out of resources. Related fields: 0000,0902
+          add_error("Failure! SCP has given the following reason: 'Out of Resources'.")
+        when 43264 # "a900"
+          # Failure: Identifier Does Not Match SOP Class. Related fields: 0000,0901, 0000,0902
+          add_error("Failure! SCP has given the following reason: 'Identifier Does Not Match SOP Class'.")
+        when 49152 # "c000"
+          # Failure: Unable to process. Related fields: 0000,0901, 0000,0902
+          add_error("Failure! SCP has given the following reason: 'Unable to process'.")
+        when 49408 # "c100"
+          # Failure: More than one match found. Related fields: 0000,0901, 0000,0902
+          add_error("Failure! SCP has given the following reason: 'More than one match found'.")
+        when 49664 # "c200"
+          # Failure: Unable to support requested template. Related fields: 0000,0901, 0000,0902
+          add_error("Failure! SCP has given the following reason: 'Unable to support requested template'.")
+        when 65024 # "fe00"
+          # Cancel: Matching terminated due to Cancel request.
+          add_notice("Cancel! SCP has given the following reason: 'Matching terminated due to Cancel request'.")
+        when 65280 # "ff00"
+          # Sub-operations are continuing.
+          # (No particular action taken, the program will listen for and receive the coming fragments)
+        when 65281 # "ff01"
+          # More command/data fragments to follow.
+          # (No particular action taken, the program will listen for and receive the coming fragments)
+        else
+          add_error("Error! Something was NOT successful regarding the desired operation. SCP responded with error code: #{status} (tag: 0000,0900). See DICOM PS3.7, Annex C for details.")
+      end
+    end
+
+
     # Handles an incoming transmission.
     # Optional: Specify a minimum length of the incoming transmission. (If a message is received
     # which is shorter than this limit, the method will keep listening for more incoming packets to append)
@@ -1026,8 +1161,7 @@ module DICOM
         if (Time.now.to_f - t1) > @timeout
           Thread.kill(thr)
           add_error("No answer was received within the specified timeout period. Aborting.")
-          @listen = false
-          @receive = false
+          stop_receiving
         end
       end
       return data
@@ -1040,20 +1174,18 @@ module DICOM
       @net_endian = true
       # Default endianness of data is little endian:
       @data_endian = false
-      # Explicitness (this may turn out not to be necessary...)
+      # It may turn out to be unncessary to define the following values at this early stage.
+      # Explicitness
       @explicit = true
       # Transfer syntax (Implicit, little endian):
       set_transfer_syntax("1.2.840.10008.1.2")
-      # Version information:
-      @implementation_uid = "1.2.826.0.1.3680043.8.641"
-      @implementation_name = "RUBY_DICOM_0.6"
     end
 
 
     # Set instance variables related to the transfer syntax.
     def set_transfer_syntax(value)
       # Query the library with our particular transfer syntax string:
-      result = @lib.process_transfer_syntax(value)
+      result = LIBRARY.process_transfer_syntax(value)
       # Result is a 3-element array: [Validity of ts, explicitness, endianness]
       unless result[0]
         add_error("Warning: Invalid/unknown transfer syntax encountered! Will try to continue, but errors may occur.")
@@ -1066,14 +1198,27 @@ module DICOM
 
 
     # Set user information [item type code, vr/type, value]
-    def set_user_information_array
+    def set_user_information_array(info = nil)
       @user_information = [
         ["51", "UL", @max_package_size], # Max PDU Length
-        ["52", "STR", @implementation_uid],
-        ["55", "STR", @implementation_name]
+        ["52", "STR", UID],
+        ["55", "STR", NAME]
       ]
+      # A bit of a hack to include "asynchronous operations window negotiation", if this has been included in the association request:
+      if info
+        @user_information.insert(2, ["53", "HEX", "00010001"]) if info[:maxnum_operations_invoked]
+      end
+    end
+
+
+    # Breaks the loops that listen for incoming packets by changing a couple of instance variables.
+    # This method is called by the various methods that interpret incoming data when they have verified that
+    # the entire message has been received, or when a timeout is reached.
+    def stop_receiving
+      @listen = false
+      @receive = false
     end
 
 
-  end
-end
+  end # of class
+end # of module