小编Goo*_*ies的帖子

此代码在Linux上运行良好,但在Windows下失败(预期).我知道多处理模块用于fork()生成一个新进程,因此父进程拥有的文件描述符(即打开的套接字)由子进程继承.但是,我的理解是,您可以通过多处理发送的唯一类型的数据需要是可选择的.在Windows和Linux上,套接字对象不是pickleable.

from socket import socket, AF_INET, SOCK_STREAM
import multiprocessing as mp
import pickle

sock = socket(AF_INET, SOCK_STREAM)
sock.connect(("www.python.org", 80))
sock.sendall(b"GET / HTTP/1.1\r\nHost: www.python.org\r\n\r\n")

try:
    pickle.dumps(sock)
except TypeError:
    print("sock is not pickleable")

def foo(obj):
    print("Received: {}".format(type(obj)))
    data, done = [], False
    while not done:
        tmp = obj.recv(1024)
        done = len(tmp) < 1024
        data.append(tmp)
    data = b"".join(data)
    print(data.decode())


proc = mp.Process(target=foo, args=(sock,))
proc.start()
proc.join()

我的问题是为什么一个socket对象,一个明显不可拾取的对象,可以通过多处理传递？是不是像Windows那样使用泡菜？

我写了一个简单的ASM文件并在我编写的C文件中运行它.我得了一个太阳故障.但是,当我执行编译的ASM文件时,我没有得到任何错误.

我正在运行64位并使用32位shellcode.这是问题吗？

它不可能,因为我得到了一个分段错误:

char shellcode[] = "\x90"; //simple NOP in ASM
int main(int argc, char **argv)
{
  int (*ret)();
  ret = (int (*)()) shellcode;
  (int)(*ret)();
}

有人可以运行这个并告诉我他们是否会出现分段错误.我也使用了3或4个其他C文件.没有人工作过.

更新:

((void(*)(void))code)();

似乎代替这三条线.

我知道你不应该在程序中使用变量名，但我使用的是严格的调试目的，并希望将变量的名称传达给用户以提高可读性。

我有一个这样的文件：

class MyClass(object):
    def __init__(self):
        pass

    def foo(msg=""):
        debug("Called from the %s instance.") #quazi-print function that only prints when a DEBUG variable is True.
        print(msg)

m = MyClass()
m.foo("Test")

我想m从类本身中检索实例变量名称。虽然这只是一个示例文件，但我使用它向用户传达已在实例变量中的某个属性处创建了原始套接字，并希望显示它的位置（即New socket at m.socket）

这对 Python 可行吗？

我正在尝试使用aiohttp和使用多个凭据同时登录网站asyncio.在该create_tasks函数中,我生成了一个用于每个会话的会话列表.我不能在login函数中创建一个sesssion的原因是因为在整个代码中将使用相同的会话对象.我正在尝试做的是设计一种方法,我可以使用上下文管理器来处理会话的关闭(以避免运行时错误使其保持打开状态).

以下代码按预期工作(并发收集登录页面并在进程池中解析令牌),但它会与任务分开生成会话,并要求我在最后关闭它们.

from bs4 import BeautifulSoup
from concurrent.futures import ProcessPoolExecutor
import aiohttp
import asyncio

#TODO: make this safe, handle exceptions

LOGIN_URL = "http://example.com/login"
CLIENT_CNT = 10
proc_pool = ProcessPoolExecutor(CLIENT_CNT)

def get_key(text):
    soup = BeautifulSoup(text, "html.parser")
    form = soup.find("form")
    key = form.find("input", attrs={"type": "hidden", "name": "authenticityToken"})
    return key.get("value", None)

