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

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

Path:root/var/www/html/wxwpsite/fungiftdeals/wp-admin/

Name	Size	Perm	Actions
📁 css	-	0755	🗑️ 🏷️
📁 images	-	0755	🗑️ 🏷️
📁 includes	-	0755	🗑️ 🏷️
📁 js	-	0755	🗑️ 🏷️
📁 maint	-	0755	🗑️ 🏷️
📁 network	-	0755	🗑️ 🏷️
📁 user	-	0755	🗑️ 🏷️
📄 about.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 admin-footer.php	2.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 admin.php	12.63 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 async-upload.php	5.47 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 authorize-application.php	10.09 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 comment.php	11.37 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 config.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 custom-header.php	0.49 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 customize.php	11.21 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 data.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 edit-form-blocks.php	14.73 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 edit.php	19.48 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 export-personal-data.php	7.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 font-library.php	1.01 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 home.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 index.php	7.68 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 media-upload.php	3.58 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 menu-header.php	9.82 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 network.php	5.39 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 press-this.php	2.41 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 privacy.php	2.83 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 setup-config.php	17.52 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 themes.phpwp-update.php	114.83 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 update.php	12.76 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 user-edit.php	40.35 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 widgets-form-blocks.php	5.12 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-mail.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 xmlrpc.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️

Edit: interface_plan9.go

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package net

import (
	"errors"
	"internal/itoa"
	"os"
)

// If the ifindex is zero, interfaceTable returns mappings of all
// network interfaces. Otherwise it returns a mapping of a specific
// interface.
func interfaceTable(ifindex int) ([]Interface, error) {
	if ifindex == 0 {
		n, err := interfaceCount()
		if err != nil {
			return nil, err
		}
		ifcs := make([]Interface, n)
		for i := range ifcs {
			ifc, err := readInterface(i)
			if err != nil {
				return nil, err
			}
			ifcs[i] = *ifc
		}
		return ifcs, nil
	}

ifc, err := readInterface(ifindex - 1)
	if err != nil {
		return nil, err
	}
	return []Interface{*ifc}, nil
}

func readInterface(i int) (*Interface, error) {
	ifc := &Interface{
		Index: i + 1,                             // Offset the index by one to suit the contract
		Name:  netdir + "/ipifc/" + itoa.Itoa(i), // Name is the full path to the interface path in plan9
	}

ifcstat := ifc.Name + "/status"
	ifcstatf, err := open(ifcstat)
	if err != nil {
		return nil, err
	}
	defer ifcstatf.close()

line, ok := ifcstatf.readLine()
	if !ok {
		return nil, errors.New("invalid interface status file: " + ifcstat)
	}

fields := getFields(line)
	if len(fields) < 4 {
		return nil, errors.New("invalid interface status file: " + ifcstat)
	}

device := fields[1]
	mtustr := fields[3]

mtu, _, ok := dtoi(mtustr)
	if !ok {
		return nil, errors.New("invalid status file of interface: " + ifcstat)
	}
	ifc.MTU = mtu

// Not a loopback device ("/dev/null") or packet interface (e.g. "pkt2")
	if stringsHasPrefix(device, netdir+"/") {
		deviceaddrf, err := open(device + "/addr")
		if err != nil {
			return nil, err
		}
		defer deviceaddrf.close()

line, ok = deviceaddrf.readLine()
		if !ok {
			return nil, errors.New("invalid address file for interface: " + device + "/addr")
		}

if len(line) > 0 && len(line)%2 == 0 {
			ifc.HardwareAddr = make([]byte, len(line)/2)
			var ok bool
			for i := range ifc.HardwareAddr {
				j := (i + 1) * 2
				ifc.HardwareAddr[i], ok = xtoi2(line[i*2:j], 0)
				if !ok {
					ifc.HardwareAddr = ifc.HardwareAddr[:i]
					break
				}
			}
		}

ifc.Flags = FlagUp | FlagRunning | FlagBroadcast | FlagMulticast
	} else {
		ifc.Flags = FlagUp | FlagRunning | FlagMulticast | FlagLoopback
	}

return ifc, nil
}

func interfaceCount() (int, error) {
	d, err := os.Open(netdir + "/ipifc")
	if err != nil {
		return -1, err
	}
	defer d.Close()

names, err := d.Readdirnames(0)
	if err != nil {
		return -1, err
	}

// Assumes that numbered files in ipifc are strictly
	// the incrementing numbered directories for the
	// interfaces
	c := 0
	for _, name := range names {
		if _, _, ok := dtoi(name); !ok {
			continue
		}
		c++
	}

return c, nil
}

// If the ifi is nil, interfaceAddrTable returns addresses for all
// network interfaces. Otherwise it returns addresses for a specific
// interface.
func interfaceAddrTable(ifi *Interface) ([]Addr, error) {
	var ifcs []Interface
	if ifi == nil {
		var err error
		ifcs, err = interfaceTable(0)
		if err != nil {
			return nil, err
		}
	} else {
		ifcs = []Interface{*ifi}
	}

var addrs []Addr
	for _, ifc := range ifcs {
		status := ifc.Name + "/status"
		statusf, err := open(status)
		if err != nil {
			return nil, err
		}
		defer statusf.close()

// Read but ignore first line as it only contains the table header.
		// See https://9p.io/magic/man2html/3/ip
		if _, ok := statusf.readLine(); !ok {
			return nil, errors.New("cannot read header line for interface: " + status)
		}

for line, ok := statusf.readLine(); ok; line, ok = statusf.readLine() {
			fields := getFields(line)
			if len(fields) < 1 {
				return nil, errors.New("cannot parse IP address for interface: " + status)
			}
			addr := fields[0]
			ip := ParseIP(addr)
			if ip == nil {
				return nil, errors.New("cannot parse IP address for interface: " + status)
			}

// The mask is represented as CIDR relative to the IPv6 address.
			// Plan 9 internal representation is always IPv6.
			maskfld := fields[1]
			maskfld = maskfld[1:]
			pfxlen, _, ok := dtoi(maskfld)
			if !ok {
				return nil, errors.New("cannot parse network mask for interface: " + status)
			}
			var mask IPMask
			if ip.To4() != nil { // IPv4 or IPv6 IPv4-mapped address
				mask = CIDRMask(pfxlen-8*len(v4InV6Prefix), 8*IPv4len)
			}
			if ip.To16() != nil && ip.To4() == nil { // IPv6 address
				mask = CIDRMask(pfxlen, 8*IPv6len)
			}

addrs = append(addrs, &IPNet{IP: ip, Mask: mask})
		}
	}

return addrs, nil
}

// interfaceMulticastAddrTable returns addresses for a specific
// interface.
func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error) {
	return nil, nil
}

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

Edit: interface_plan9.go

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