heck_orca-c/sysmisc.c

#include "gbuffer.h"
#include "oso.h"
#include "sysmisc.h"
#include <ctype.h>
#include <errno.h>
#include <sys/stat.h>

ORCA_FORCE_NO_INLINE
Cboard_error cboard_copy(Glyph const *gbuffer, Usz field_height,
                         Usz field_width, Usz rect_y, Usz rect_x, Usz rect_h,
                         Usz rect_w) {
  (void)field_height;
  FILE *fp =
#ifdef ORCA_OS_MAC
      popen("pbcopy -pboard general 2>/dev/null", "w");
#else
      popen("xclip -i -selection clipboard 2>/dev/null", "w");
#endif
  if (!fp)
    return Cboard_error_popen_failed;
  for (Usz iy = 0; iy < rect_h; iy++) {
    Glyph const *row = gbuffer + (rect_y + iy) * field_width + rect_x;
    fwrite(row, sizeof(Glyph), rect_w, fp);
    if (iy + 1 < rect_h)
      fputc('\n', fp);
  }
  int status = pclose(fp);
  return status ? Cboard_error_process_exit_error : Cboard_error_none;
}

ORCA_FORCE_NO_INLINE
Cboard_error cboard_paste(Glyph *gbuffer, Usz height, Usz width, Usz y, Usz x,
                          Usz *out_h, Usz *out_w) {
  FILE *fp =
#ifdef ORCA_OS_MAC
      popen("pbpaste -pboard general -Prefer txt 2>/dev/null", "r");
#else
      popen("xclip -o -selection clipboard 2>/dev/null", "r");
#endif
  Usz start_y = y, start_x = x, max_y = y, max_x = x;
  if (!fp)
    return Cboard_error_popen_failed;
  char inbuff[512];
  for (;;) {
    size_t n = fread(inbuff, 1, sizeof inbuff, fp);
    for (size_t i = 0; i < n; i++) {
      char c = inbuff[i];
      if (c == '\r' || c == '\n') {
        y++;
        x = start_x;
        continue;
      }
      if (c != ' ' && y < height && x < width) {
        Glyph g = is_valid_glyph((Glyph)c) ? (Glyph)c : '.';
        gbuffer_poke(gbuffer, height, width, y, x, g);
        if (x > max_x)
          max_x = x;
        if (y > max_y)
          max_y = y;
      }
      x++;
    }
    if (n < sizeof inbuff)
      break;
  }
  int status = pclose(fp);
  *out_h = max_y - start_y + 1;
  *out_w = max_x - start_x + 1;
  return status ? Cboard_error_process_exit_error : Cboard_error_none;
}

ORCA_FORCE_NO_INLINE
Conf_read_result conf_read_line(FILE *file, char *buf, Usz bufsize,
                                char **out_left, Usz *out_leftsize,
                                char **out_right, Usz *out_rightsize) {
  // a0 and a1 are the start and end positions of the left side of an "foo=bar"
  // pair. b0 and b1 are the positions right side. Leading and trailing spaces
  // will be removed.
  Usz len, a0, a1, b0, b1;
  char *s;
  if (bufsize < 2)
    goto insufficient_buffer;
#if SIZE_MAX > INT_MAX
  if (bufsize > (Usz)INT_MAX)
    exit(1); // he boot too big
#endif
  s = fgets(buf, (int)bufsize, file);
  if (!s) {
    if (feof(file))
      goto eof;
    goto ioerror;
  }
  len = strlen(buf);
  if (len == bufsize - 1 && buf[len - 1] != '\n' && !feof(file))
    goto insufficient_buffer;
  a0 = 0;
  for (;;) { // scan for first non-space in "   foo=bar"
    if (a0 == len)
      goto ignore;
    char c = s[a0];
    if (c == ';' || c == '#') // comment line, ignore
      goto ignore;
    if (c == '=') // '=' before any other char, bad
      goto ignore;
    if (!isspace(c))
      break;
    a0++;
  }
  a1 = a0;
  for (;;) { // scan for '='
    a1++;
    if (a1 == len)
      goto ignore;
    char c = s[a1];
    Usz x = a1; // don't include any whitespace preceeding the '='
    while (isspace(c)) {
      x++;
      if (x == len)
        goto ignore;
      c = s[x];
    }
    if (c == '=') {
      b0 = x;
      break;
    }
    a1 = x;
  }
  for (;;) { // scan for first non-whitespace after '='
    b0++;
    if (b0 == len)
      goto ignore;
    char c = s[b0];
    if (!isspace(c))
      break;
  }
  b1 = b0;
  for (;;) { // scan for end of useful stuff for right-side value
    b1++;
    if (b1 == len)
      goto ok;
    char c = s[b1];
    Usz x = b1; // don't include any whitespace preceeding the EOL
    while (isspace(c)) {
      x++;
      if (x == len)
        goto ok;
      c = s[x];
    }
    b1 = x;
  }
  Conf_read_result err;
insufficient_buffer:
  err = Conf_read_buffer_too_small;
  goto fail;
eof:
  err = Conf_read_eof;
  goto fail;
ioerror:
  err = Conf_read_io_error;
  goto fail;
fail:
  *out_left = NULL;
  *out_leftsize = 0;
  goto no_right;
ignore:
  s[len - 1] = '\0';
  *out_left = s;
  *out_leftsize = len;
  err = Conf_read_irrelevant;
  goto no_right;
no_right:
  *out_right = NULL;
  *out_rightsize = 0;
  return err;
ok:
  s[a1] = '\0';
  s[b1] = '\0';
  *out_left = s + a0;
  *out_leftsize = a1 - a0;
  *out_right = s + b0;
  *out_rightsize = b1 - b0;
  return Conf_read_left_and_right;
}

