/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-â
âvi: set et ft=c ts=8 tw=8 fenc=utf-8                                       :viâ
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
â                                                                              â
â  Musl Libc                                                                   â
â  Copyright Â© 2005-2014 Rich Felker, et al.                                   â
â                                                                              â
â  Permission is hereby granted, free of charge, to any person obtaining       â
â  a copy of this software and associated documentation files (the             â
â  "Software"), to deal in the Software without restriction, including         â
â  without limitation the rights to use, copy, modify, merge, publish,         â
â  distribute, sublicense, and/or sell copies of the Software, and to          â
â  permit persons to whom the Software is furnished to do so, subject to       â
â  the following conditions:                                                   â
â                                                                              â
â  The above copyright notice and this permission notice shall be              â
â  included in all copies or substantial portions of the Software.             â
â                                                                              â
â  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             â
â  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          â
â  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      â
â  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        â
â  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        â
â  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           â
â  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      â
â                                                                              â
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ*/
#include "libc/mem/alg.h"
#include "libc/calls/calls.h"
#include "libc/calls/struct/dirent.h"
#include "libc/calls/struct/stat.h"
#include "libc/errno.h"
#include "libc/mem/mem.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/dt.h"
#include "libc/sysv/consts/s.h"
#include "third_party/musl/fnmatch.h"
#include "third_party/musl/glob.h"

#define MAXPATH 1024

asm(".ident\t\"\\n\\n\
Musl libc (MIT License)\\n\
Copyright 2005-2014 Rich Felker, et. al.\"");
asm(".include \"libc/disclaimer.inc\"");

struct GlobList {
  struct GlobList *next;
  char name[];
};

static int AppendGlob(struct GlobList **tail, const char *name, size_t len,
                      int mark) {
  struct GlobList *new;
  if ((new = malloc(sizeof(struct GlobList) + len + 2))) {
    (*tail)->next = new;
    new->next = NULL;
    memcpy(new->name, name, len + 1);
    if (mark && len && name[len - 1] != '/') {
      new->name[len] = '/';
      new->name[len + 1] = 0;
    }
    *tail = new;
    return 0;
  } else {
    return -1;
  }
}

static int PerformGlob(char *buf, size_t pos, int type, char *pat, int flags,
                       int (*errfunc)(const char *path, int err),
                       struct GlobList **tail) {
  DIR *dir;
  size_t l;
  char *p, *p2;
  char saved_sep;
  ptrdiff_t i, j;
  struct stat st;
  struct dirent *de;
  int r, readerr, in_bracket, overflow, old_errno, fnm_flags;
  /* If GLOB_MARK is unused, we don't care about type. */
  if (!type && !(flags & GLOB_MARK)) type = DT_REG;
  /* Special-case the remaining pattern being all slashes, in
   * which case we can use caller-passed type if it's a dir. */
  if (*pat && type != DT_DIR) type = 0;
  while (pos + 1 < MAXPATH && *pat == '/') {
    buf[pos++] = *pat++;
  }
  /* Consume maximal [escaped-]literal prefix of pattern, copying
   * and un-escaping it to the running buffer as we go. */
  i = 0;
  j = 0;
  overflow = 0;
  in_bracket = 0;
  for (; pat[i] != '*' && pat[i] != '?' && (!in_bracket || pat[i] != ']');
       i++) {
    if (!pat[i]) {
      if (overflow) return 0;
      pat += i;
      pos += j;
      i = j = 0;
      break;
    } else if (pat[i] == '[') {
      in_bracket = 1;
    } else if (pat[i] == '\\' && !(flags & GLOB_NOESCAPE)) {
      /* Backslashes inside a bracket are (at least by
       * our interpretation) non-special, so if next
       * char is ']' we have a complete expression. */
      if (in_bracket && pat[i + 1] == ']') break;
      /* Unpaired final backslash never matches. */
      if (!pat[i + 1]) return 0;
      i++;
    }
    if (pat[i] == '/') {
      if (overflow) return 0;
      in_bracket = 0;
      pat += i + 1;
      i = -1;
      pos += j + 1;
      j = -1;
    }
    /* Only store a character if it fits in the buffer, but if
     * a potential bracket expression is open, the overflow
     * must be remembered and handled later only if the bracket
     * is unterminated (and thereby a literal), so as not to
     * disallow long bracket expressions with short matches. */
    if (pos + (j + 1) < MAXPATH) {
      buf[pos + j++] = pat[i];
    } else if (in_bracket) {
      overflow = 1;
    } else {
      return 0;
    }
    /* If we consume any new components, the caller-passed type
     * or dummy type from above is no longer valid. */
    type = 0;
  }
  buf[pos] = 0;
  if (!*pat) {
    /* If we consumed any components above, or if GLOB_MARK is
     * requested and we don't yet know if the match is a dir,
     * we must call stat to confirm the file exists and/or
     * determine its type. */
    if ((flags & GLOB_MARK) && type == DT_LNK) type = 0;
    if (!type && stat(buf, &st)) {
      if (errno != ENOENT && (errfunc(buf, errno) || (flags & GLOB_ERR))) {
        return GLOB_ABORTED;
      }
      return 0;
    }
    if (!type && S_ISDIR(st.st_mode)) type = DT_DIR;
    if (AppendGlob(tail, buf, pos, (flags & GLOB_MARK) && type == DT_DIR)) {
      return GLOB_NOSPACE;
    }
    return 0;
  }
  p2 = strchr(pat, '/');
  saved_sep = '/';
  /* Check if the '/' was escaped and, if so, remove the escape char
   * so that it will not be unpaired when passed to fnmatch. */
  if (p2 && !(flags & GLOB_NOESCAPE)) {
    for (p = p2; p > pat && p[-1] == '\\'; p--)
      ;
    if ((p2 - p) % 2) {
      p2--;
      saved_sep = '\\';
    }
  }
  dir = opendir(pos ? buf : ".");
  if (!dir) {
    if (errfunc(buf, errno) || (flags & GLOB_ERR)) return GLOB_ABORTED;
    return 0;
  }
  old_errno = errno;
  while (errno = 0, de = readdir(dir)) {
    /* Quickly skip non-directories when there's pattern left. */
    if (p2 && de->d_type && de->d_type != DT_DIR && de->d_type != DT_LNK) {
      continue;
    }
    l = strlen(de->d_name);
    if (l >= MAXPATH - pos) continue;
    if (p2) *p2 = 0;
    fnm_flags = ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0) |
                ((!(flags & GLOB_PERIOD)) ? FNM_PERIOD : 0);
    if (fnmatch(pat, de->d_name, fnm_flags)) continue;
    /* With GLOB_PERIOD don't allow matching . or .. unless fnmatch()
     * would match them with FNM_PERIOD rules in effect. */
    if (p2 && (flags & GLOB_PERIOD) && de->d_name[0] == '.' &&
        (!de->d_name[1] || de->d_name[1] == '.' && !de->d_name[2]) &&
        fnmatch(pat, de->d_name, fnm_flags | FNM_PERIOD)) {
      continue;
    }
    memcpy(buf + pos, de->d_name, l + 1);
    if (p2) *p2 = saved_sep;
    r = PerformGlob(buf, pos + l, de->d_type, p2 ? p2 : "", flags, errfunc,
                    tail);
    if (r) {
      closedir(dir);
      return r;
    }
  }
  readerr = errno;
  if (p2) *p2 = saved_sep;
  closedir(dir);
  if (readerr && (errfunc(buf, errno) || (flags & GLOB_ERR))) {
    return GLOB_ABORTED;
  }
  errno = old_errno;
  return 0;
}

