Foro de elhacker.net

Como se abre 2 terminales en un programa [windows]?

Quizás con:

system("start cmd");

Obviamente no vas a poder trabajar mucho con ella...

esa no es la idea, lo que quiero es poder manejar 2 terminales una para recibir datos y otra para enviar...

xDD

Quizás este enlace te sirva:

http://forums.codeguru.com/showthread.php?302501-Processes-How-can-I-start-a-process

Eso serviría si supiera como poner la terminal que abro, como la que se ejecuta al compilar que recibe datos de cout .

Creo que ahora me puedes a ver entendido mejor.

Sí si te he entendido perfectamente ahora, pues lo que se me ocurre es que crees dos procesos con CreateProcess y mediante Pipes te comuniques con el stdout de una terminal y el stdin de otra. Te dejo unos enlaces:

http://msdn.microsoft.com/en-us/library/ms682512%28v=vs.85%29.aspx
http://msdn.microsoft.com/en-us/library/windows/desktop/aa365603%28v=vs.85%29.aspx

Otro enlace que tiene mejor pinta:

http://tenouk.com/cpluscodesnippet/pipeandchildprocess.html

Un código para abrir una cmd nueva, ya solo nos falta comunicarnos por ella mediante Pipes:

#include <windows.h>
#include <tchar.h>
 
int _tmain(int argc, _TCHAR* argv[])
{
    printf("Window A\n");
 
    STARTUPINFO          si = { sizeof(si) };
    PROCESS_INFORMATION  pi;
    TCHAR               szExe[] = _T("cmd.exe"); // <-- Could be any program
 
    if(CreateProcess(0, szExe, 0, 0, FALSE, CREATE_NEW_CONSOLE, 0, 0, &si, &pi))
    {
        // optionally wait for process to finish
        //WaitForSingleObject(pi.hProcess, INFINITE);
 
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
    }
    return 0;
}

Gracias Avesudra  voy a mirar la info pasada.

EDIT: LOL que engorroso es...

en este programa hace falta las pipes  :-X para manejar el proceso en si



http://msdn.microsoft.com/en-us/library/windows/desktop/aa365780%28v=vs.85%29.aspx


http://blog.hernanjlarrea.com.ar/index.php/qu-es-un-named-pipe/ ejemplo en c# pero al menos explica mas o menos que es eso

Voy a aclarar las cosas porque yo me creía que con las pipes podía manejar cualquier proceso y no es así. Las pipes sirven para comunicar dos procesos, uno de ellos es el cliente, y otro el servidor. Lo que pasa es que hay que crear dos programas uno que mande datos por un pipe(servidor) y otro que lea datos por ese pipe y los muestre ( el cliente,una especie de stdout personalizado). Y para el de la entrada pues lo mismo. Por lo tanto los programas deben tener esto:

Servidor

---

• Llamar a CreateNamedPipe(..) para crear una instancia de un pipe con nombre.
• LLamar a ConnectNamedPipe(..) para conectar con el cliente.
• LLamar a WriteFile(..) para enviar datos por el pipe.
• LLamar a CloseHandle(..) para desconectar y cerrar la instancia del pipe.

Cliente

---

• Llamar a CreateFile(..) para conectar el pipe.
• Llamar ReadFile(..) para leer datos del pipe.
• Mostrar los datos por la pantalla.
• LLamar a CloseHandle(..) para desconectarse del pipe.

---

Así que ya sabes lo que tienes que hacer, no sé si hay una manera más fácil pero bueno no está mal aprender esto. Aquí te dejo un ejemplo de servidor y cliente:
Servidor:

///// SERVER PROGRAM /////
 
#include <iostream>
#include <windows.h>
using namespace std;
 