bool conf_read_match(FILE **pfile, char const *const *names, Usz nameslen,
                     char *buf, Usz bufsize, Usz *out_index, char **out_value) {
  FILE *file = *pfile;
  if (!file)
    return false;
  char *left;
  Usz leftsz, rightsz;
next_line:;
  Conf_read_result res =
      conf_read_line(file, buf, bufsize, &left, &leftsz, out_value, &rightsz);
  switch (res) {
  case Conf_read_left_and_right:
    for (Usz i = 0; i < nameslen; i++) {
      if (strcmp(names[i], left) == 0) {
        *out_index = i;
        return true;
      }
    }
    goto next_line;
  case Conf_read_irrelevant:
    goto next_line;
  case Conf_read_buffer_too_small:
  case Conf_read_eof:
  case Conf_read_io_error:
    break;
  }
  fclose(file);
  *pfile = NULL;
  return false;
}

typedef enum {
  Conf_dir_ok = 0,
  Conf_dir_no_home,
} Conf_dir_error;

static char const *const xdg_config_home_env = "XDG_CONFIG_HOME";
static char const *const home_env = "HOME";
static char const *const conf_file_name = "/orca.conf";

static Conf_dir_error try_get_conf_dir(oso **out) {
  char const *xdgcfgdir = getenv(xdg_config_home_env);
  if (xdgcfgdir) {
    Usz xdgcfgdirlen = strlen(xdgcfgdir);
    if (xdgcfgdirlen > 0) {
      osoputlen(out, xdgcfgdir, xdgcfgdirlen);
      return Conf_dir_ok;
    }
  }
  char const *homedir = getenv(home_env);
  if (homedir) {
    Usz homedirlen = strlen(homedir);
    if (homedirlen > 0) {
      osoputprintf(out, "%s/.config", homedir);
      return Conf_dir_ok;
    }
  }
  return Conf_dir_no_home;
}

FILE *conf_file_open_for_reading(void) {
  oso *path = NULL;
  if (try_get_conf_dir(&path))
    return NULL;
  osocat(&path, conf_file_name);
  if (!path)
    return NULL;
  FILE *file = fopen(osoc(path), "r");
  osofree(path);
  return file;
}

Conf_save_start_error conf_save_start(Conf_save *p) {
  memset(p, 0, sizeof(Conf_save));
  oso *dir = NULL;
  Conf_save_start_error err;
  if (try_get_conf_dir(&dir)) {
    err = Conf_save_start_no_home;
    goto cleanup;
  }
  if (!dir) {
    err = Conf_save_start_alloc_failed;
    goto cleanup;
  }
  osoputoso(&p->canonpath, dir);
  osocat(&p->canonpath, conf_file_name);
  if (!p->canonpath) {
    err = Conf_save_start_alloc_failed;
    goto cleanup;
  }
  osoputoso(&p->temppath, p->canonpath);
  osocat(&p->temppath, ".tmp");
  if (!p->temppath) {
    err = Conf_save_start_alloc_failed;
    goto cleanup;
  }
  // Remove old temp file if it exists. If it exists and we can't remove it,
  // error.
  if (unlink(osoc(p->temppath)) == -1 && errno != ENOENT) {
    switch (errno) {
    case ENOTDIR:
      err = Conf_save_start_conf_dir_not_dir;
      break;
    case EACCES:
      err = Conf_save_start_temp_file_perm_denied;
      break;
    default:
      err = Conf_save_start_old_temp_file_stuck;
      break;
    }
    goto cleanup;
  }
  p->tempfile = fopen(osoc(p->temppath), "w");
  if (!p->tempfile) {
    // Try to create config dir, in case it doesn't exist. (XDG says we should
    // do this, and use mode 0700.)
    mkdir(osoc(dir), 0700);
    p->tempfile = fopen(osoc(p->temppath), "w");
  }
  if (!p->tempfile) {
    err = Conf_save_start_temp_file_open_failed;
    goto cleanup;
  }
  // This may be left as NULL.
  p->origfile = fopen(osoc(p->canonpath), "r");
  // We did it, boys.
  osofree(dir);
  return Conf_save_start_ok;

cleanup:
  osofree(dir);
  conf_save_cancel(p);
  return err;
}

