File Coverage

blib/lib/Net/MQTT/Message/Connect.pm

Criterion	Covered	Total	%
statement	67	67	100.0
branch	42	42	100.0
condition			n/a
subroutine	23	23	100.0
pod	16	16	100.0
total	148	148	100.0

use strict;
use warnings;
package Net::MQTT::Message::Connect;
$Net::MQTT::Message::Connect::VERSION = '1.143250';
# ABSTRACT: Perl module to represent an MQTT Connect message


use base 'Net::MQTT::Message';
use Net::MQTT::Constants qw/:all/;

sub message_type {
  1
}


sub protocol_name { shift->{protocol_name} || 'MQIsdp' }


sub protocol_version { shift->{protocol_version} || 3 }


sub user_name_flag {
  my $self = shift;
  $self->{user_name_flag} || defined $self->{user_name};
}


sub password_flag {
  my $self = shift;
  $self->{password_flag} || defined $self->{password};
}


sub will_retain { shift->{will_retain} || 0 }


sub will_qos { shift->{will_qos} || 0 }


sub will_flag {
  my $self = shift;
  $self->{will_flag} || defined $self->{will_topic}
}


sub clean_session {
  my $self = shift;
  defined $self->{clean_session} ? $self->{clean_session} : 1
}


sub connect_reserved_flag { shift->{connect_reserved_flag} || 0 }


sub keep_alive_timer { shift->{keep_alive_timer} || 60 }


sub client_id { shift->{client_id} || 'NetMQTTpm'.$$ }


sub will_topic { shift->{will_topic} }


sub will_message { shift->{will_message} }


sub user_name { shift->{user_name} }


sub password { shift->{password} }

sub _remaining_string {
  my ($self, $prefix) = @_;
  $self->protocol_name.'/'.$self->protocol_version.'/'.$self->client_id.
    ($self->user_name_flag ? ' user='.$self->user_name : '').
    ($self->password_flag ? ' pass='.$self->password : '').
    ($self->will_flag
     ? ' will='.$self->will_topic.',"'.$self->will_message.'",'.
       $self->will_retain.','.qos_string($self->will_qos) : '').
    ' '.$self->SUPER::_remaining_string($prefix)
}

sub _parse_remaining {
  my $self = shift;
  my $offset = 0;
  $self->{protocol_name} = decode_string($self->{remaining}, \$offset);
  $self->{protocol_version} = decode_byte($self->{remaining}, \$offset);
  my $b = decode_byte($self->{remaining}, \$offset);
  $self->{user_name_flag} = ($b&0x80) >> 7;
  $self->{password_flag} = ($b&0x40) >> 6;
  $self->{will_retain} = ($b&0x20) >> 5;
  $self->{will_qos} = ($b&0x18) >> 3;
  $self->{will_flag} = ($b&0x4) >> 2;
  $self->{clean_session} = ($b&0x2) >> 1;
  $self->{connect_reserved_flag} = $b&0x1;
  $self->{keep_alive_timer} = decode_short($self->{remaining}, \$offset);
  $self->{client_id} = decode_string($self->{remaining}, \$offset);
  if ($self->will_flag) {
    $self->{will_topic} = decode_string($self->{remaining}, \$offset);
    $self->{will_message} = decode_string($self->{remaining}, \$offset);
  }
  if ($self->user_name_flag) {
    $self->{user_name} = decode_string($self->{remaining}, \$offset);
  }
  if ($self->password_flag) {
    $self->{password} = decode_string($self->{remaining}, \$offset);
  }
  substr $self->{remaining}, 0, $offset, '';
}

sub _remaining_bytes {
  my $self = shift;
  my $o = encode_string($self->protocol_name);
  $o .= encode_byte($self->protocol_version);
  $o .= encode_byte(
                    ($self->user_name_flag << 7) |
                    ($self->password_flag << 6) |
                    ($self->will_retain << 5) | ($self->will_qos << 3) |
                    ($self->will_flag << 2) |
                    ($self->clean_session << 1) |
                    $self->connect_reserved_flag);
  $o .= encode_short($self->keep_alive_timer);
  $o .= encode_string($self->client_id);
  $o .= encode_string($self->will_topic) if ($self->will_flag);
  $o .= encode_string($self->will_message) if ($self->will_flag);
  $o .= encode_string($self->user_name) if ($self->user_name_flag);
  $o .= encode_string($self->password) if ($self->password_flag);
  $o;
}

1;

__END__