Store : Webshell.Store

Linux lhcp3406.webapps.net 3.10.0-962.3.2.lve1.5.82.el7.x86_64 #1 SMP Tue Oct 31 10:15:24 UTC 2023 x86_64

Apache

81.88.53.156 | Your IP: 216.73.216.101

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / alt / python310 / lib64 / python3.10 / asyncio /

Home Upload Info Server

Server Info

Operating System	:	Linux lhcp3406.webapps.net 3.10.0-962.3.2.lve1.5.82.el7.x86_64 #1 SMP Tue Oct 31 10:15:24 UTC 2023 x86_64
User / Group	:	1190[c43ut3hs] / 1192[c43ut3hs]
PHP Version	:	5.6.40
IP Server	:	81.88.53.156
Your IP	:	216.73.216.101
Storage	:	Total = 1.05 TB, Free = 305.8 GB [28%]
Domains	:	Cant read [ /etc/named.conf ]
Software	:	Apache
Disable Functions	:	All function is accessible
Useful Functions	:	gcc, lcc, cc, ld, make, php, perl, python, ruby, tar, gzip, bzip, bzialfa2, nc, locate, suidperl, git, docker, ssh
Downloader	:	wget, fetch, lynx, links, curl, get, lwp-mirror
CURL : ON \| SSH2 : OFF \| Magic Quotes : ON \| MySQL : ON \| MSSQL : OFF \| PostgreSQL : OFF \| Oracle : OFF
Safe Mode : OFF \| Open Basedir : NONE \| Safe Mode Exec Dir : NONE \| Safe Mode Include Dir : NONE

subprocess.py

__all__ = 'create_subprocess_exec', 'create_subprocess_shell'

import subprocess

from . import events
from . import protocols
from . import streams
from . import tasks
from .log import logger

PIPE = subprocess.PIPE
STDOUT = subprocess.STDOUT
DEVNULL = subprocess.DEVNULL

class SubprocessStreamProtocol(streams.FlowControlMixin,
                               protocols.SubprocessProtocol):
    """Like StreamReaderProtocol, but for a subprocess."""

def __init__(self, limit, loop):
        super().__init__(loop=loop)
        self._limit = limit
        self.stdin = self.stdout = self.stderr = None
        self._transport = None
        self._process_exited = False
        self._pipe_fds = []
        self._stdin_closed = self._loop.create_future()

def __repr__(self):
        info = [self.__class__.__name__]
        if self.stdin is not None:
            info.append(f'stdin={self.stdin!r}')
        if self.stdout is not None:
            info.append(f'stdout={self.stdout!r}')
        if self.stderr is not None:
            info.append(f'stderr={self.stderr!r}')
        return '<{}>'.format(' '.join(info))

def connection_made(self, transport):
        self._transport = transport

stdout_transport = transport.get_pipe_transport(1)
        if stdout_transport is not None:
            self.stdout = streams.StreamReader(limit=self._limit,
                                               loop=self._loop)
            self.stdout.set_transport(stdout_transport)
            self._pipe_fds.append(1)

stderr_transport = transport.get_pipe_transport(2)
        if stderr_transport is not None:
            self.stderr = streams.StreamReader(limit=self._limit,
                                               loop=self._loop)
            self.stderr.set_transport(stderr_transport)
            self._pipe_fds.append(2)

stdin_transport = transport.get_pipe_transport(0)
        if stdin_transport is not None:
            self.stdin = streams.StreamWriter(stdin_transport,
                                              protocol=self,
                                              reader=None,
                                              loop=self._loop)

def pipe_data_received(self, fd, data):
        if fd == 1:
            reader = self.stdout
        elif fd == 2:
            reader = self.stderr
        else:
            reader = None
        if reader is not None:
            reader.feed_data(data)

def pipe_connection_lost(self, fd, exc):
        if fd == 0:
            pipe = self.stdin
            if pipe is not None:
                pipe.close()
            self.connection_lost(exc)
            if exc is None:
                self._stdin_closed.set_result(None)
            else:
                self._stdin_closed.set_exception(exc)
            return
        if fd == 1:
            reader = self.stdout
        elif fd == 2:
            reader = self.stderr
        else:
            reader = None
        if reader is not None:
            if exc is None:
                reader.feed_eof()
            else:
                reader.set_exception(exc)

if fd in self._pipe_fds:
            self._pipe_fds.remove(fd)
        self._maybe_close_transport()

def process_exited(self):
        self._process_exited = True
        self._maybe_close_transport()

def _maybe_close_transport(self):
        if len(self._pipe_fds) == 0 and self._process_exited:
            self._transport.close()
            self._transport = None

def _get_close_waiter(self, stream):
        if stream is self.stdin:
            return self._stdin_closed

class Process:
    def __init__(self, transport, protocol, loop):
        self._transport = transport
        self._protocol = protocol
        self._loop = loop
        self.stdin = protocol.stdin
        self.stdout = protocol.stdout
        self.stderr = protocol.stderr
        self.pid = transport.get_pid()

def __repr__(self):
        return f'<{self.__class__.__name__} {self.pid}>'

@property
    def returncode(self):
        return self._transport.get_returncode()

async def wait(self):
        """Wait until the process exit and return the process return code."""
        return await self._transport._wait()

def send_signal(self, signal):
        self._transport.send_signal(signal)

def terminate(self):
        self._transport.terminate()

def kill(self):
        self._transport.kill()

async def _feed_stdin(self, input):
        debug = self._loop.get_debug()
        self.stdin.write(input)
        if debug:
            logger.debug(
                '%r communicate: feed stdin (%s bytes)', self, len(input))
        try:
            await self.stdin.drain()
        except (BrokenPipeError, ConnectionResetError) as exc:
            # communicate() ignores BrokenPipeError and ConnectionResetError
            if debug:
                logger.debug('%r communicate: stdin got %r', self, exc)

if debug:
            logger.debug('%r communicate: close stdin', self)
        self.stdin.close()

async def _noop(self):
        return None

async def _read_stream(self, fd):
        transport = self._transport.get_pipe_transport(fd)
        if fd == 2:
            stream = self.stderr
        else:
            assert fd == 1
            stream = self.stdout
        if self._loop.get_debug():
            name = 'stdout' if fd == 1 else 'stderr'
            logger.debug('%r communicate: read %s', self, name)
        output = await stream.read()
        if self._loop.get_debug():
            name = 'stdout' if fd == 1 else 'stderr'
            logger.debug('%r communicate: close %s', self, name)
        transport.close()
        return output

async def communicate(self, input=None):
        if input is not None:
            stdin = self._feed_stdin(input)
        else:
            stdin = self._noop()
        if self.stdout is not None:
            stdout = self._read_stream(1)
        else:
            stdout = self._noop()
        if self.stderr is not None:
            stderr = self._read_stream(2)
        else:
            stderr = self._noop()
        stdin, stdout, stderr = await tasks.gather(stdin, stdout, stderr)
        await self.wait()
        return (stdout, stderr)

async def create_subprocess_shell(cmd, stdin=None, stdout=None, stderr=None,
                                  limit=streams._DEFAULT_LIMIT, **kwds):
    loop = events.get_running_loop()
    protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
                                                        loop=loop)
    transport, protocol = await loop.subprocess_shell(
        protocol_factory,
        cmd, stdin=stdin, stdout=stdout,
        stderr=stderr, **kwds)
    return Process(transport, protocol, loop)

async def create_subprocess_exec(program, *args, stdin=None, stdout=None,
                                 stderr=None, limit=streams._DEFAULT_LIMIT,
                                 **kwds):
    loop = events.get_running_loop()
    protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
                                                        loop=loop)
    transport, protocol = await loop.subprocess_exec(
        protocol_factory,
        program, *args,
        stdin=stdin, stdout=stdout,
        stderr=stderr, **kwds)
    return Process(transport, protocol, loop)

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/	drwxr-xr-x	2023-11-27 01:26:01
..	dir	-	root/	drwxr-xr-x	2023-11-27 01:26:03
__pycache__	dir	-	root/	drwxr-xr-x	2023-11-27 01:26:01
__init__.py	file	1.08 KB	root/	-rw-r--r--	2023-08-24 12:46:25
__main__.py	file	3.26 KB	root/	-rw-r--r--	2023-08-24 12:46:25
base_events.py	file	72.6 KB	root/	-rw-r--r--	2023-08-24 12:46:25
base_futures.py	file	2.51 KB	root/	-rw-r--r--	2023-08-24 12:46:25
base_subprocess.py	file	8.64 KB	root/	-rw-r--r--	2023-08-24 12:46:25
base_tasks.py	file	2.41 KB	root/	-rw-r--r--	2023-08-24 12:46:25
constants.py	file	888 B	root/	-rw-r--r--	2023-08-24 12:46:25
coroutines.py	file	8.59 KB	root/	-rw-r--r--	2023-08-24 12:46:25
events.py	file	26.71 KB	root/	-rw-r--r--	2023-08-24 12:46:25
exceptions.py	file	1.59 KB	root/	-rw-r--r--	2023-08-24 12:46:25
format_helpers.py	file	2.35 KB	root/	-rw-r--r--	2023-08-24 12:46:25
futures.py	file	13.85 KB	root/	-rw-r--r--	2023-08-24 12:46:25
locks.py	file	13.79 KB	root/	-rw-r--r--	2023-08-24 12:46:25
log.py	file	124 B	root/	-rw-r--r--	2023-08-24 12:46:25
mixins.py	file	803 B	root/	-rw-r--r--	2023-08-24 12:46:25
proactor_events.py	file	31.78 KB	root/	-rw-r--r--	2023-08-24 12:46:25
protocols.py	file	6.79 KB	root/	-rw-r--r--	2023-08-24 12:46:25
queues.py	file	7.85 KB	root/	-rw-r--r--	2023-08-24 12:46:25
runners.py	file	2.05 KB	root/	-rw-r--r--	2023-08-24 12:46:25
selector_events.py	file	38.77 KB	root/	-rw-r--r--	2023-08-24 12:46:25
sslproto.py	file	26.82 KB	root/	-rw-r--r--	2023-08-24 12:46:25
staggered.py	file	5.85 KB	root/	-rw-r--r--	2023-08-24 12:46:25
streams.py	file	25.15 KB	root/	-rw-r--r--	2023-08-24 12:46:25
subprocess.py	file	7.23 KB	root/	-rw-r--r--	2023-08-24 12:46:25
tasks.py	file	31.7 KB	root/	-rw-r--r--	2023-08-24 12:46:25
threads.py	file	790 B	root/	-rw-r--r--	2023-08-24 12:46:25
transports.py	file	10.47 KB	root/	-rw-r--r--	2023-08-24 12:46:25
trsock.py	file	5.74 KB	root/	-rw-r--r--	2023-08-24 12:46:25
unix_events.py	file	50.41 KB	root/	-rw-r--r--	2023-08-24 12:46:25
windows_events.py	file	32.61 KB	root/	-rw-r--r--	2023-08-24 12:46:25
windows_utils.py	file	4.94 KB	root/	-rw-r--r--	2023-08-24 12:46:25