void conf_save_cancel(Conf_save *p) {
  osofree(p->canonpath);
  osofree(p->temppath);
  if (p->origfile)
    fclose(p->origfile);
  if (p->tempfile)
    fclose(p->tempfile);
  memset(p, 0, sizeof(Conf_save));
}

Conf_save_commit_error conf_save_commit(Conf_save *p) {
  Conf_save_commit_error err;
  fclose(p->tempfile);
  p->tempfile = NULL;
  if (p->origfile) {
    fclose(p->origfile);
    p->origfile = NULL;
  }
  // This isn't really atomic. But if we want to close and move a file
  // simultaneously, I think we have to use OS-specific facilities. So I guess
  // this is the best we can do for now. I could be wrong, though. But I
  // couldn't find any good information about it.
  if (rename(osoc(p->temppath), osoc(p->canonpath)) == -1) {
    err = Conf_save_commit_rename_failed;
    goto cleanup;
  }
  err = Conf_save_commit_ok;
cleanup:
  conf_save_cancel(p);
  return err;
}

char const *ezconf_write_error_string(Ezconf_write_error error) {
  switch (error) {
  case Ezconf_write_ok:
    return "No error";
  case Ezconf_write_oom:
    return "Out of memory";
  case Ezconf_write_no_home:
    return "Unable to resolve $XDG_CONFIG_HOME or $HOME";
  case Ezconf_write_mkdir_failed:
    return "Unable to create $XDG_CONFIG_HOME or $HOME/.config directory";
  case Ezconf_write_conf_dir_not_dir:
    return "Config directory path is not a directory";
  case Ezconf_write_old_temp_file_stuck:
    return "Unable to remove old orca.conf.tmp file";
  case Ezconf_write_temp_file_perm_denied:
    return "Permission denied for config directory";
  case Ezconf_write_temp_open_failed:
    return "Unable to open orca.conf.tmp for writing";
  case Ezconf_write_temp_fsync_failed:
    return "fsync() reported an when writing temp file.\n"
           "Refusing to continue.";
  case Ezconf_write_temp_close_failed:
    return "Unable to close temp file";
  case Ezconf_write_rename_failed:
    return "Unable to rename orca.conf.tmp to orca.conf";
  case Ezconf_write_line_too_long:
    return "Line in file is too long";
  case Ezconf_write_existing_read_error:
    return "Error when reading existing configuration file";
  case Ezconf_write_unknown_error:
    break;
  }
  return "Unknown";
}

void ezconf_read_start(Ezconf_read *ezcr) {
  ezcr->file = conf_file_open_for_reading();
  ezcr->index = 0;
  ezcr->value = NULL;
}

bool ezconf_read_step(Ezconf_read *ezcr, char const *const *names,
                      Usz nameslen) {
  return conf_read_match(&ezcr->file, names, nameslen, ezcr->buffer,
                         sizeof ezcr->buffer, &ezcr->index, &ezcr->value);
}

enum {
  Confwflag_add_newline = 1 << 0,
};

