view release on metacpan or  search on metacpan

lib/IxNetwork/IxNetworkLegacy.pm  view on Meta::CPAN

sub _CreateFileOnServer {
    my($self) = @_;
    my $filename = $_[1];

    $self->_Send(sprintf("<001><006><007%d>%s<009>", length($filename), $filename));
    my $remoteFilename = $self->_Recv();

    return $self->_SendRecv('ixNet', 'writeTo', $remoteFilename, '-ixNetRelative', '-overwrite')
}

sub _InitialConnect {
    my($self) = @_;
    my $address = $_[1];
    my $port = $_[2];
    my $options = $_[3];
    
    # make an initial socket connection
    # this will keep trying as it could be connecting to the proxy
    # which may not have an available application instance at that time
    my $attempts = 0;
    while(1)
    {
        my $ret = eval {
            if (validate::isIpv6($address) == 0) {
                # connect to IPv4 address (or a host name).
                my $protocol = getprotobyname('tcp');
                socket($self->{_socket}, Socket::AF_INET, Socket::SOCK_STREAM, $protocol);
                my $inetAddress = gethostbyname($address);
                my $sockAddress = Socket::sockaddr_in($port, $inetAddress);
                CORE::connect($self->{_socket}, $sockAddress);
            } else {
                if (!$checkDependencies::ipv6LoadError) {
                    require LWP::Protocol::INET6;
                    $self->{_socket} = LWP::Protocol::INET6->new(
                        PeerAddr => $address,
                        PeerPort => $port,
                        Proto    => 'tcp',
                    )
                    or die("Unknown Ipv6 address $address\n");
                } else {
                    die("Unable to load perl IPv6 module\n");
                }
            }
            1;
        };
        if (!$ret and $@) {
            if ((defined $self->{_proxySocket}) && $attempts < 120) {
                sleep(2);
                $attempts++;
            } else {
                $self->_Close();
                die "$@\n";
            }
        } else {
            last;
        }
    }
    
    ## a socket connection has been made now read the type of connection
    ## setup to timeout if the remote endpoint is not valid
    my $sock = $self->{_socket};
    $self->{_socket}->blocking(0);
    my $rin = '';
    vec($rin, fileno($sock), 1) = 1;
    my $timeout = 30;
    my $nfound = select(my $rout = $rin, undef, undef, $timeout);
    if ($nfound == 0)
    {
        $self->_Close();
        die "Connection handshake timed out after $timeout seconds\n";
    }
    $sock->blocking(1);
    my $ret = eval {
        my $connectString = $self->_Recv();
        if($connectString eq 'proxy') {
            $self->{_socket}->write($options);
            $self->{_socket}->flush();
            $self->{_connectTokens} = $self->_Recv();
            my %connectTokens = split(/ /, $self->{_connectTokens});
            $self->{_proxySocket} = $self->{_socket};
            $self->{_socket} = undef;
            $self->_InitialConnect($address, $connectTokens{-port}, '');
        }
        1;
    };
    if (!$ret and $@) {
        my $error = $@; 
        $self->_Close();
        die "$error";
    }
}

sub _Close {
    my($self) = @_;
    
    eval {
        if (defined $self->{_socket}) {
            close($self->{_socket});
            $self->{_socket} = undef;
        }
        if (defined $self->{_proxySocket}) {
            close($self->{_proxySocket});
            $self->{_proxySocket} = undef;
        }
        $self->{_port} = undef;
        $self->{_address} = undef;
        $self->{_sessionId} = undef;
        $self->{_serverusername} = undef;
    };
}

sub _Join {
    my($self) = @_;
    my @args = @_[1..scalar(@_) - 1];
    
    foreach my $arg (@args) {
        if (ref($arg) eq 'ARRAY') {
            if ($self->{_addContentSeparator} == 0) {
                $self->{_sendContent} .= chr(0x02);
            }