Inside Bitcoin

251      throw OSError("invalid_mode", 0);
252    }
253
254    if (mode[0] == 'w') {
255      md = _O_WRONLY;
256    }
257    else if (mode[0] == 'r') {
258      md = _O_RDONLY;
259    }
260    else {
261      throw OSError("file_from_handle", 0);
262    }
263
264    int os_fhandle = _open_osfhandle((intptr_t)h, md);
265    if (os_fhandle == -1) {
266      CloseHandle(h);
267      throw OSError("_open_osfhandle", 0);
268    }
269
270    FILE *fp = _fdopen(os_fhandle, mode);
271    if (fp == 0) {
272      subprocess_close(os_fhandle);
273      throw OSError("_fdopen", 0);
274    }
275
276    return fp;
277  }
278
279  inline void configure_pipe(HANDLE* read_handle, HANDLE* write_handle, HANDLE* child_handle)
280  {
281    SECURITY_ATTRIBUTES saAttr;
282
283    // Set the bInheritHandle flag so pipe handles are inherited.
284    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
285    saAttr.bInheritHandle = TRUE;
286    saAttr.lpSecurityDescriptor = NULL;
287
288    // Create a pipe for the child process's STDIN.
289    if (!CreatePipe(read_handle, write_handle, &saAttr,0))
290      throw OSError("CreatePipe", 0);
291
292    // Ensure the write handle to the pipe for STDIN is not inherited.
293    if (!SetHandleInformation(*child_handle, HANDLE_FLAG_INHERIT, 0))
294      throw OSError("SetHandleInformation", 0);
295  }
296#endif
297
298  /*!
299   * Function: split
300   * Parameters:
301   * [in] str : Input string which needs to be split based upon the
302   *            delimiters provided.
303   * [in] deleims : Delimiter characters based upon which the string needs
304   *                to be split. Default constructed to ' '(space) and '\t'(tab)
305   * [out] vector<string> : Vector of strings split at deleimiter.
306   */
307  static inline std::vector<std::string>
308  split(const std::string& str, const std::string& delims=" \t")
309  {
310    std::vector<std::string> res;
311    size_t init = 0;
312
313    while (true) {
314      auto pos = str.find_first_of(delims, init);
315      if (pos == std::string::npos) {
316        res.emplace_back(str.substr(init, str.length()));
317        break;
318      }
319      res.emplace_back(str.substr(init, pos - init));
320      pos++;
321      init = pos;
322    }
323
324    return res;
325  }
326
327
328#ifndef WIN32
329  /*!
330   * Function: set_clo_on_exec
331   * Sets/Resets the FD_CLOEXEC flag on the provided file descriptor
332   * based upon the `set` parameter.
333   * Parameters:
334   * [in] fd : The descriptor on which FD_CLOEXEC needs to be set/reset.
335   * [in] set : If 'true', set FD_CLOEXEC.
336   *            If 'false' unset FD_CLOEXEC.
337   */
338  static inline
339  void set_clo_on_exec(int fd, bool set = true)
340  {
341    int flags = fcntl(fd, F_GETFD, 0);
342    if (flags == -1) {
343        throw OSError("fcntl F_GETFD failed", errno);
344    }
345    if (set) flags |= FD_CLOEXEC;
346    else flags &= ~FD_CLOEXEC;
347    if (fcntl(fd, F_SETFD, flags) == -1) {
348        throw OSError("fcntl F_SETFD failed", errno);
349    }
350  }
351
352
353  /*!
354   * Function: pipe_cloexec
355   * Creates a pipe and sets FD_CLOEXEC flag on both
356   * read and write descriptors of the pipe.
357   * Parameters:
358   * [out] : A pair of file descriptors.
359   *         First element of pair is the read descriptor of pipe.
360   *         Second element is the write descriptor of pipe.
361   */
362  static inline
363  std::pair<int, int> pipe_cloexec() noexcept(false)
364  {
365    int pipe_fds[2];
366    int res = pipe(pipe_fds);
367    if (res) {
368      throw OSError("pipe failure", errno);
369    }
370
371    set_clo_on_exec(pipe_fds[0]);
372    set_clo_on_exec(pipe_fds[1]);
373
374    return std::make_pair(pipe_fds[0], pipe_fds[1]);
375  }
376#endif
377
378
379  /*!
380   * Function: write_n
381   * Writes `length` bytes to the file descriptor `fd`
382   * from the buffer `buf`.
383   * Parameters:
384   * [in] fd : The file descriptotr to write to.
385   * [in] buf: Buffer from which data needs to be written to fd.
386   * [in] length: The number of bytes that needs to be written from
387   *              `buf` to `fd`.
388   * [out] int : Number of bytes written or -1 in case of failure.
389   */
390  static inline
391  int write_n(int fd, const char* buf, size_t length)
392  {
393    size_t nwritten = 0;
394    while (nwritten < length) {
395      int written = subprocess_write(fd, buf + nwritten, length - nwritten);
396      if (written == -1) return -1;
397      nwritten += written;
398    }
399    return nwritten;
400  }
401
402
403  /*!
404   * Function: read_atmost_n
405   * Reads at the most `read_upto` bytes from the
406   * file object `fp` before returning.
407   * Parameters:
408   * [in] fp : The file object from which it needs to read.
409   * [in] buf : The buffer into which it needs to write the data.
410   * [in] read_upto: Max number of bytes which must be read from `fd`.
411   * [out] int : Number of bytes written to `buf` or read from `fd`
412   *             OR -1 in case of error.
413   *  NOTE: In case of EINTR while reading from socket, this API
414   *  will retry to read from `fd`, but only till the EINTR counter
415   *  reaches 50 after which it will return with whatever data it read.
416   */
417  static inline
418  int read_atmost_n(FILE* fp, char* buf, size_t read_upto)
419  {
420#ifdef WIN32
421    return (int)fread(buf, 1, read_upto, fp);
422#else
423    int fd = subprocess_fileno(fp);
424    int rbytes = 0;
425    int eintr_cnter = 0;
426
427    while (1) {
428      int read_bytes = read(fd, buf + rbytes, read_upto - rbytes);
429      if (read_bytes == -1) {
430        if (errno == EINTR) {
431          if (eintr_cnter >= 50) return -1;
432          eintr_cnter++;
433          continue;
434        }
435        return -1;
436      }
437      if (read_bytes == 0) return rbytes;
438
439      rbytes += read_bytes;
440    }
441    return rbytes;
442#endif
443  }
444
445
446  /*!
447   * Function: read_all
448   * Reads all the available data from `fp` into
449   * `buf`. Internally calls read_atmost_n.
450   * Parameters:
451   * [in] fp : The file object from which to read from.
452   * [in] buf : The buffer of type `class Buffer` into which
453   *            the read data is written to.
454   * [out] int: Number of bytes read OR -1 in case of failure.
455   *
456   * NOTE: `class Buffer` is a exposed public class. See below.
457   */
458
459  static inline int read_all(FILE* fp, std::vector<char>& buf)
460  {
461    auto buffer = buf.data();
462    int total_bytes_read = 0;
463    int fill_sz = buf.size();
464
465    while (1) {
466      const int rd_bytes = read_atmost_n(fp, buffer, fill_sz);
467
468      if (rd_bytes == -1) { // Read finished
469        if (total_bytes_read == 0) return -1;
470        break;
471
472      } else if (rd_bytes == fill_sz) { // Buffer full
473        const auto orig_sz = buf.size();
474        const auto new_sz = orig_sz * 2;
475        buf.resize(new_sz);
476        fill_sz = new_sz - orig_sz;
477
478        //update the buffer pointer
479        buffer = buf.data();
480        total_bytes_read += rd_bytes;
481        buffer += total_bytes_read;
482
483      } else { // Partial data ? Continue reading
484        total_bytes_read += rd_bytes;
485        fill_sz -= rd_bytes;
486        break;
487      }
488    }
489    buf.erase(buf.begin()+total_bytes_read, buf.end()); // remove extra nulls
490    return total_bytes_read;
491  }
492
493#ifndef WIN32
494  /*!
495   * Function: wait_for_child_exit
496   * Waits for the process with pid `pid` to exit
497   * and returns its status.
498   * Parameters:
499   * [in] pid : The pid of the process.
500   * [out] pair<int, int>: