Можно ли перенапривить ввод/вывод запущенного процесса в linux socket в реальном времени?

Question

[Андрей Евдокимов]

Можно ли перенаправить ввод/вывод запущенного процесса в socket. Linux, С, СPP.
То есть программно запустить процесс и управлять им через сокет удаленно в реальном времени, а не получить результат выполнения?

Comments

[Александр]

А как, по вашему мнению, работает ssh?

[Андрей Евдокимов]

К сожалению, сейчас нет времени углубляться, есть задача. SSH привел как пример инетерактивной программы, вывод которой не заканчивается выполнением.

[abmanimenja]

в реальном времени

Это означает не то, что вы имеете ввиду.

Answer 1

[Дмитрий Александров]

Есть замечательная утилитка nc которая это сделает в любом виде.
Как то прошляпил что сокеты, есть еще socat

Comments

[Андрей Евдокимов]

Встречал упоминания по запросам. Хочется открыть порт на сервере, подключиться клиентом и управлять им, что-то вроде обратного ssh простыми запросами. Ну должно же быть решение или хотя бы наброски куда копать.

Answer 2

[Vitsliputsli]

man unix, там даже примеры исходников есть

Comments

[Андрей Евдокимов]

А можно чуть чуть подробнее? Что такое man я знаю.

[Vitsliputsli]

Наберитие "man unix", там в конце пример клиент-серверного приложения общающихся по unix-сокету. Весь man нельзя выложить, но вот пример:

spoiler

EXAMPLE
The following code demonstrates the use of sequenced-packet sockets for local interpro‐
cess communication. It consists of two programs. The server program waits for a connec‐
tion from the client program. The client sends each of its command-line arguments in
separate messages. The server treats the incoming messages as integers and adds them up.
The client sends the command string "END". The server sends back a message containing
the sum of the client's integers. The client prints the sum and exits. The server waits
for the next client to connect. To stop the server, the client is called with the com‐
mand-line argument "DOWN".

The following output was recorded while running the server in the background and repeat‐
edly executing the client. Execution of the server program ends when it receives the
"DOWN" command.

Example output
$ ./server &
[1] 25887
$ ./client 3 4
Result = 7
$ ./client 11 -5
Result = 6
$ ./client DOWN
Result = 0
[1]+ Done ./server
$

Program source

/*
* File connection.h
*/

#define SOCKET_NAME "/tmp/9Lq7BNBnBycd6nxy.socket"
#define BUFFER_SIZE 12

/*
* File server.c
*/

#include
#include
#include
#include
#include
#include
#include "connection.h"

int
main(int argc, char *argv[])
{
struct sockaddr_un name;
int down_flag = 0;
int ret;
int connection_socket;
int data_socket;
int result;
char buffer[BUFFER_SIZE];

/*
* In case the program exited inadvertently on the last run,
* remove the socket.
*/

unlink(SOCKET_NAME);

/* Create local socket. */

connection_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
if (connection_socket == -1) {
perror("socket");
exit(EXIT_FAILURE);
}

/*
* For portability clear the whole structure, since some
* implementations have additional (nonstandard) fields in
* the structure.
*/

memset(&name, 0, sizeof(struct sockaddr_un));

/* Bind socket to socket name. */

name.sun_family = AF_UNIX;
strncpy(name.sun_path, SOCKET_NAME, sizeof(name.sun_path) - 1);

ret = bind(connection_socket, (const struct sockaddr *) &name,
sizeof(struct sockaddr_un));
if (ret == -1) {
perror("bind");
exit(EXIT_FAILURE);
}

/*
* Prepare for accepting connections. The backlog size is set
* to 20. So while one request is being processed other requests
* can be waiting.
*/

ret = listen(connection_socket, 20);
if (ret == -1) {
perror("listen");
exit(EXIT_FAILURE);
}

/* This is the main loop for handling connections. */

for (;;) {

/* Wait for incoming connection. */

data_socket = accept(connection_socket, NULL, NULL);
if (data_socket == -1) {
perror("accept");
exit(EXIT_FAILURE);
}

result = 0;
for (;;) {

/* Wait for next data packet. */

ret = read(data_socket, buffer, BUFFER_SIZE);
if (ret == -1) {
perror("read");
exit(EXIT_FAILURE);
}

/* Ensure buffer is 0-terminated. */

buffer[BUFFER_SIZE - 1] = 0;

/* Handle commands. */

if (!strncmp(buffer, "DOWN", BUFFER_SIZE)) {
down_flag = 1;
break;
}

if (!strncmp(buffer, "END", BUFFER_SIZE)) {
break;
}

/* Add received summand. */

result += atoi(buffer);
}

/* Send result. */

sprintf(buffer, "%d", result);
ret = write(data_socket, buffer, BUFFER_SIZE);
if (ret == -1) {
perror("write");
exit(EXIT_FAILURE);
}

/* Close socket. */

close(data_socket);

/* Quit on DOWN command. */

if (down_flag) {
break;
}
}

close(connection_socket);

/* Unlink the socket. */

unlink(SOCKET_NAME);

exit(EXIT_SUCCESS);
}