void ezconf_write_start(Ezconf_write *ezcw, Confopt_w *optsbuffer,
                        size_t buffercap) {
  *ezcw = (Ezconf_write){0};
  ezcw->opts = optsbuffer;
  ezcw->optscap = buffercap;
  Ezconf_write_error error = Ezconf_write_unknown_error;
  switch (conf_save_start(&ezcw->save)) {
  case Conf_save_start_ok:
    error = Ezconf_write_ok;
    ezcw->file = ezcw->save.tempfile;
    break;
  case Conf_save_start_alloc_failed:
    error = Ezconf_write_oom;
    break;
  case Conf_save_start_no_home:
    error = Ezconf_write_no_home;
    break;
  case Conf_save_start_mkdir_failed:
    error = Ezconf_write_mkdir_failed;
    break;
  case Conf_save_start_conf_dir_not_dir:
    error = Ezconf_write_conf_dir_not_dir;
    break;
  case Conf_save_start_old_temp_file_stuck:
    error = Ezconf_write_old_temp_file_stuck;
    break;
  case Conf_save_start_temp_file_perm_denied:
    error = Ezconf_write_temp_file_perm_denied;
    break;
  case Conf_save_start_temp_file_open_failed:
    error = Ezconf_write_temp_open_failed;
    break;
  }
  ezcw->error = error;
}
void ezconf_write_addopt(Ezconf_write *ezcw, char const *key, intptr_t id) {
  size_t count = ezcw->optscount, cap = ezcw->optscap;
  if (count == cap)
    return;
  ezcw->opts[count] = (Confopt_w){.name = key, .id = id, .written = 0};
  ezcw->optscount = count + 1;
}
bool ezconf_write_step(Ezconf_write *ezcw) {
  U32 stateflags = ezcw->stateflags;
  FILE *origfile = ezcw->save.origfile, *tempfile = ezcw->save.tempfile;
  Confopt_w *opts = ezcw->opts, *chosen = NULL;
  size_t optscount = ezcw->optscount;
  if (ezcw->error || !tempfile) // Already errored or finished ok
    return false;
  // If we set a flag to write a closing newline the last time we were called,
  // write it now.
  if (stateflags & Confwflag_add_newline) {
    fputs("\n", tempfile);
    stateflags &= ~(U32)Confwflag_add_newline;
  }
  if (!optscount)
    goto commit;
  if (!origfile)
    goto write_leftovers;
  for (;;) { // Scan through file looking for known keys in key=value lines
    char linebuff[1024];
    char *left, *right;
    Usz leftsz, rightsz;
    Conf_read_result res = conf_read_line(origfile, linebuff, sizeof linebuff,
                                          &left, &leftsz, &right, &rightsz);
    switch (res) {
    case Conf_read_left_and_right: {
      for (size_t i = 0; i < optscount; i++) {
        char const *name = opts[i].name;
        if (!name)
          continue;
        if (strcmp(name, left) != 0)
          continue;
        // If we already wrote this one, comment out the line instead, and move
        // on to the next line.
        if (opts[i].written) {
          fputs("# ", tempfile);
          goto write_landr;
        }
        chosen = opts + i;
        goto return_for_writing;
      }
    write_landr:
      fputs(left, tempfile);
      fputs(" = ", tempfile);
      fputs(right, tempfile);
      fputs("\n", tempfile);
      continue;
    }
    case Conf_read_irrelevant:
      fputs(left, tempfile);
      fputs("\n", tempfile);
      continue;
    case Conf_read_eof:
      goto end_original;
    case Conf_read_buffer_too_small:
      ezcw->error = Ezconf_write_line_too_long;
      goto cancel;
    case Conf_read_io_error:
      ezcw->error = Ezconf_write_existing_read_error;
      goto cancel;
    }
  }
end_original: // Don't need original file anymore
  fclose(origfile);
  ezcw->save.origfile = origfile = NULL;
write_leftovers: // Write out any guys that weren't in original file.
  for (;;) {     // Find the first guy that wasn't already written.
    if (!optscount)
      goto commit;
    chosen = opts;
    // Drop the guy from the front of the list. This is to reduce super-linear
    // complexity growth as the number of conf key-value pairs are increased.
    // (Otherwise, we iterate the full set of guys on each call during the
    // "write the leftovers" phase.)
    opts++;
    optscount--;
    if (!chosen->written)
      break;
  }
  // Once control has reached here, we're going to return true to the caller.
  // Which means we expect to be called at least one more time. So update the
  // pointers stored in the persistent state, so that we don't have to scan
  // through as much of this list next time. (This might even end up finishing
  // it off, making it empty.)
  ezcw->opts = opts;
  ezcw->optscount = optscount;
return_for_writing:
  chosen->written = true;
  fputs(chosen->name, tempfile);
  fputs(" = ", tempfile);
  ezcw->optid = chosen->id;
  stateflags |= (U32)Confwflag_add_newline;
  ezcw->stateflags = stateflags;
  return true;
cancel:
  conf_save_cancel(&ezcw->save);
  // ^- Sets tempfile to null, which we use as a guard at the top of this
  //    function.
  ezcw->file = NULL;
  ezcw->stateflags = 0;
  return false;
commit:;
  Ezconf_write_error error = Ezconf_write_unknown_error;
  switch (conf_save_commit(&ezcw->save)) {
  case Conf_save_commit_ok:
    error = Ezconf_write_ok;
    break;
  case Conf_save_commit_temp_fsync_failed:
    error = Ezconf_write_temp_fsync_failed;
    break;
  case Conf_save_commit_temp_close_failed:
    error = Ezconf_write_temp_close_failed;
    break;
  case Conf_save_commit_rename_failed:
    error = Ezconf_write_rename_failed;
    break;
  }
  ezcw->file = NULL;
  ezcw->error = error;
  ezcw->stateflags = 0;
  return false;
}