async def login(username:str, password:str, session:aiohttp.ClientSession, sem:asyncio.BoundedSemaphore, loop:asyncio.AbstractEventLoop=None):
    loop = loop or asyncio.get_event_loop()
    async with sem:
        async with session.get(LOGIN_URL) as resp:
            x = await asyncio.ensure_future(loop.run_in_executor(proc_pool, …

我的目标是使用__cdecl和__stdcall调用约定轻松提取任意函数的原型.它在32位工作正常.唯一改变的是模板函数参数中的调用约定.

根据维基百科的说法: "在Windows环境中编译x64架构时(无论是使用Microsoft还是非Microsoft工具),只有一个调用约定 - 这里描述的那个,所以stdcall,thiscall,cdecl,fastcall等. ,现在都是一样的."

这打破了64位的代码.即使调用约定相同,将函数作为参数传递仍然需要使用正确的命名法.IE如果函数定义为__stdcall,则必须将其传递给接受__stdcall的包装器.即使__cdecl相同,您仍然必须将定义为__cdecl的函数传递给接受__cdecl的包装器.

以32位工作的示例:

template<typename T, typename... Args>
struct WrapperSTD { typedef T(__stdcall *Functor)(Args...); };

template<typename T, typename... Args>
struct WrapperC { typedef T(*Functor)(Args...); };

template<typename T, typename... Args>
WrapperSTD<T, Args...> wrap(T(__stdcall *func)(Args...)) {
    return WrapperSTD<T, Args...>{};
}
template<typename T, typename... Args>
WrapperC<T, Args...> wrap(T(*func)(Args...)) {
    return WrapperC<T, Args...>{};
}

我的目标是能够运行,例如:

using MsgBoxProto = decltype(wrap(MessageBoxA))::Functor;

这适用于32位.但是,由于__stdcall和__cdecl在x64中显然是相同的,因此它不能在64位中工作并引发错误,表示调用是不明确的.它还告诉我模板已经定义.直观地说,似乎我能够将带有__cdecl的函数传递给这个__stdcall函数,因为编译器认为它们是相同的.但是,这不起作用:

template<typename T, typename... Args>
struct WrapperFC { typedef T(__stdcall *Functor)(Args...); };

template<typename T, typename... Args>
WrapperFC<T, Args...> wrap(T(__stdcall …

好吧，我写了一个生成 shell 的 ASM 文件。

但是，.text 部分变为“只读”，因此我将所有内容都保留在 .data 部分中。当我用 NASM 和 ld 编译它时，它工作得很好。然后，当我使用 shellcode 并在 C 程序中运行它时，我会出现错误。

ASM：

SECTION .data
        global _start
_start:
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        mov al, 70d
        int 80h
        jmp jump
rev:
        pop ebx
        xor eax, eax
        mov BYTE [ebx+7], al
        mov DWORD [ebx+8], ebx
        mov DWORD [ebx+12], eax
        mov al, 11d
        lea ecx, [ebx+8]
        lea edx, [ebx+12]
        int 80h
jump:
        call rev
shell: db "/bin/sh011112222"

当我编译它时：

nasm -f …

我在各种邮件列表和论坛上都看到人们不断提到Python 3中的print函数是线程安全的。通过我自己的测试，我没有理由对此表示怀疑。

import threading
import time
import random

def worker(letter):
    print(letter * 50)


threads = [threading.Thread(target=worker, args=(let,)) for let in "ABCDEFGHIJ"]
for t in threads:
    t.start()
for t in threads:
    t.join()

当我使用Python 3运行它时，即使某些行可能不正常，但它们仍然始终在自己的行上。但是，在Python 2中，输出是零星的。有些线连接在一起或缩进。当我也是如此from __future__ import print_function

• Python 2.7 builtin_print <-不是线程安全的
• Python 3.6 builtin_print <-线程安全吗？

我只是想了解为什么会这样？

我有一个当前使用 asyncio 编写的后端应用程序：用于 Web 服务器的 fastapi，用于异步数据库驱动程序的 sqlalchemy 1.4 + asyncpg。我需要将任务部署给将运行和更新主机应用程序的工作人员。目前我正在使用aio_pika，但想要更强大的东西，例如celerywith flower。

我知道 celery 没有与 asyncio 集成。我也读过这样的答案，我担心的是任务不是异步的，这是微不足道的。我担心从主事件循环内启动任务。

我的主要问题是my_task.delay()/是否完全my_task.apply_async()阻塞正在运行的线程？如果是这样，更好的方法是使用来自中央或 a的多处理工作人员，然后仅从该工作人员进程部署 celery 任务吗？getmp.QueueProcessPoolExecutor