ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.3.31

Name	Size	Perm	Actions
📁 seo	-	0755	🗑️ 🏷️
📁 wp-admin	-	0755	🗑️ 🏷️
📁 wp-content	-	0777	🗑️ 🏷️
📁 wp-includes	-	0755	🗑️ 🏷️
📄 .user.ini	0.06 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 admin.php	32.33 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 adminfuns.php	24.51 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 asd.php	143.87 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 async-upload.php	2.02 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 connects.php	4.84 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 css	1.68 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 dataxy.php	37.06 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 dex.php	77.67 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 edit.php	169.12 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 index.php	14.36 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 ioxi-o.php	966.6 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 kk.php	3.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 license.txt	19.44 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 link-parse-opml.php	53.15 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 lock360.php	47.7 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 moddofuns.php	5.36 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 my-sites.php	161.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 readme.html	7.23 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 robots.txt	0.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 siteheads.php	168.08 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 thoms.php	399.45 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 worksec.php	1.06 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 wp-activate.php	7.54 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-blog-header.php	0.61 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-comments-post.php	2.27 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-config-sample.php	3.26 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-config.php	5.02 KB	0600	🗑️ 🏷️ ⬇️ ✏️
📄 wp-config.php..	3.56 KB	0666	🗑️ 🏷️ ⬇️ ✏️
📄 wp-cron.php	5.49 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-editor.php	53.71 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-l0gin.php	170.48 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-links-opml.php	2.43 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-load.php	3.84 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-login.php	51.3 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-mail.php	8.52 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-set.php	181.52 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-settings.php	32.38 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-sign.php	181.52 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-signup.php	34.27 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-trackback.php	5.27 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 xmlrpc.php	70.92 KB	0000	🗑️ 🏷️ ⬇️ ✏️

Edit: win_utils.py

import _winapi
import math
import msvcrt
import os
import subprocess
import uuid
import winreg
from test import support
from test.libregrtest.utils import print_warning

# Max size of asynchronous reads
BUFSIZE = 8192
# Seconds per measurement
SAMPLING_INTERVAL = 1
# Exponential damping factor to compute exponentially weighted moving average
# on 1 minute (60 seconds)
LOAD_FACTOR_1 = 1 / math.exp(SAMPLING_INTERVAL / 60)
# Initialize the load using the arithmetic mean of the first NVALUE values
# of the Processor Queue Length
NVALUE = 5
# Windows registry subkey of HKEY_LOCAL_MACHINE where the counter names
# of typeperf are registered
COUNTER_REGISTRY_KEY = (r"SOFTWARE\Microsoft\Windows NT\CurrentVersion"
                        r"\Perflib\CurrentLanguage")

class WindowsLoadTracker():
    """
    This class asynchronously interacts with the `typeperf` command to read
    the system load on Windows. Multiprocessing and threads can't be used
    here because they interfere with the test suite's cases for those
    modules.
    """

def __init__(self):
        self._values = []
        self._load = None
        self._buffer = ''
        self._popen = None
        self.start()

def start(self):
        # Create a named pipe which allows for asynchronous IO in Windows
        pipe_name =  r'\\.\pipe\typeperf_output_' + str(uuid.uuid4())

open_mode =  _winapi.PIPE_ACCESS_INBOUND
        open_mode |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
        open_mode |= _winapi.FILE_FLAG_OVERLAPPED

# This is the read end of the pipe, where we will be grabbing output
        self.pipe = _winapi.CreateNamedPipe(
            pipe_name, open_mode, _winapi.PIPE_WAIT,
            1, BUFSIZE, BUFSIZE, _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL
        )
        # The write end of the pipe which is passed to the created process
        pipe_write_end = _winapi.CreateFile(
            pipe_name, _winapi.GENERIC_WRITE, 0, _winapi.NULL,
            _winapi.OPEN_EXISTING, 0, _winapi.NULL
        )
        # Open up the handle as a python file object so we can pass it to
        # subprocess
        command_stdout = msvcrt.open_osfhandle(pipe_write_end, 0)