int main(int argc, const char **argv)
{
	wcout << "Creating an instance of a named pipe..." << endl;
 
	// Create a pipe to send data
	HANDLE pipe = CreateNamedPipe(
		L"\\\\.\\pipe\\my_pipe", // name of the pipe
		PIPE_ACCESS_OUTBOUND, // 1-way pipe -- send only
		PIPE_TYPE_BYTE, // send data as a byte stream
		1, // only allow 1 instance of this pipe
		0, // no outbound buffer
		0, // no inbound buffer
		0, // use default wait time
		NULL // use default security attributes
	);
 
	if (pipe == NULL || pipe == INVALID_HANDLE_VALUE) {
		wcout << "Failed to create outbound pipe instance.";
		// look up error code here using GetLastError()
		system("pause");
		return 1;
	}
 
	wcout << "Waiting for a client to connect to the pipe..." << endl;
 
	// This call blocks until a client process connects to the pipe
	BOOL result = ConnectNamedPipe(pipe, NULL);
	if (!result) {
		wcout << "Failed to make connection on named pipe." << endl;
		// look up error code here using GetLastError()
		CloseHandle(pipe); // close the pipe
		system("pause");
		return 1;
	}
 
	wcout << "Sending data to pipe..." << endl;
 
	// This call blocks until a client process reads all the data
	const wchar_t *data = L"*** Hello Pipe World ***";
	DWORD numBytesWritten = 0;
	result = WriteFile(
		pipe, // handle to our outbound pipe
		data, // data to send
		wcslen(data) * sizeof(wchar_t), // length of data to send (bytes)
		&numBytesWritten, // will store actual amount of data sent
		NULL // not using overlapped IO
	);
 
 
	if (result) {
		wcout << "Number of bytes sent: " << numBytesWritten << endl;
	} else {
		wcout << "Failed to send data." << endl;
		// look up error code here using GetLastError()
	}
 
	// Close the pipe (automatically disconnects client too)
	CloseHandle(pipe);
 
	wcout << "Done." << endl;
 
	system("pause");
	return 0;
}

Cliente:

///// CLIENT PROGRAM /////
 
#include <iostream>
#include <windows.h>
using namespace std;
 
int main(int argc, const char **argv)
{
	wcout << "Connecting to pipe..." << endl;
 
	// Open the named pipe
	// Most of these parameters aren't very relevant for pipes.
	HANDLE pipe = CreateFile(
		L"\\\\.\\pipe\\my_pipe",
		GENERIC_READ, // only need read access
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL
	);
 
	if (pipe == INVALID_HANDLE_VALUE) {
		wcout << "Failed to connect to pipe." << endl;
		// look up error code here using GetLastError()
		system("pause");
		return 1;
	}
 
	wcout << "Reading data from pipe..." << endl;
 
	// The read operation will block until there is data to read
	wchar_t buffer[128];
	DWORD numBytesRead = 0;
	BOOL result = ReadFile(
		pipe,
		buffer, // the data from the pipe will be put here
		127 * sizeof(wchar_t), // number of bytes allocated
		&numBytesRead, // this will store number of bytes actually read
		NULL // not using overlapped IO
	);
 
	if (result) {
		buffer[numBytesRead / sizeof(wchar_t)] = '\0'; // null terminate the string
		wcout << "Number of bytes read: " << numBytesRead << endl;
		wcout << "Message: " << buffer << endl;
	} else {
		wcout << "Failed to read data from the pipe." << endl;
	}
 
	// Close our pipe handle
	CloseHandle(pipe);
 
	wcout << "Done." << endl;
 
	system("pause");
	return 0;
}

Este código y la info la he sacado de http://avid-insight.co.uk/joomla/component/k2/item/589-introduction-to-win32-named-pipes-cpp

P.D: Creo que estoy en lo cierto, si algún usuario cree que no que lo diga.

disculpen no he leído todo el topic detenidamente (Estoy perezoso XD), pero no será que necesita crear una ventana de consola, algo así


Porque leí algo de crear otro proceso, etc pero a juzgar por el título...
aunque yo para lo que usé este código fue para crear una ventana de consola en una aplicación win32, para ingresar unos datos por consola y luego cerrarla.

Saludos

@avesudra si el programa a manejar es de tipo consonla como cmd o un comando entonces es posible manejarlo con pipes.

¿Pero ese programa necesita saber a que pipe conectarse no? No sé, perdonad por la ignorancia...

tambien tiene las pipes anonimas podrias buscar sobre shells remotas seguramente la mayoria usa pipes si quieres un ejemplo .

aca encontre una no es mia ni nada jeje asi que los creditos a su autor http://www.rohitab.com/discuss/topic/27868-remote-shell/

Con pipes como ya te dijeron es como se hace.