static int IgnoreGlobError(const char *path, int err) {
  return 0;
}

static void FreeGlobList(struct GlobList *head) {
  struct GlobList *match, *next;
  for (match = head->next; match; match = next) {
    next = match->next;
    free(match);
  }
}

static int GlobPredicate(const void *a, const void *b) {
  return strcmp(*(const char **)a, *(const char **)b);
}

/**
 * Finds pathnames matching pattern.
 *
 * For example:
 *
 *     glob_t g = {.gl_offs = 2};
 *     glob("*.*", GLOB_DOOFFS, NULL, &g);
 *     glob("../.*", GLOB_DOOFFS | GLOB_APPEND, NULL, &g);
 *     g.gl_pathv[0] = "ls";
 *     g.gl_pathv[1] = "-l";
 *     execvp("ls", &g.gl_pathv[0]);
 *     globfree(g);
 *
 * @param pat can have star wildcard see fnmatch()
 * @param g will receive matching entries and needs globfree()
 * @return 0 on success or GLOB_NOMATCH, GLOB_NOSPACE on OOM, or
 *     GLOB_ABORTED on read error
 */
int glob(const char *pat, int flags, int errfunc(const char *path, int err),
         glob_t *g) {
  int error = 0;
  size_t cnt, i;
  char *p, **pathv, buf[MAXPATH];
  struct GlobList head = {.next = NULL}, *tail = &head;
  size_t offs = (flags & GLOB_DOOFFS) ? g->gl_offs : 0;
  if (!errfunc) errfunc = IgnoreGlobError;
  if (!(flags & GLOB_APPEND)) {
    g->gl_offs = offs;
    g->gl_pathc = 0;
    g->gl_pathv = NULL;
  }
  if (*pat) {
    char *p = strdup(pat);
    if (!p) return GLOB_NOSPACE;
    buf[0] = 0;
    error = PerformGlob(buf, 0, 0, p, flags, errfunc, &tail);
    free(p);
  }
  if (error == GLOB_NOSPACE) {
    FreeGlobList(&head);
    return error;
  }
  for (cnt = 0, tail = head.next; tail; tail = tail->next, cnt++)
    ;
  if (!cnt) {
    if (flags & GLOB_NOCHECK) {
      tail = &head;
      if (AppendGlob(&tail, pat, strlen(pat), 0)) {
        return GLOB_NOSPACE;
      }
      cnt++;
    } else
      return GLOB_NOMATCH;
  }
  if (flags & GLOB_APPEND) {
    pathv =
        realloc(g->gl_pathv, (offs + g->gl_pathc + cnt + 1) * sizeof(char *));
    if (!pathv) {
      FreeGlobList(&head);
      return GLOB_NOSPACE;
    }
    g->gl_pathv = pathv;
    offs += g->gl_pathc;
  } else {
    g->gl_pathv = malloc((offs + cnt + 1) * sizeof(char *));
    if (!g->gl_pathv) {
      FreeGlobList(&head);
      return GLOB_NOSPACE;
    }
    for (i = 0; i < offs; i++) {
      g->gl_pathv[i] = NULL;
    }
  }
  for (i = 0, tail = head.next; i < cnt; tail = tail->next, i++) {
    g->gl_pathv[offs + i] = tail->name;
  }
  g->gl_pathv[offs + i] = NULL;
  g->gl_pathc += cnt;
  if (!(flags & GLOB_NOSORT)) {
    qsort(g->gl_pathv + offs, cnt, sizeof(char *), GlobPredicate);
  }
  return error;
}

/**
 * Frees entries allocated by glob().
 */
void globfree(glob_t *g) {
  size_t i;
  for (i = 0; i < g->gl_pathc; i++) {
    free(g->gl_pathv[g->gl_offs + i] - offsetof(struct GlobList, name));
  }
  free(g->gl_pathv);
  g->gl_pathc = 0;
  g->gl_pathv = NULL;
}
