#main.pl
use strict;
use warnings;

my $s = { Local_IP=>"127.0.0.1", Local_Port => 5060 };

#passing the variable $s to the module p
P::sss($s);

#package
package P;
use strict;
my $s1;
sub sss
{
  $s1= shift;
  print $s1->{Local_IP}, "\n";#it works fine
}
#out of sub routine it is not accesssible.
print $s1->{Local_Port}, "\n";#it doesn't work
1;
[download]

127.0.0.1
5060
[download]

$Config = Config::Tiny->read( 'imp1.txt' );
[download]

Generally it is a better idea to pass variable content to functions in other packages via function arguments, and to methods by e.g. binding them as attributes to an object of the foreign package. Sharing variables between packages can (or will) lead to confusion and should not be undertaken lightly.

That said - you can declare a package global inside package P and set it from within the package main (default namespace):

package P;
use vars qw($f);
sub foo { print "$f\n" }

package main;
$P::f = "howdy, world";

P::foo();
__END__

output:
howdy, world
[download]

You can also share variables between packages assinging to typeglobs in the respective symbol table (see e.g. Of Symbol Tables and Globs):

package P;
use strict;
use vars qw($f);  # NOTE: *f is a shared typeglob
sub foo {
    print $f,"\n";
    $f = "world";
}

package main;
use strict;
use vars qw($f);  # NOTE: *f shared with package P

*P::f = *f;    # make P::f an alias of main::f

$f = "howdy";
P::foo();      # after this call, $f is changed!
print $f,"\n";
__END__
ouput:
howdy
world
[download]

You should use this approach only if you know well what you are doing, and state prominently in whatever file that uses a shared typeglob that it is doing so, and why you need it. The $main::f variable can be changed also in P assigning to $f, and it will be changed in main as well, which would give you some surprise if you aren't aware of it.

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

• Define $sl; lexically to the package. This is fine, though the variable has no value
• Attempt to print $l->{'Local_Port'}.

Well ... the code above is a bit messy (mixing OO methods with module subroutines, package P vs Config::P). To answer the question, you need to export the symbol $s1.

Scratch that ... I didn't see *inside* the module. It is visibile inside the module ... but your not coding it correctly.

Using just OO and not package subs, here's one way to do it:

use strict;
use warnings;

use Config::Tiny;
use MyConfig::P;

my $DATA;
open CONFIGFILE2, "imp1.txt" or die $!;

{
  local $/;
  $/ = undef;
  $DATA=<CONFIGFILE2>;
}
close CONFIGFILE2;

my $Config = Config::Tiny->new();
$Config = Config::Tiny->read_string( $DATA );
my $s = $Config->{_};

my $p = MyConfig::P->new( $s );
$p->sss();
$p->ppp();
[download]

package MyConfig::P;

sub new {
  my( $class, $val ) = @_;
  my $self = {};
  $self->{config} = $val;
  bless $self, $class;
}

sub sss {
  my $self = shift;
  print $self->{config}{Local_IP}, "\n";
}

sub ppp {
  my $self = shift;
  print $self->{config}{Local_Port}, "\n";
}

1;
[download]