cpp

// leaky_stdlib.cc: Replacement for standard library modules

// and native/posixmodule.c

// clang-format off

#include "mycpp/myerror.h"  // for OSError; must come first

// clang-format on

#include "leaky_stdlib.h"

#include <errno.h>

#include <fcntl.h>      // open

#include <sys/stat.h>   // umask

#include <sys/types.h>  // umask

#include <sys/wait.h>   // WUNTRACED

#include <time.h>

#include <unistd.h>

#include "cpp/leaky_core_error.h"

#include "cpp/leaky_core_pyerror.h"

#include "mycpp/mylib_leaky.h"

using mylib::CopyStr;

using mylib::OverAllocatedStr;

namespace fcntl_ {

int fcntl(int fd, int cmd) {

  int result = ::fcntl(fd, cmd);

  if (result < 0) {

    throw new IOError(errno);

  }

  return result;

}

int fcntl(int fd, int cmd, int arg) {

  int result = ::fcntl(fd, cmd, arg);

  if (result < 0) {

    throw new IOError(errno);

  }

  return result;

}

}  // namespace fcntl_

namespace posix {

int umask(int mask) {

  // note: assuming mode_t fits in an int

  return ::umask(mask);

}

int open(Str* path, int flags, int perms) {

  mylib::Str0 path0(path);

  return ::open(path0.Get(), flags, perms);

}

void dup2(int oldfd, int newfd) {

  if (::dup2(oldfd, newfd) < 0) {

    throw new OSError(errno);

  }

}

void putenv(Str* name, Str* value) {

  assert(name->IsNulTerminated());

  assert(value->IsNulTerminated());

  int overwrite = 1;

  int ret = ::setenv(name->data_, value->data_, overwrite);

  if (ret < 0) {

    throw new IOError(errno);

  }

}

mylib::LineReader* fdopen(int fd, Str* c_mode) {

  mylib::Str0 c_mode0(c_mode);

  FILE* f = ::fdopen(fd, c_mode0.Get());

  // TODO: raise exception

  assert(f);

  return new mylib::CFileLineReader(f);

}

void execve(Str* argv0, List<Str*>* argv, Dict<Str*, Str*>* environ) {

  mylib::Str0 _argv0(argv0);

  int n_args = len(argv);

  // never deallocated

  char** _argv = static_cast<char**>(malloc((n_args + 1) * sizeof(char*)));

  // Annoying const_cast

  // https://stackoverflow.com/questions/190184/execv-and-const-ness

  for (int i = 0; i < n_args; ++i) {

    _argv[i] = const_cast<char*>(argv->index_(i)->data_);

  }

  _argv[n_args] = nullptr;

  // Convert environ into an array of pointers to strings of the form: "k=v".

  int n_env = len(environ);

  char** envp = static_cast<char**>(malloc((n_env + 1) * sizeof(char*)));

  int i = 0;

  for (const auto& kv : environ->items_) {

    Str* k = kv.first;

    Str* v = kv.second;

    int joined_len = k->len_ + v->len_ + 1;

    char* buf = static_cast<char*>(malloc(joined_len + 1));

    memcpy(buf, k->data_, k->len_);

    buf[k->len_] = '=';

    memcpy(buf + k->len_ + 1, v->data_, v->len_);

    buf[joined_len] = '\0';

    envp[i++] = buf;

  }

  envp[n_env] = nullptr;

  int ret = ::execve(_argv0.Get(), _argv, envp);

  if (ret == -1) {

    throw new OSError(errno);

  }

  // NOTE(Jesse): ::execve() is specified to never return on success.  If we

  // hit this assertion, it returned successfully (or at least something other

  // than -1) but should have overwritten our address space with the invoked

  // process'

  InvalidCodePath();

}

}  // namespace posix

namespace time_ {

void tzset() {

  ::tzset();

}

time_t time() {

  return ::time(nullptr);

}

// NOTE(Jesse): time_t is specified to be an arithmetic type by C++. On most

// systems it's a 64-bit integer.  64 bits is used because 32 will overflow in

// 2038.  Someone on a comittee somewhere thought of that when moving to 64-bit

// architectures to prevent breaking ABI again; on 32-bit systems it's usually

// 32 bits.  Point being, using anything but the time_t typedef here could

// (unlikely, but possible) produce weird behavior.

time_t localtime(time_t ts) {

  tm* loc_time = ::localtime(&ts);

  time_t result = mktime(loc_time);

  return result;

}

Str* strftime(Str* s, time_t ts) {

  // TODO: may not work with mylib_leaky.h

  // https://github.com/oilshell/oil/issues/1221

  assert(s->IsNulTerminated());

  tm* loc_time = ::localtime(&ts);

  const int max_len = 1024;

  Str* result = OverAllocatedStr(max_len);

  int n = strftime(result->data(), max_len, s->data_, loc_time);

  if (n == 0) {

    // bash silently truncates on large format string like

    //   printf '%(%Y)T'

    // Oil doesn't mask errors

    // No error location info, but leaving it out points reliably to 'printf'

    e_die(CopyStr("strftime() result exceeds 1024 bytes"));

  }

  result->SetObjLenFromStrLen(n);

  return result;

}

}  // namespace time_