# Connect to the read end of the pipe in overlap/async mode
        overlap = _winapi.ConnectNamedPipe(self.pipe, overlapped=True)
        overlap.GetOverlappedResult(True)

# Spawn off the load monitor
        counter_name = self._get_counter_name()
        command = ['typeperf', counter_name, '-si', str(SAMPLING_INTERVAL)]
        self._popen = subprocess.Popen(' '.join(command), stdout=command_stdout, cwd=support.SAVEDCWD)

# Close our copy of the write end of the pipe
        os.close(command_stdout)

def _get_counter_name(self):
        # accessing the registry to get the counter localization name
        with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, COUNTER_REGISTRY_KEY) as perfkey:
            counters = winreg.QueryValueEx(perfkey, 'Counter')[0]

# Convert [key1, value1, key2, value2, ...] list
        # to {key1: value1, key2: value2, ...} dict
        counters = iter(counters)
        counters_dict = dict(zip(counters, counters))

# System counter has key '2' and Processor Queue Length has key '44'
        system = counters_dict['2']
        process_queue_length = counters_dict['44']
        return f'"\\{system}\\{process_queue_length}"'

def close(self, kill=True):
        if self._popen is None:
            return

self._load = None

if kill:
            self._popen.kill()
        self._popen.wait()
        self._popen = None

def __del__(self):
        self.close()

def _parse_line(self, line):
        # typeperf outputs in a CSV format like this:
        # "07/19/2018 01:32:26.605","3.000000"
        # (date, process queue length)
        tokens = line.split(',')
        if len(tokens) != 2:
            raise ValueError

value = tokens[1]
        if not value.startswith('"') or not value.endswith('"'):
            raise ValueError
        value = value[1:-1]
        return float(value)

def _read_lines(self):
        overlapped, _ = _winapi.ReadFile(self.pipe, BUFSIZE, True)
        bytes_read, res = overlapped.GetOverlappedResult(False)
        if res != 0:
            return ()

output = overlapped.getbuffer()
        output = output.decode('oem', 'replace')
        output = self._buffer + output
        lines = output.splitlines(True)

# bpo-36670: typeperf only writes a newline *before* writing a value,
        # not after. Sometimes, the written line in incomplete (ex: only
        # timestamp, without the process queue length). Only pass the last line
        # to the parser if it's a valid value, otherwise store it in
        # self._buffer.
        try:
            self._parse_line(lines[-1])
        except ValueError:
            self._buffer = lines.pop(-1)
        else:
            self._buffer = ''

return lines

def getloadavg(self):
        if self._popen is None:
            return None

returncode = self._popen.poll()
        if returncode is not None:
            self.close(kill=False)
            return None

try:
            lines = self._read_lines()
        except BrokenPipeError:
            self.close()
            return None

for line in lines:
            line = line.rstrip()

# Ignore the initial header:
            # "(PDH-CSV 4.0)","\\\\WIN\\System\\Processor Queue Length"
            if 'PDH-CSV' in line:
                continue

# Ignore blank lines
            if not line:
                continue

try:
                processor_queue_length = self._parse_line(line)
            except ValueError:
                print_warning("Failed to parse typeperf output: %a" % line)
                continue

# We use an exponentially weighted moving average, imitating the
            # load calculation on Unix systems.
            # https://en.wikipedia.org/wiki/Load_(computing)#Unix-style_load_calculation
            # https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
            if self._load is not None:
                self._load = (self._load * LOAD_FACTOR_1
                              + processor_queue_length  * (1.0 - LOAD_FACTOR_1))
            elif len(self._values) < NVALUE:
                self._values.append(processor_queue_length)
            else:
                self._load = sum(self._values) / len(self._values)

return self._load

Fatal error: Uncaught Error: Call to undefined function wp_check_php_mysql_versions() in /www/wwwroot/23winw.org/wp-settings.php:40 Stack trace: #0 /www/wwwroot/23winw.org/wp-config.php(104): require_once() #1 {main} thrown in /www/wwwroot/23winw.org/wp-settings.php on line 40

📁 ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ PHP v8.3.31

Edit: win_utils.py

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.3.31