/*
* File client.c
*/

#include
#include
#include
#include
#include
#include
#include
#include "connection.h"

int
main(int argc, char *argv[])
{
struct sockaddr_un addr;
int i;
int ret;
int data_socket;
char buffer[BUFFER_SIZE];

/* Create local socket. */

data_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
if (data_socket == -1) {
perror("socket");
exit(EXIT_FAILURE);
}

/*
* For portability clear the whole structure, since some
* implementations have additional (nonstandard) fields in
* the structure.
*/

memset(&addr, 0, sizeof(struct sockaddr_un));

/* Connect socket to socket address */

addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, SOCKET_NAME, sizeof(addr.sun_path) - 1);

ret = connect (data_socket, (const struct sockaddr *) &addr,
sizeof(struct sockaddr_un));
if (ret == -1) {
fprintf(stderr, "The server is down.\n");
exit(EXIT_FAILURE);
}

/* Send arguments. */

for (i = 1; i < argc; ++i) {
ret = write(data_socket, argv[i], strlen(argv[i]) + 1);
if (ret == -1) {
perror("write");
break;
}
}

/* Request result. */

strcpy (buffer, "END");
ret = write(data_socket, buffer, strlen(buffer) + 1);
if (ret == -1) {
perror("write");
exit(EXIT_FAILURE);
}

/* Receive result. */

ret = read(data_socket, buffer, BUFFER_SIZE);
if (ret == -1) {
perror("read");
exit(EXIT_FAILURE);
}

/* Ensure buffer is 0-terminated. */

buffer[BUFFER_SIZE - 1] = 0;

printf("Result = %s\n", buffer);

/* Close socket. */

close(data_socket);

exit(EXIT_SUCCESS);
}

For an example of the use of SCM_RIGHTS see cmsg(3).

SEE ALSO
recvmsg(2), sendmsg(2), socket(2), socketpair(2), cmsg(3), capabilities(7), creden‐
tials(7), socket(7), udp(7)

COLOPHON
This page is part of release 5.00 of the Linux man-pages project. A description of the
project, information about reporting bugs, and the latest version of this page, can be
found at https://www.kernel.org/doc/man-pages/.

Linux 2018-04-30 UNIX(7)

[Philipp]

Vitsliputsli, можно было просто привести ссылку man7.org/linux/man-pages/man7/unix.7.html

[Андрей Евдокимов]

Задача в теме была описана. Запустить интерактивный (не завершающийся сразу, требующий ввода от пользователя) процесс, и управлять вводом-выводом через сокет.

[Vitsliputsli]

Philipp, привел - "man unix", даже без инета работает.

[Vitsliputsli]

Андрей Евдокимов,

Задача в теме была описана. Запустить интерактивный (не завершающийся сразу, требующий ввода от пользователя) процесс, и управлять вводом-выводом через сокет.

В смысле? Что-то не получается? Или что?

[Андрей Евдокимов]

Попробую объяснить по другому. Нашел рабочий пример перенаправления ввода-вывода в сокет. При подключении клиента, "ls" выполнится, результат будет отправлен клиенту. Задача же в другом, можно ли до завершения процесса (если раскомментировать блок с тем же man unix внизу), передать управление так, чтобы можно было получить вывод man и отправить через сокет "q", для выхода из man?

for (;;) 
	{  /* loop, accepting connections */
		if ( (csock = accept( serverSockfd, NULL, NULL )) == -1)
		  exit(1);
	  cpid = fork();
	  if (cpid < 0) exit(1);  /* exit if fork() fails */
	  if ( cpid )
	  {
		/* In the parent process: */
		close( csock ); /* csock is not needed in the parent after the fork */
		waitpid( cpid, NULL, 0 ); /* wait for and reap child process */
	  }
	  else
	  {
		/* In the child process: */
		printf("execvp\n");
		dup2( csock, STDOUT_FILENO );  /* duplicate socket on stdout */
		dup2( csock, STDERR_FILENO );  /* duplicate socket on stderr too */
		close( csock );  /* can close the original after it's duplicated */
		char   *cmd = "/usr/bin/man";
		char   *cmdArgs[] = { "man",
							   "unix",
							   NULL }; //note: last item is NULL
		/*
		char   *cmd = "ls";
		char   *cmdArgs[] = { "ls",
							   "/home/user",
							   NULL }; //note: last item is NULL
		*/
		execvp( cmd, cmdArgs );   /* execvp() the command */
	  }
	}