/**
* Relational pipes
* Copyright © 2020 František Kučera (Frantovo.cz, GlobalCode.info)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <sstream>
#include <codecvt>
#include <locale>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
#include <ext/stdio_filebuf.h>
#include <algorithm>
#include "SubProcess.h"
using namespace relpipe::writer;
/**
* TODO: have a separate side process for forking new processes.
*/
class SubProcessImpl : public SubProcess {
private:
__pid_t subPid;
std::istream subOutputReader;
std::ostream subInputWriter;
__gnu_cxx::stdio_filebuf<char> subOutputReaderBuffer;
__gnu_cxx::stdio_filebuf<char> subInputWriterBuffer;
static const char SEPARATOR = '\0';
std::wstring_convert < std::codecvt_utf8<wchar_t>> convertor; // TODO: support also other encodings. Or use always UTF-8 for communication with subprocesses.
int readInt() {
return std::stoi(readString());
}
string_t readString() {
std::stringstream s;
for (char ch; subOutputReader.read(&ch, 1).good() && ch != SEPARATOR;) s.put(ch);
return convertor.from_bytes(s.str());
}
void write(string_t s) {
// if the value contains a null byte 0x00, it will be trimmed (passing 0x00 through would break the protocol)
subInputWriter << convertor.to_bytes(s).c_str();
subInputWriter.put(SEPARATOR);
if (subInputWriter.bad()) throw SubProcess::Exception(L"Unable to write to sub-process.");
}
void write(int i) {
write(std::to_wstring(i));
}
void flush() {
subInputWriter.flush();
}
public:
/**
* TODO: move to a common library (copied from the AWK module)
* @param args
*/
static void execp(const std::vector<std::string>& args) {
const char** a = new const char*[args.size() + 1];
for (size_t i = 0; i < args.size(); i++) a[i] = args[i].c_str();
a[args.size()] = nullptr;
execv(a[0], (char*const*) a);
delete[] a;
throw SubProcess::Exception(L"Unable to do execvp().");
}
/**
* TODO: move to a common library (copied from the AWK module)
* @param readerFD
* @param writerFD
*/
static void createPipe(int& readerFD, int& writerFD) {
int fds[2];
int result = pipe(fds);
readerFD = fds[0];
writerFD = fds[1];
if (result < 0) throw SubProcess::Exception(L"Unable to create a pipe.");
}
/**
* TODO: move to a common library (copied from the AWK module)
*/
static void redirectFD(int oldfd, int newfd) {
int result = dup2(oldfd, newfd);
if (result < 0) throw SubProcess::Exception(L"Unable redirect FD.");
}
/**
* TODO: move to a common library (copied from the AWK module)
*/
static void closeOrThrow(int fd) {
int error = close(fd);
if (error) throw SubProcess::Exception(L"Unable to close FD: " + std::to_wstring(fd) + L" from PID: " + std::to_wstring(getpid()));
}
static SubProcess* createSubProcess(std::vector<string_t> commandLine, std::map<string_t, string_t> environment, bool dropErrorOutput) {
int subInputReaderFD;
int subInputWriterFD;
int subOutputReaderFD;
int subOutputWriterFD;
createPipe(subInputReaderFD, subInputWriterFD);
createPipe(subOutputReaderFD, subOutputWriterFD);
__pid_t subPid = fork();
if (subPid < 0) {
throw SubProcess::Exception(L"Unable to fork the hash process.");
} else if (subPid == 0) {
// Child process
redirectFD(subInputReaderFD, STDIN_FILENO);
redirectFD(subOutputWriterFD, STDOUT_FILENO);
closeOrThrow(subInputWriterFD);
closeOrThrow(subOutputReaderFD);
if (dropErrorOutput) redirectFD(open("/dev/null", O_RDWR), STDERR_FILENO);
std::wstring_convert < std::codecvt_utf8<wchar_t>> convertor; // TODO: support also other encodings. Or use always UTF-8 for communication with subprocesses.
for (auto const & entry : environment) setenv(convertor.to_bytes(entry.first).c_str(), convertor.to_bytes(entry.second).c_str(), true);
std::vector<std::string> commandLineRaw;
for (string_t s : commandLine) commandLineRaw.push_back(convertor.to_bytes(s));
execp(commandLineRaw);
throw SubProcess::Exception(L"Unexpected exception after execp(commandLineRaw)"); // will never happen, look inside the method above (throws exception)
} else {
// Parent process
closeOrThrow(subInputReaderFD);
closeOrThrow(subOutputWriterFD);
fcntl(subInputWriterFD, F_SETFD, FD_CLOEXEC);
fcntl(subOutputReaderFD, F_SETFD, FD_CLOEXEC);
return new SubProcessImpl(subPid, subInputWriterFD, subOutputReaderFD);
}
}
SubProcessImpl(__pid_t subPid, int subInputWriterFD, int subOutputReaderFD) :
subPid(subPid),
subOutputReaderBuffer(__gnu_cxx::stdio_filebuf<char>(subOutputReaderFD, std::ios::in)),
subInputWriterBuffer(__gnu_cxx::stdio_filebuf<char>(subInputWriterFD, std::ios::out)),
subOutputReader(&subOutputReaderBuffer),
subInputWriter(&subInputWriterBuffer) {
}
virtual ~SubProcessImpl() {
}
SubProcess::Message read() {
Message m;
m.code = readInt();
int count = readInt();
for (int i = 0; i < count; i++) m.parameters.push_back(readString());
return m;
}
void write(Message m) {
write(m.code);
write(m.parameters.size());
for (auto p : m.parameters) write(p);
flush();
}
int wait() {
closeOrThrow(subInputWriterBuffer.fd());
closeOrThrow(subOutputReaderBuffer.fd());
int status = -1;
::waitpid(subPid, &status, 0);
return status;
}
};
SubProcess* SubProcess::create(std::vector<string_t> commandLine, std::map<string_t, string_t> environment, bool dropErrorOutput) {
return SubProcessImpl::createSubProcess(commandLine, environment, dropErrorOutput);
}