Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

child.cpp 40KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632
  1. // \file child.cpp
  2. //
  3. // Copyright (C) 2014 MicroNeil Research Corporation.
  4. //
  5. // This program is part of the MicroNeil Research Open Library Project. For
  6. // more information go to http://www.microneil.com/OpenLibrary/index.html
  7. //
  8. // This program is free software; you can redistribute it and/or modify it
  9. // under the terms of the GNU General Public License as published by the
  10. // Free Software Foundation; either version 2 of the License, or (at your
  11. // option) any later version.
  12. //
  13. // This program is distributed in the hope that it will be useful, but WITHOUT
  14. // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  16. // more details.
  17. //
  18. // You should have received a copy of the GNU General Public License along with
  19. // this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  20. // Place, Suite 330, Boston, MA 02111-1307 USA
  21. //==============================================================================
  22. #ifndef _WIN32
  23. #include <unistd.h>
  24. #include <sys/types.h>
  25. #include <sys/wait.h>
  26. #include <signal.h>
  27. #include <sys/select.h>
  28. #include <cstring>
  29. #include <cerrno>
  30. #endif
  31. #include <stdexcept>
  32. #include <utility>
  33. #include "CodeDweller/timing.hpp"
  34. #include "CodeDweller/child.hpp"
  35. namespace CodeDweller {
  36. ChildStream::ChildStream(std::vector<std::string> const &args,
  37. size_t bufSize) :
  38. std::iostream(&childStreambuf),
  39. childStreambuf(bufSize),
  40. cmdArgs(args) {
  41. init();
  42. run();
  43. }
  44. ChildStream::ChildStream(std::string const &childpath, size_t bufSize) :
  45. std::iostream(&childStreambuf),
  46. childStreambuf(bufSize) {
  47. cmdArgs.push_back(childpath);
  48. init();
  49. run();
  50. }
  51. ChildStream::ChildStream(size_t bufSize) :
  52. std::iostream(&childStreambuf),
  53. childStreambuf(bufSize) {
  54. init();
  55. }
  56. ChildStream::~ChildStream() {
  57. try {
  58. close();
  59. } catch (std::exception &e) {
  60. ;
  61. }
  62. }
  63. void ChildStream::init() {
  64. childStarted = false;
  65. childExited = false;
  66. exitCodeObtainedFlag = false;
  67. exitCode = 0;
  68. }
  69. void ChildStream::open(std::vector<std::string> const &args) {
  70. cmdArgs = args;
  71. init();
  72. run();
  73. }
  74. void ChildStream::open(std::string const &childpath) {
  75. cmdArgs.clear();
  76. cmdArgs.push_back(childpath);
  77. init();
  78. run();
  79. }
  80. size_t ChildStream::numBytesAvailable() const {
  81. return childStreambuf.numBytesAvailable();
  82. }
  83. bool ChildStream::isRunning() const {
  84. return childStarted && !childExited;
  85. }
  86. void ChildStream::run() {
  87. if (childStarted) {
  88. throw std::logic_error("Child process was active when "
  89. "run() was called");
  90. }
  91. if (cmdArgs.empty()) {
  92. throw std::invalid_argument("A child executable must be specified.");
  93. }
  94. #ifdef _WIN32
  95. // Set the bInheritHandle flag so pipe handles are inherited.
  96. SECURITY_ATTRIBUTES securityAttributes;
  97. securityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
  98. securityAttributes.bInheritHandle = true;
  99. securityAttributes.lpSecurityDescriptor = NULL;
  100. // Create a pipe for the child process's STDOUT.
  101. HANDLE childStdOutAtChild;
  102. HANDLE childStdOutAtParent;
  103. HANDLE childStdInAtChild;
  104. HANDLE childStdInAtParent;
  105. int bufferSize = 0;
  106. if (!CreatePipe(&childStdOutAtParent,
  107. &childStdOutAtChild,
  108. &securityAttributes,
  109. bufferSize)) {
  110. throw std::runtime_error("Error from CreatePipe for stdout: " +
  111. getErrorText());
  112. }
  113. // Ensure the read handle to the pipe for STDOUT is not inherited.
  114. int inheritFlag = 0;
  115. if (!SetHandleInformation(childStdOutAtParent,
  116. HANDLE_FLAG_INHERIT,
  117. inheritFlag) ) {
  118. throw std::runtime_error("Error from GetHandleInformation for stdout: " +
  119. getErrorText());
  120. }
  121. // Create a pipe for the child process's STDIN.
  122. if (! CreatePipe(&childStdInAtChild,
  123. &childStdInAtParent,
  124. &securityAttributes,
  125. bufferSize)) {
  126. throw std::runtime_error("Error from CreatePipe for stdin: " +
  127. getErrorText());
  128. }
  129. // Ensure the write handle to the pipe for STDIN is not inherited.
  130. if (!SetHandleInformation(childStdInAtParent,
  131. HANDLE_FLAG_INHERIT,
  132. inheritFlag)) {
  133. throw std::runtime_error("Error from GetHandleInformation for stdin: " +
  134. getErrorText());
  135. }
  136. // Set up members of the PROCESS_INFORMATION structure.
  137. PROCESS_INFORMATION processInfo;
  138. std::fill((char *) &processInfo,
  139. ((char *) &processInfo) + sizeof(PROCESS_INFORMATION),
  140. 0);
  141. // Set up members of the STARTUPINFO structure. This structure
  142. // specifies the STDIN and STDOUT handles for redirection.
  143. STARTUPINFO startInfo;
  144. std::fill((char *) &startInfo,
  145. ((char *) &startInfo) + sizeof(STARTUPINFO),
  146. 0);
  147. startInfo.cb = sizeof(STARTUPINFO);
  148. startInfo.hStdError = childStdOutAtChild;
  149. startInfo.hStdOutput = childStdOutAtChild;
  150. startInfo.hStdInput = childStdInAtChild;
  151. startInfo.dwFlags |= STARTF_USESTDHANDLES;
  152. // Assemble the command line.
  153. std::string cmdline;
  154. if (cmdArgs.size() == 1) {
  155. cmdline = cmdArgs[0];
  156. } else {
  157. // Append all but last command-line arguments.
  158. for (size_t i = 0; i < cmdArgs.size() - 1; i++) {
  159. cmdline += cmdArgs[i] + " ";
  160. }
  161. cmdline += cmdArgs.back(); // Append last command-line argument.
  162. }
  163. // Create the child process.
  164. bool status;
  165. status = CreateProcess(NULL,
  166. (char *) cmdline.c_str(),
  167. NULL, // process security attributes
  168. NULL, // primary thread security attributes
  169. true, // handles are inherited
  170. 0, // creation flags
  171. NULL, // use parent's environment
  172. NULL, // use parent's current directory
  173. &startInfo, // STARTUPINFO pointer
  174. &processInfo); // receives PROCESS_INFORMATION
  175. // If an error occurs, exit the application.
  176. if (!status ) {
  177. throw std::runtime_error("Error from CreateProcess with "
  178. "command line \"" + cmdline + "\": " +
  179. getErrorText());
  180. }
  181. // Provide the stream buffers with the handles for communicating
  182. // with the child process.
  183. childStreambuf.setInputHandle(childStdOutAtParent);
  184. childStreambuf.setOutputHandle(childStdInAtParent);
  185. // Save the handles to the child process and its primary thread.
  186. childProcess = processInfo.hProcess;
  187. childThread = processInfo.hThread;
  188. // Close the child's end of the pipes.
  189. if (!CloseHandle(childStdOutAtChild)) {
  190. throw std::runtime_error("Error closing the child process "
  191. "stdout handle: " + getErrorText());
  192. }
  193. if (!CloseHandle(childStdInAtChild)) {
  194. throw std::runtime_error("Error closing the child process "
  195. "stdin handle: " + getErrorText());
  196. }
  197. #else
  198. // Create the pipes for the stdin and stdout.
  199. int childStdInPipe[2];
  200. int childStdOutPipe[2];
  201. if (pipe(childStdInPipe) != 0) {
  202. throw std::runtime_error("Error creating pipe for stdin: " +
  203. getErrorText());
  204. }
  205. if (pipe(childStdOutPipe) != 0) {
  206. ::close(childStdInPipe[0]);
  207. ::close(childStdInPipe[1]);
  208. throw std::runtime_error("Error creating pipe for stdout: " +
  209. getErrorText());
  210. }
  211. // Create the child process.
  212. childPid = fork();
  213. if (-1 == childPid) {
  214. for (int i = 0; i < 2; i++) {
  215. ::close(childStdInPipe[i]);
  216. ::close(childStdOutPipe[i]);
  217. }
  218. throw std::runtime_error("Error creating child process: " +
  219. getErrorText());
  220. }
  221. if (0 == childPid) {
  222. // The child executes this. Redirect stdin.
  223. if (dup2(childStdInPipe[0], STDIN_FILENO) == -1) {
  224. std::string errMsg;
  225. // Send message to parent.
  226. errMsg = "Error redirecting stdin in the child: " + getErrorText();
  227. ::write(childStdOutPipe[1], errMsg.data(), errMsg.size());
  228. exit(-1);
  229. }
  230. // Redirect stdout.
  231. if (dup2(childStdOutPipe[1], STDOUT_FILENO) == -1) {
  232. std::string errMsg;
  233. // Send message to parent.
  234. errMsg = "Error redirecting stdout in the child: " + getErrorText();
  235. ::write(childStdOutPipe[1], errMsg.data(), errMsg.size());
  236. exit(-1);
  237. }
  238. // Close pipes.
  239. if ( (::close(childStdInPipe[0]) != 0) ||
  240. (::close(childStdInPipe[1]) != 0) ||
  241. (::close(childStdOutPipe[0]) != 0) ||
  242. (::close(childStdOutPipe[1]) != 0) ) {
  243. std::string errMsg;
  244. // Send message to parent.
  245. errMsg = "Error closing the pipes in the child: " + getErrorText();
  246. ::write(STDOUT_FILENO, errMsg.data(), errMsg.size());
  247. exit(-1);
  248. }
  249. // Prepare the arguments.
  250. std::vector<const char *> execvArgv;
  251. for (auto &arg : cmdArgs) {
  252. execvArgv.push_back(arg.c_str());
  253. }
  254. execvArgv.push_back((char *) NULL);
  255. // Run the child process image.
  256. (void) execv(execvArgv[0], (char * const *) &(execvArgv[0]));
  257. // Error from exec.
  258. std::string errMsg;
  259. // Send message to parent.
  260. errMsg = "Error from exec: " + getErrorText();
  261. ::write(STDOUT_FILENO, errMsg.data(), errMsg.size());
  262. exit(-1);
  263. }
  264. // Provide the stream buffers with the file descriptors for
  265. // communicating with the child process.
  266. childStreambuf.setInputFileDescriptor(childStdOutPipe[0]);
  267. childStreambuf.setOutputFileDescriptor(childStdInPipe[1]);
  268. // Close the child's end of the pipes.
  269. if ( (::close(childStdInPipe[0]) != 0) ||
  270. (::close(childStdOutPipe[1]) != 0) ) {
  271. std::string errMsg;
  272. throw std::runtime_error("Error closing child's end of pipes in "
  273. "the parent: " + getErrorText());
  274. }
  275. #endif
  276. childStarted = true;
  277. }
  278. void ChildStream::close() {
  279. if (!childStarted) {
  280. throw std::logic_error("Child process was not started "
  281. "when close() was called");
  282. }
  283. // Terminate the child if it's running.
  284. if (isRunning()) {
  285. std::string errorString;
  286. bool errorOccurred = false;
  287. #ifdef _WIN32
  288. // Ignore errors. Reason: Terminating a proces that doesn't
  289. // exist (e.g. has exited) gives an error.
  290. (void) TerminateProcess(childProcess, terminateExitCode);
  291. #else
  292. if (kill(childPid, SIGKILL) != 0) {
  293. errorString += (errorOccurred ? "\n" : "");
  294. errorString += "Error terminating the child process: " +
  295. getErrorText();
  296. errorOccurred = true;
  297. } else if (waitpid(childPid, NULL, 0) != childPid) {
  298. errorString += (errorOccurred ? "\n" : "");
  299. errorString += "Error waiting for the child process: " +
  300. getErrorText();
  301. errorOccurred = true;
  302. }
  303. #endif
  304. if (errorOccurred) {
  305. throw std::runtime_error(errorString);
  306. }
  307. }
  308. // Reset.
  309. init();
  310. }
  311. bool ChildStream::isDone() {
  312. if (childExited) {
  313. return true;
  314. }
  315. if (!childStarted) {
  316. throw std::logic_error("Child process was not started "
  317. "when isDone() was called");
  318. }
  319. int result;
  320. #ifdef _WIN32
  321. if (!GetExitCodeProcess(childProcess, (LPDWORD) &result)) {
  322. throw std::runtime_error("Error checking status of child process: " +
  323. getErrorText());
  324. }
  325. if (STILL_ACTIVE == result) {
  326. return false;
  327. }
  328. // Child process has exited. Save the exit code.
  329. exitCode = result;
  330. exitCodeObtainedFlag = true;
  331. #else
  332. int status = 0;
  333. result = waitpid(childPid, &status, WNOHANG);
  334. if (-1 == result) {
  335. throw std::runtime_error("Error checking status of child process: " +
  336. getErrorText());
  337. } else if (0 == result) {
  338. // Child is still running.
  339. return false;
  340. }
  341. if (WIFEXITED(status)) {
  342. // Child exited normally.
  343. exitCode = WEXITSTATUS(status);
  344. exitCodeObtainedFlag = true;
  345. }
  346. #endif
  347. childExited = true;
  348. return true;
  349. }
  350. int32_t ChildStream::result() {
  351. if (exitCodeObtainedFlag) {
  352. return exitCode;
  353. }
  354. // Check whether the process is running, and get the exit code.
  355. if (!isDone()) {
  356. throw std::logic_error("Child process was still running "
  357. "when result() was called");
  358. }
  359. // Child process has exited.
  360. if (!exitCodeObtainedFlag) {
  361. // Exit code is not available.
  362. throw std::runtime_error("Child process has exited but the exit "
  363. "code is not available");
  364. }
  365. return exitCode;
  366. }
  367. std::string ChildStream::getErrorText() {
  368. #ifdef _WIN32
  369. LPVOID winMsgBuf;
  370. DWORD lastError = GetLastError();
  371. FormatMessage(
  372. FORMAT_MESSAGE_ALLOCATE_BUFFER |
  373. FORMAT_MESSAGE_FROM_SYSTEM |
  374. FORMAT_MESSAGE_IGNORE_INSERTS,
  375. NULL,
  376. lastError,
  377. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  378. (char *) &winMsgBuf,
  379. 0, NULL );
  380. std::string errMsg((char *) winMsgBuf);
  381. LocalFree(winMsgBuf);
  382. return errMsg;
  383. #else
  384. return strerror(errno);
  385. #endif
  386. }
  387. ChildStream::ChildStreambuf::ChildStreambuf(std::size_t bufSize) :
  388. #ifdef _WIN32
  389. inputHandle(0),
  390. outputHandle(0),
  391. #else
  392. inputFileDescriptor(-1),
  393. outputFileDescriptor(-1),
  394. #endif
  395. bufferSize(bufSize),
  396. readBuffer(bufferSize + 1),
  397. writeBuffer(bufferSize + 1) {
  398. // Read buffer initialization.
  399. char *end = &(readBuffer.front()) + readBuffer.size();
  400. // Indicate to underflow that underflow has not been called.
  401. setg(end, end, end);
  402. // Write buffer initialization.
  403. char *base = &(writeBuffer.front());
  404. // Indicate to overflow that overflow has not been called.
  405. setp(base, base + writeBuffer.size() - 1);
  406. }
  407. #ifdef _WIN32
  408. void ChildStream::ChildStreambuf::setInputHandle(HANDLE inHandle) {
  409. inputHandle = inHandle;
  410. }
  411. #else
  412. void ChildStream::ChildStreambuf::setInputFileDescriptor(int inFd) {
  413. inputFileDescriptor = inFd;
  414. }
  415. #endif
  416. size_t ChildStream::ChildStreambuf::numBytesAvailable() const {
  417. size_t nBytesAvailable = egptr() - gptr();
  418. #ifdef _WIN32
  419. DWORD lpTotalBytesAvail;
  420. if (!PeekNamedPipe(inputHandle,
  421. NULL,
  422. 0,
  423. NULL,
  424. &lpTotalBytesAvail,
  425. NULL)) {
  426. throw std::runtime_error("Error from PeekNamedPipe: " +
  427. getErrorText());
  428. }
  429. if (lpTotalBytesAvail > 0) {
  430. nBytesAvailable++;
  431. }
  432. #else
  433. fd_set readFd;
  434. int retVal;
  435. struct timeval timeout = {0, 0};
  436. FD_ZERO(&readFd);
  437. FD_SET(inputFileDescriptor, &readFd);
  438. // Check if input is available.
  439. retVal = select(inputFileDescriptor + 1, &readFd, NULL, NULL, &timeout);
  440. if (-1 == retVal) {
  441. throw std::runtime_error("Error from select(): " + getErrorText());
  442. } else if (retVal > 0) {
  443. nBytesAvailable++;
  444. }
  445. #endif
  446. return nBytesAvailable;
  447. }
  448. std::streambuf::int_type ChildStream::ChildStreambuf::underflow() {
  449. // Check for empty buffer.
  450. if (gptr() < egptr()) {
  451. // Not empty.
  452. return traits_type::to_int_type(*gptr());
  453. }
  454. // Need to fill the buffer.
  455. char *base = &(readBuffer.front());
  456. char *start = base;
  457. // Check whether this is the first fill.
  458. if (eback() == base) {
  459. // Not the first fill. Copy one putback character.
  460. *(eback()) = *(egptr() - 1);
  461. start++;
  462. }
  463. // start points to the start of the buffer. Fill buffer.
  464. #ifdef _WIN32
  465. DWORD nBytesRead;
  466. if (!ReadFile(inputHandle,
  467. start,
  468. readBuffer.size() - (start - base),
  469. &nBytesRead,
  470. NULL)) {
  471. return traits_type::eof();
  472. }
  473. #else
  474. ssize_t nBytesRead;
  475. nBytesRead = ::read(inputFileDescriptor,
  476. start,
  477. readBuffer.size() - (start - base));
  478. if (-1 == nBytesRead) {
  479. return traits_type::eof();
  480. }
  481. #endif
  482. // Check for EOF.
  483. if (0 == nBytesRead) {
  484. return traits_type::eof();
  485. }
  486. // Update buffer pointers.
  487. setg(base, start, start + nBytesRead);
  488. return traits_type::to_int_type(*gptr());
  489. }
  490. #ifdef _WIN32
  491. void ChildStream::ChildStreambuf::setOutputHandle(HANDLE outHandle) {
  492. outputHandle = outHandle;
  493. }
  494. #else
  495. void ChildStream::ChildStreambuf::setOutputFileDescriptor(int outFd) {
  496. outputFileDescriptor = outFd;
  497. }
  498. #endif
  499. void ChildStream::ChildStreambuf::flushBuffer() {
  500. // Write.
  501. std::ptrdiff_t nBytes = pptr() - pbase();
  502. #ifdef _WIN32
  503. DWORD nBytesWritten;
  504. if (!WriteFile(outputHandle,
  505. pbase(),
  506. nBytes,
  507. &nBytesWritten,
  508. NULL)) {
  509. // Clear the output buffer.
  510. pbump(-nBytes);
  511. throw std::runtime_error("Error writing to child process: " +
  512. getErrorText());
  513. }
  514. #else
  515. ssize_t nBytesWritten;
  516. nBytesWritten = ::write(outputFileDescriptor, pbase(), nBytes);
  517. #endif
  518. // Clear the output buffer.
  519. pbump(-nBytes);
  520. if (nBytes != nBytesWritten) {
  521. throw std::runtime_error("Not all data was written to to child "
  522. "process: " + getErrorText());
  523. }
  524. return;
  525. }
  526. std::streambuf::int_type ChildStream::ChildStreambuf::overflow(int_type ch) {
  527. // Check whether we're writing EOF.
  528. if (traits_type::eof() != ch) {
  529. // Not writing EOF.
  530. *(pptr()) = ch;
  531. pbump(1);
  532. // Write.
  533. flushBuffer();
  534. // Success.
  535. return ch;
  536. }
  537. return traits_type::eof();
  538. }
  539. int ChildStream::ChildStreambuf::sync() {
  540. flushBuffer(); // Throws exception on failure.
  541. // Success.
  542. return 1;
  543. }
  544. Child::CircularBuffer::CircularBuffer(size_t maxSize) :
  545. buffer(maxSize + 1),
  546. capacity(maxSize) {
  547. iBegin = 0;
  548. iEnd = 0;
  549. }
  550. bool Child::CircularBuffer::empty() const {
  551. return (iBegin == iEnd);
  552. }
  553. size_t Child::CircularBuffer::nUsed() const {
  554. return capacity - nFree();
  555. }
  556. void Child::CircularBuffer::clear() {
  557. iBegin = 0;
  558. iEnd = 0;
  559. }
  560. size_t Child::CircularBuffer::nFree() const {
  561. size_t iLocalBegin = iBegin;
  562. // Correct an invalid value.
  563. if (iLocalBegin >= capacity + 1) {
  564. iLocalBegin = 0;
  565. }
  566. if (iLocalBegin <= iEnd) {
  567. return capacity - (iEnd - iLocalBegin);
  568. }
  569. return iLocalBegin - iEnd - 1;
  570. }
  571. void Child::CircularBuffer::put(char const *ptr, size_t nBytes) {
  572. for (size_t i = 0; i < nBytes; i++) {
  573. buffer[iEnd] = *ptr;
  574. ptr++;
  575. nextIndex(iEnd);
  576. }
  577. }
  578. Child::Child(std::vector<std::string> const &args,
  579. size_t bufSize,
  580. std::uint16_t nominalAboveMinPollTime_ms,
  581. std::uint16_t deltaPollTime_ms) :
  582. bufferCapacity(bufSize),
  583. readBuffer(bufferCapacity),
  584. writeBuffer(bufferCapacity),
  585. nominalPollTime_ms(nominalAboveMinPollTime_ms +
  586. CodeDweller::MinimumSleeperTime),
  587. maximumPollTime_ms(nominalPollTime_ms + deltaPollTime_ms) {
  588. init();
  589. open(args);
  590. }
  591. Child::Child(std::string const &childpath,
  592. size_t bufSize,
  593. std::uint16_t nominalAboveMinPollTime_ms,
  594. std::uint16_t deltaPollTime_ms) :
  595. bufferCapacity(bufSize),
  596. readBuffer(bufferCapacity),
  597. writeBuffer(bufferCapacity),
  598. nominalPollTime_ms(nominalAboveMinPollTime_ms +
  599. CodeDweller::MinimumSleeperTime),
  600. maximumPollTime_ms(nominalPollTime_ms + deltaPollTime_ms) {
  601. init();
  602. open(childpath);
  603. }
  604. Child::Child(size_t bufSize,
  605. std::uint16_t nominalAboveMinPollTime_ms,
  606. std::uint16_t deltaPollTime_ms) :
  607. bufferCapacity(bufSize),
  608. readBuffer(bufferCapacity),
  609. writeBuffer(bufferCapacity),
  610. nominalPollTime_ms(nominalAboveMinPollTime_ms +
  611. CodeDweller::MinimumSleeperTime),
  612. maximumPollTime_ms(nominalPollTime_ms + deltaPollTime_ms) {
  613. init();
  614. }
  615. Child::~Child() {
  616. try {
  617. close();
  618. } catch (std::exception &e) {
  619. ;
  620. }
  621. }
  622. void Child::open(std::vector<std::string> const &args) {
  623. cmdArgs = args;
  624. if (isRunning()) {
  625. throw std::logic_error("The child process was already active.");
  626. }
  627. init();
  628. run();
  629. }
  630. void Child::open(std::string const &childpath) {
  631. if (isRunning()) {
  632. throw std::logic_error("The child process was already active.");
  633. }
  634. cmdArgs.clear();
  635. cmdArgs.push_back(childpath);
  636. init();
  637. run();
  638. }
  639. void Child::init() {
  640. childStarted = false;
  641. childExited = false;
  642. exitCodeObtainedFlag = false;
  643. exitCode = 0;
  644. readBuffer.clear();
  645. nWriteBytes = 0;
  646. nTransmitBytes = 0;
  647. readerThreadIsRunning = false;
  648. writerThreadIsRunning = false;
  649. stopReaderFlag = true;
  650. stopWriterFlag = true;
  651. errorText.clear();
  652. }
  653. bool Child::isFinishedWriting() const {
  654. return ( (0 == nWriteBytes) &&
  655. (0 == nTransmitBytes) );
  656. }
  657. bool Child::closeInput(std::string &errorString) {
  658. #ifdef _WIN32
  659. // Close if not already closed.
  660. if ( (NULL != inputHandle) &&
  661. (CloseHandle(inputHandle) == 0) ) {
  662. errorString += (errorString.empty() ? "" : "\n");
  663. errorString += "Error closing input to the child: " + getErrorText();
  664. return false;
  665. }
  666. // Closed successfully.
  667. inputHandle = NULL;
  668. return true;
  669. #else
  670. // Close if not already closed.
  671. if ( (-1 != inputFileDescriptor) &&
  672. (0 != ::close(inputFileDescriptor)) ) {
  673. errorString += (errorString.empty() ? "" : "\n");
  674. errorString += "Error closing input to the child: " + getErrorText();
  675. return false;
  676. }
  677. // Closed successfully.
  678. inputFileDescriptor = -1;
  679. return true;
  680. #endif
  681. }
  682. bool Child::closeOutput(std::string &errorString) {
  683. #ifdef _WIN32
  684. // Close if not already closed.
  685. if ( (NULL != outputHandle) &&
  686. (CloseHandle(outputHandle) == 0) ) {
  687. errorString += (errorString.empty() ? "" : "\n");
  688. errorString += "Error closing output to the child: " + getErrorText();
  689. return false;
  690. }
  691. // Closed successfully.
  692. outputHandle = NULL;
  693. return true;
  694. #else
  695. // Close if not already closed.
  696. if ( (-1 != outputFileDescriptor) &&
  697. (0 != ::close(outputFileDescriptor)) ) {
  698. errorString += (errorString.empty() ? "" : "\n");
  699. errorString += "Error closing output to the child: " + getErrorText();
  700. return false;
  701. }
  702. // Closed successfully.
  703. outputFileDescriptor = -1;
  704. return true;
  705. #endif
  706. }
  707. void Child::closeStdIn() {
  708. if (!childStarted) {
  709. throw std::logic_error("Child process was not started "
  710. "when close() was called");
  711. }
  712. // Stop writer thread. Note: None of the error conditions that
  713. // cause an exception to be thrown by join() can ever occur.
  714. stopWriterFlag = true;
  715. std::string errorString;
  716. if (!closeOutput(errorString)) {
  717. throw std::runtime_error(errorString);
  718. }
  719. if (writerThreadIsRunning) {
  720. writerThread.join();
  721. writerThreadIsRunning = false;
  722. }
  723. }
  724. void Child::close() {
  725. if (!childStarted) {
  726. throw std::logic_error("Child process was not started "
  727. "when close() was called");
  728. }
  729. // Stop the reader and writer threads. Note: None of the error
  730. // conditions that cause an exception to be thrown by join()
  731. // can ever occur.
  732. stopReaderFlag = true;
  733. stopWriterFlag = true;
  734. // Terminate the child if it's running.
  735. if (isRunning()) {
  736. std::string errorString;
  737. bool noErrorOccurred = true;
  738. #ifdef _WIN32
  739. // Ignore errors. Reason: Terminating a proces that doesn't
  740. // exist (e.g. has exited) gives an error.
  741. (void) TerminateProcess(childProcess, terminateExitCode);
  742. noErrorOccurred = noErrorOccurred && closeInput(errorString);
  743. noErrorOccurred = noErrorOccurred && closeOutput(errorString);
  744. #else
  745. noErrorOccurred = noErrorOccurred && closeInput(errorString);
  746. noErrorOccurred = noErrorOccurred && closeOutput(errorString);
  747. if (kill(childPid, SIGKILL) != 0) {
  748. errorString += (errorString.empty() ? "" : "\n");
  749. errorString += "Error terminating the child process: " +
  750. getErrorText();
  751. noErrorOccurred = false;
  752. } else if (waitpid(childPid, NULL, 0) != childPid) {
  753. errorString += (errorString.empty() ? "" : "\n");
  754. errorString += "Error waiting for the child process: " +
  755. getErrorText();
  756. noErrorOccurred = false;
  757. }
  758. #endif
  759. if (!noErrorOccurred) {
  760. throw std::runtime_error(errorString);
  761. }
  762. }
  763. if (readerThreadIsRunning) {
  764. readerThread.join();
  765. readerThreadIsRunning = false;
  766. }
  767. if (writerThreadIsRunning) {
  768. writerThread.join();
  769. writerThreadIsRunning = false;
  770. }
  771. // Reset.
  772. init();
  773. }
  774. bool Child::isRunning() const {
  775. return childStarted && !childExited;
  776. }
  777. bool Child::errorOccurred(std::string &errorDescription) const {
  778. errorDescription = errorText;
  779. return !errorDescription.empty();
  780. }
  781. void Child::run() {
  782. if (childStarted) {
  783. throw std::logic_error("Child process was active when "
  784. "run() was called");
  785. }
  786. if (cmdArgs.empty()) {
  787. throw std::invalid_argument("A child executable must be specified.");
  788. }
  789. #ifdef _WIN32
  790. // Set the bInheritHandle flag so pipe handles are inherited.
  791. SECURITY_ATTRIBUTES securityAttributes;
  792. securityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
  793. securityAttributes.bInheritHandle = true;
  794. securityAttributes.lpSecurityDescriptor = NULL;
  795. // Create a pipe for the child process's STDOUT.
  796. HANDLE childStdOutAtChild;
  797. HANDLE childStdOutAtParent;
  798. HANDLE childStdInAtChild;
  799. HANDLE childStdInAtParent;
  800. int bufferSize = 0;
  801. if (!CreatePipe(&childStdOutAtParent,
  802. &childStdOutAtChild,
  803. &securityAttributes,
  804. bufferSize)) {
  805. throw std::runtime_error("Error from CreatePipe for stdout: " +
  806. getErrorText());
  807. }
  808. // Ensure the read handle to the pipe for STDOUT is not inherited.
  809. int inheritFlag = 0;
  810. if (!SetHandleInformation(childStdOutAtParent,
  811. HANDLE_FLAG_INHERIT,
  812. inheritFlag) ) {
  813. throw std::runtime_error("Error from GetHandleInformation for stdout: " +
  814. getErrorText());
  815. }
  816. // Create a pipe for the child process's STDIN.
  817. if (! CreatePipe(&childStdInAtChild,
  818. &childStdInAtParent,
  819. &securityAttributes,
  820. bufferSize)) {
  821. throw std::runtime_error("Error from CreatePipe for stdin: " +
  822. getErrorText());
  823. }
  824. // Ensure the write handle to the pipe for STDIN is not inherited.
  825. if (!SetHandleInformation(childStdInAtParent,
  826. HANDLE_FLAG_INHERIT,
  827. inheritFlag)) {
  828. throw std::runtime_error("Error from GetHandleInformation for stdin: " +
  829. getErrorText());
  830. }
  831. // Set up members of the PROCESS_INFORMATION structure.
  832. PROCESS_INFORMATION processInfo;
  833. std::fill((char *) &processInfo,
  834. ((char *) &processInfo) + sizeof(PROCESS_INFORMATION),
  835. 0);
  836. // Set up members of the STARTUPINFO structure. This structure
  837. // specifies the STDIN and STDOUT handles for redirection.
  838. STARTUPINFO startInfo;
  839. std::fill((char *) &startInfo,
  840. ((char *) &startInfo) + sizeof(STARTUPINFO),
  841. 0);
  842. startInfo.cb = sizeof(STARTUPINFO);
  843. startInfo.hStdError = childStdOutAtChild;
  844. startInfo.hStdOutput = childStdOutAtChild;
  845. startInfo.hStdInput = childStdInAtChild;
  846. startInfo.dwFlags |= STARTF_USESTDHANDLES;
  847. // Assemble the command line.
  848. std::string cmdline;
  849. if (cmdArgs.size() == 1) {
  850. cmdline = cmdArgs[0];
  851. } else {
  852. // Append all but last command-line arguments.
  853. for (size_t i = 0; i < cmdArgs.size() - 1; i++) {
  854. cmdline += cmdArgs[i] + " ";
  855. }
  856. cmdline += cmdArgs.back(); // Append last command-line argument.
  857. }
  858. // Create the child process.
  859. bool status;
  860. status = CreateProcess(NULL,
  861. (char *) cmdline.c_str(),
  862. NULL, // process security attributes
  863. NULL, // primary thread security attributes
  864. true, // handles are inherited
  865. 0, // creation flags
  866. NULL, // use parent's environment
  867. NULL, // use parent's current directory
  868. &startInfo, // STARTUPINFO pointer
  869. &processInfo); // receives PROCESS_INFORMATION
  870. // If an error occurs, exit the application.
  871. if (!status ) {
  872. throw std::runtime_error("Error from CreateProcess with "
  873. "command line \"" + cmdline + "\": " +
  874. getErrorText());
  875. }
  876. // Save the handles for communicating with the child process.
  877. inputHandle = childStdOutAtParent;
  878. outputHandle = childStdInAtParent;
  879. // Save the handles to the child process and its primary thread.
  880. childProcess = processInfo.hProcess;
  881. childThread = processInfo.hThread;
  882. // Close the child's end of the pipes.
  883. if (!CloseHandle(childStdOutAtChild)) {
  884. throw std::runtime_error("Error closing the child process "
  885. "stdout handle: " + getErrorText());
  886. }
  887. if (!CloseHandle(childStdInAtChild)) {
  888. throw std::runtime_error("Error closing the child process "
  889. "stdin handle: " + getErrorText());
  890. }
  891. #else
  892. // Create the pipes for the stdin and stdout.
  893. int childStdInPipe[2];
  894. int childStdOutPipe[2];
  895. if (pipe(childStdInPipe) != 0) {
  896. throw std::runtime_error("Error creating pipe for stdin: " +
  897. getErrorText());
  898. }
  899. if (pipe(childStdOutPipe) != 0) {
  900. ::close(childStdInPipe[0]);
  901. ::close(childStdInPipe[1]);
  902. throw std::runtime_error("Error creating pipe for stdout: " +
  903. getErrorText());
  904. }
  905. // Create the child process.
  906. childPid = fork();
  907. if (-1 == childPid) {
  908. for (int i = 0; i < 2; i++) {
  909. ::close(childStdInPipe[i]);
  910. ::close(childStdOutPipe[i]);
  911. }
  912. throw std::runtime_error("Error creating child process: " +
  913. getErrorText());
  914. }
  915. if (0 == childPid) {
  916. // The child executes this. Redirect stdin.
  917. if (dup2(childStdInPipe[0], STDIN_FILENO) == -1) {
  918. std::string errMsg;
  919. // Send message to parent.
  920. errMsg = "Error redirecting stdin in the child: " + getErrorText();
  921. ::write(childStdOutPipe[1], errMsg.data(), errMsg.size());
  922. exit(-1);
  923. }
  924. // Redirect stdout.
  925. if (dup2(childStdOutPipe[1], STDOUT_FILENO) == -1) {
  926. std::string errMsg;
  927. // Send message to parent.
  928. errMsg = "Error redirecting stdout in the child: " + getErrorText();
  929. ::write(childStdOutPipe[1], errMsg.data(), errMsg.size());
  930. exit(-1);
  931. }
  932. if (dup2(childStdOutPipe[1], STDERR_FILENO) == -1) {
  933. std::string errMsg;
  934. // Send message to parent.
  935. errMsg = "Error redirecting stderr in the child: " + getErrorText();
  936. ::write(childStdOutPipe[1], errMsg.data(), errMsg.size());
  937. exit(-1);
  938. }
  939. // Close pipes.
  940. if ( (::close(childStdInPipe[0]) != 0) ||
  941. (::close(childStdInPipe[1]) != 0) ||
  942. (::close(childStdOutPipe[0]) != 0) ||
  943. (::close(childStdOutPipe[1]) != 0) ) {
  944. std::string errMsg;
  945. // Send message to parent.
  946. errMsg = "Error closing the pipes in the child: " + getErrorText();
  947. ::write(STDOUT_FILENO, errMsg.data(), errMsg.size());
  948. exit(-1);
  949. }
  950. // Prepare the arguments.
  951. std::vector<const char *> execvArgv;
  952. for (auto &arg : cmdArgs) {
  953. execvArgv.push_back(arg.c_str());
  954. }
  955. execvArgv.push_back((char *) NULL);
  956. // Run the child process image.
  957. (void) execv(execvArgv[0], (char * const *) &(execvArgv[0]));
  958. // Error from exec.
  959. std::string errMsg;
  960. // Send message to parent.
  961. errMsg = "Error (from exec) running the command \"";
  962. errMsg += execvArgv[0];
  963. errMsg += ": " + getErrorText();
  964. ::write(STDOUT_FILENO, errMsg.data(), errMsg.size());
  965. exit(-1);
  966. }
  967. // Provide the stream buffers with the file descriptors for
  968. // communicating with the child process.
  969. inputFileDescriptor = childStdOutPipe[0];
  970. outputFileDescriptor = childStdInPipe[1];
  971. // Close the child's end of the pipes.
  972. if ( (::close(childStdInPipe[0]) != 0) ||
  973. (::close(childStdOutPipe[1]) != 0) ) {
  974. std::string errMsg;
  975. throw std::runtime_error("Error closing child's end of pipes in "
  976. "the parent: " + getErrorText());
  977. }
  978. #endif
  979. childStarted = true;
  980. // Start the reader and writer threads.
  981. stopReaderFlag = false;
  982. stopWriterFlag = false;
  983. try {
  984. std::thread readerTemp(&Child::readFromChild, this);
  985. readerThread = std::move(readerTemp);
  986. } catch (std::exception &e) {
  987. throw std::runtime_error("Error starting reader thread: " +
  988. getErrorText());
  989. }
  990. try {
  991. std::thread writerTemp(&Child::writeToChild, this);
  992. writerThread = std::move(writerTemp);
  993. } catch (std::exception &e) {
  994. stopReaderFlag = true;
  995. stopWriterFlag = true;
  996. readerThread.join();
  997. throw std::runtime_error("Error starting writer thread: " +
  998. getErrorText());
  999. }
  1000. readerThreadIsRunning = true;
  1001. writerThreadIsRunning = true;
  1002. }
  1003. bool Child::isDone() {
  1004. if (childExited) {
  1005. return true;
  1006. }
  1007. if (!childStarted) {
  1008. throw std::logic_error("Child process was not started "
  1009. "when isDone() was called");
  1010. }
  1011. int result;
  1012. #ifdef _WIN32
  1013. if (!GetExitCodeProcess(childProcess, (LPDWORD) &result)) {
  1014. throw std::runtime_error("Error checking status of child process: " +
  1015. getErrorText());
  1016. }
  1017. if (STILL_ACTIVE == result) {
  1018. return false;
  1019. }
  1020. // Child process has exited. Save the exit code.
  1021. exitCode = result;
  1022. exitCodeObtainedFlag = true;
  1023. #else
  1024. int status = 0;
  1025. result = waitpid(childPid, &status, WNOHANG);
  1026. if (-1 == result) {
  1027. throw std::runtime_error("Error checking status of child process: " +
  1028. getErrorText());
  1029. } else if (0 == result) {
  1030. // Child is still running.
  1031. return false;
  1032. }
  1033. if (WIFEXITED(status)) {
  1034. // Child exited normally.
  1035. exitCode = WEXITSTATUS(status);
  1036. exitCodeObtainedFlag = true;
  1037. }
  1038. #endif
  1039. childExited = true;
  1040. // Stop threads.
  1041. stopReaderFlag = true;
  1042. stopWriterFlag = true;
  1043. if (readerThreadIsRunning) {
  1044. readerThread.join();
  1045. readerThreadIsRunning = false;
  1046. }
  1047. if (writerThreadIsRunning) {
  1048. writerThread.join();
  1049. writerThreadIsRunning = false;
  1050. }
  1051. return true;
  1052. }
  1053. int32_t Child::result() {
  1054. if (exitCodeObtainedFlag) {
  1055. return exitCode;
  1056. }
  1057. // Check whether the process is running, and get the exit code.
  1058. if (!isDone()) {
  1059. throw std::logic_error("Child process was still running "
  1060. "when result() was called");
  1061. }
  1062. // Child process has exited.
  1063. if (!exitCodeObtainedFlag) {
  1064. // Exit code is not available.
  1065. throw std::runtime_error("Child process has exited but the exit "
  1066. "code is not available");
  1067. }
  1068. return exitCode;
  1069. }
  1070. std::string Child::getErrorText() {
  1071. #ifdef _WIN32
  1072. LPVOID winMsgBuf;
  1073. DWORD lastError = GetLastError();
  1074. FormatMessage(
  1075. FORMAT_MESSAGE_ALLOCATE_BUFFER |
  1076. FORMAT_MESSAGE_FROM_SYSTEM |
  1077. FORMAT_MESSAGE_IGNORE_INSERTS,
  1078. NULL,
  1079. lastError,
  1080. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  1081. (char *) &winMsgBuf,
  1082. 0, NULL );
  1083. std::string errMsg((char *) winMsgBuf);
  1084. LocalFree(winMsgBuf);
  1085. return errMsg;
  1086. #else
  1087. return strerror(errno);
  1088. #endif
  1089. }
  1090. void Child::readFromChild() {
  1091. std::vector<char> rxBuf(bufferCapacity);
  1092. CodeDweller::PollTimer pollTimer(nominalPollTime_ms, maximumPollTime_ms);
  1093. while (!stopReaderFlag) {
  1094. char *bufferPtr;
  1095. bufferPtr = &(rxBuf[0]);
  1096. // Blocking read from the child.
  1097. #ifdef _WIN32
  1098. DWORD nBytesRead;
  1099. if (!ReadFile(inputHandle,
  1100. bufferPtr,
  1101. bufferCapacity,
  1102. &nBytesRead,
  1103. NULL)) {
  1104. if (stopReaderFlag) {
  1105. break;
  1106. }
  1107. // Broken pipe occurs when the child exits; this is not
  1108. // necessarily an error condition.
  1109. if (GetLastError() != ERROR_BROKEN_PIPE) {
  1110. errorText = "Error reading from the child process: ";
  1111. errorText += getErrorText();
  1112. }
  1113. break;
  1114. }
  1115. #else
  1116. ssize_t nBytesRead;
  1117. nBytesRead = ::read(inputFileDescriptor,
  1118. bufferPtr,
  1119. bufferCapacity);
  1120. if (-1 == nBytesRead) {
  1121. if (stopReaderFlag) {
  1122. break;
  1123. }
  1124. errorText = "Error reading from the child process: ";
  1125. errorText += getErrorText();
  1126. break;
  1127. } else if (0 == nBytesRead) {
  1128. // EOF; child exited.
  1129. break;
  1130. }
  1131. #endif
  1132. // Copy to the shared read buffer.
  1133. while ((nBytesRead > 0) && !stopReaderFlag) {
  1134. int nBytesToPut, nBytesFree;
  1135. nBytesToPut = nBytesRead;
  1136. // Can be called in the reader thread without locking the
  1137. // mutex.
  1138. nBytesFree = readBuffer.nFree();
  1139. if (nBytesToPut > nBytesFree) {
  1140. nBytesToPut = nBytesFree;
  1141. }
  1142. if (nBytesToPut > 0) {
  1143. std::lock_guard<std::mutex> lock(readBufferMutex);
  1144. readBuffer.put(bufferPtr, nBytesToPut);
  1145. bufferPtr += nBytesToPut;
  1146. nBytesRead -= nBytesToPut;
  1147. pollTimer.reset();
  1148. } else {
  1149. pollTimer.pause();
  1150. }
  1151. }
  1152. }
  1153. }
  1154. void Child::writeToChild() {
  1155. std::vector<char> localWriteBuffer(bufferCapacity);
  1156. size_t nLocalWriteBytes;
  1157. CodeDweller::PollTimer pollTimer(nominalPollTime_ms, maximumPollTime_ms);
  1158. while (!stopWriterFlag) {
  1159. char *bufferPtr;
  1160. // Poll for data in the shared write buffer.
  1161. while ((0 == nWriteBytes) && !stopWriterFlag) {
  1162. pollTimer.pause();
  1163. }
  1164. if (stopWriterFlag) {
  1165. goto exit;
  1166. }
  1167. // Copy from the shared write buffer.
  1168. {
  1169. std::lock_guard<std::mutex> lock(writeBufferMutex);
  1170. localWriteBuffer.swap(writeBuffer);
  1171. nLocalWriteBytes = nWriteBytes;
  1172. nWriteBytes = 0;
  1173. }
  1174. if (stopWriterFlag) {
  1175. goto exit;
  1176. }
  1177. pollTimer.reset();
  1178. // Blocking write to the child.
  1179. bufferPtr = &(localWriteBuffer[0]);
  1180. while (nLocalWriteBytes > 0) {
  1181. #ifdef _WIN32
  1182. DWORD nBytesWritten;
  1183. if (!WriteFile(outputHandle,
  1184. bufferPtr,
  1185. nLocalWriteBytes,
  1186. &nBytesWritten,
  1187. NULL)) {
  1188. if (stopWriterFlag) {
  1189. goto exit;
  1190. }
  1191. errorText = "Error writing to the child process: ";
  1192. errorText += getErrorText();
  1193. goto exit;
  1194. }
  1195. if (stopWriterFlag) {
  1196. goto exit;
  1197. }
  1198. #else
  1199. ssize_t nBytesWritten;
  1200. nBytesWritten = ::write(outputFileDescriptor,
  1201. bufferPtr,
  1202. nLocalWriteBytes);
  1203. if (stopWriterFlag) {
  1204. goto exit;
  1205. }
  1206. if (-1 == nBytesWritten) {
  1207. if (ENOSPC != errno) {
  1208. // Some error other than no space.
  1209. errorText = "Error writing to the child process: ";
  1210. errorText += getErrorText();
  1211. goto exit;
  1212. }
  1213. }
  1214. #endif
  1215. nLocalWriteBytes -= nBytesWritten;
  1216. bufferPtr += nBytesWritten;
  1217. }
  1218. }
  1219. exit: return;
  1220. }
  1221. }