@foone In particular, this code looks relevant:

sub incoming_process_packet
{
  my $self = shift;

  my $server;
  my $packet;

#  $DEBUG && warn "INCOMING:  Reading incoming packet ...\n";

  if (!defined($self->{'socket'}))
  {
    die "No socket!\n";
    return;
  }

  my $sock = $self->{'socket'};
  $self->{'user_uin'} = 0;

  unless ($sock->recv($packet, 99999))
  {
#   croak "socket:  recv2:  $!";

    print "Socket died! Opening a new...\n";

    # open the connection
    $self->{'socket'} =
      new IO::Socket::INET(LocalPort => $self->{'port'},
                           Proto     => "udp",
                           Type      => SOCK_DGRAM,
                           Reuse     => 1
                           ) || croak "new: connect socket: $!";

    $self->{'select'} = new IO::Select [$self->{'socket'}];
    return;
  }

  if (!defined($packet))
  {
    die "No message!\n";
    return;
  }

  my($version, $command, $sequence_number, $session_id, $zeroes, 
     $sequence_number2, $user_uin, $checksum);

  $version = unpack("v", $packet);
  if ($version == 2)
  {
    if ($DEBUG && $DEBUG_PACKET_DUMP)
    {
      print "\nIncoming packet:\n";
      $self->dump_packet($packet);
    }

    ($packet, $version)         = extract_uword($packet);
    ($packet, $command)         = extract_uword($packet);
    ($packet, $sequence_number) = extract_uword($packet);

    ($zeroes, $sequence_number2, $user_uin, $checksum, $session_id) = 
      (0, 0, 0, 0, 0);
  }
  elsif ($version == 3 || $version == 4)
  {
#    if ($DEBUG && $DEBUG_PACKET_DUMP)
#    {
#      print "\nIncoming encrypted packet:\n";
#      $DEBUG_PACKET_DUMP && $self->dump_packet($packet);
#    }

    $packet = $self->decrypt_packet_v4($packet);

    ($packet, $version)          = extract_uword($packet);
    ($packet, $session_id)       = extract_uword($packet);
    ($packet, $zeroes)           = extract_uword($packet);
    ($packet, $command)          = extract_uword($packet);
    ($packet, $sequence_number)  = extract_uword($packet);
    ($packet, $sequence_number2) = extract_uword($packet);
    ($packet, $user_uin)         = extract_udword($packet);
    ($packet, $checksum)         = extract_udword($packet);
  }
  elsif ($version == 5)
  {
#    if ($DEBUG && $DEBUG_PACKET_DUMP)
#    {
#      print "\nIncoming encrypted packet:\n";
#      $self->dump_packet($packet);
#    }

    my($checkcode) = $self->find_checkcode_v5($packet);
    $packet = $self->crypt_packet_v5($packet, $checkcode);

    my($org_packet) = $packet;

    ($packet, $version)          = extract_uword($packet);
    ($packet, $zeroes)           = extract_udword($packet);
    ($packet, $user_uin)         = extract_udword($packet);
    ($packet, $session_id)       = extract_udword($packet);
    ($packet, $command)          = extract_uword($packet);
    ($packet, $sequence_number)  = extract_uword($packet);
    ($packet, $sequence_number2) = extract_uword($packet);
    ($packet, $checksum)         = extract_udword($packet);

    if ($DEBUG && $DEBUG_PACKET_DUMP &&
        ($DEBUG_ACK ||
          ($command ne $client_commands{'ACK'} &&
           $command ne $client_commands{'KEEP_ALIVE'} &&
           $command ne $client_commands{'KEEP_ALIVE_2'})))
    {
      print "\nIncoming decrypted packet:\n";
      $self->dump_packet($org_packet);
    }

  }
  else
  {
    $DEBUG && warn("Cannot handle version $version packets!!!\n");
    return;
  }

  if ($DEBUG)
  {
    my $command_hex = &uword_to_hex($command);
    my $sc = $client_commands_bynumber{$command};
    if ($sc)
    {
      if ($DEBUG_ACK ||
          ($command ne $client_commands{'ACK'} &&
           $command ne $client_commands{'KEEP_ALIVE'} &&
           $command ne $client_commands{'KEEP_ALIVE_2'}))
      {
        warn "INCOMING:  Got command " .  
          $client_commands_bynumber{$command} . " ($command/$command_hex) ",
          "sequence $sequence_number, $sequence_number2\n";
      }
    }
    else
    {
      warn "INCOMING:  Got unknown command number $command/$command_hex ",
      "sequence $sequence_number, $sequence_number2\n";
    }
  }

  if ($command eq $client_commands{'ACK'}) {
    # ack is special case, we ignore it for the moment
    # TODO we should keep track of packets sent (hash, indexed
    #      by sequence number) and tick them off when they're
    #      ACK'd.  Then resend things if they aren't.  Fiddly.
    $DEBUG && $DEBUG_ACK && 
      warn "INCOMING:  Got ACK for packet $sequence_number\n";
  }
  else
  {
    # common packet info
    my(%packet_header) =
    (
      'version'    => $version,
      'command'    => $command,
      'seq_num'    => $sequence_number,
      'seq_num2'   => $sequence_number2,
      'user_uin'   => $user_uin,
      'checksum'   => $checksum,
      'session_id' => $session_id,
    );

    $self->{'packet_header'} = \%packet_header;
    $DEBUG && $DEBUG_ACK && 
      warn "INCOMING: Sending ACK for packet $sequence_number, ",
      "$sequence_number2, random=$session_id\n";

    # If this is a disconnect message we must not ack it, so the ack is
    # done in receive_send_text_code if needed...
    unless ($command == $client_commands{'SEND_TEXT_CODE'})
    {
      $self->send_ack($sequence_number, $sequence_number2);
    }

    if ($self->session_check_user_status($user_uin, 'OFFLINE'))
    {
      # User is set offline => we only allow session setup commands 
      if ($command != $client_commands{'LOGIN'} &&
          $command != $client_commands{'OLD_USER_REG'} &&
          $command != $client_commands{'NEW_USER_REG'} &&
          $command != $client_commands{'NEW_USER_1'} &&
          $command != $client_commands{'SEND_TEXT_CODE'})
      {
        print(">>NOT_LOGGED_IN:\n",
              "    user_uin=$user_uin\n");

        $packet = "";

        $self->send_packet($self->construct_packet("NOT_LOGGED_IN", $packet));
        return 0;
      }
    }

    # Update time stamp
    if ($user_uin != 0 && $command != $client_commands{'LOGIN'})
    {
      $self->{'sessions'}{$user_uin}{'last_packet_received_time'} = time;
    }

    $self->session_kill_inactive_sessions();

    my $command_name = "receive_" . lc($client_commands_bynumber{$command});
    my $coderef = $self->can($command_name);
    if ($command_name && $coderef)
    {
      # we've found a method that can process this type of packet
      return $self->$command_name($packet);
    }
    else
    {
      # TODO: can't cope - what do we do with this packet!!
      warn("UNKNOWN PACKET TYPE: '$command/",
           &uword_to_hex($command),
           "', sequence number '$sequence_number, $sequence_number2'");
      $DEBUG && warn("INCOMING: Unknown packet dump: ", Dumper($packet), "\n");
      return 0;
    }
  }
}