/***************************************************************************

 *                                  _   _ ____  _

 *  Project                     ___| | | |  _ \| |

 *                             / __| | | | |_) | |

 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms

 * are also available at https://curl.se/docs/copyright.html.

 *

 * You may opt to use, copy, modify, merge, publish, distribute and/or sell

 * copies of the Software, and permit persons to whom the Software is

 * furnished to do so, under the terms of the COPYING file.

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

 * KIND, either express or implied.

 *

 * SPDX-License-Identifier: curl

 *

 ***************************************************************************/

#include "curl_setup.h"

#ifndef CURL_DISABLE_NETRC

#ifdef HAVE_PWD_H

#ifdef __AMIGA__

#undef __NO_NET_API /* required for AmigaOS to declare getpwuid() */

#endif

#include <pwd.h>

#ifdef __AMIGA__

#define __NO_NET_API

#endif

#endif

#include "netrc.h"

#include "urldata.h"

#include "creds.h"

#include "curl_trc.h"

#include "strcase.h"

#include "curl_get_line.h"

#include "curlx/fopen.h"

#include "curlx/strparse.h"

/* .netrc is not really a standard. The GNU definition can be found here:

 * https://www.gnu.org/software/inetutils/manual/html_node/The-_002enetrc-file.html

 * This gives grammar like:

 *

 * LITERAL := \S+ | QUOTED

 * QUOTED  := "(\\[rnt\]|[^"])*"

 * ANYTHING := .

 * EMPTY_LINE := \r*\n\r*\n

 * MACHINE := machine         # case-insensitive

 * LOGIN   := login           # case-insensitive

 * PASSWD  := password        # case-insensitive

 * ACCOUNT := account         # case-insensitive

 * MACDEF  := macdef          # case-insensitive

 * DEFAULT := default         # case-insensitive

 *

 * MACRO   := MACDEF ANYTHING* EMPTY_LINE

 * JUNK    := LITERAL

 * LKEY     := ( LOGIN | PASSWD | ACCOUNT ) LITERAL

 * MENTRY   := MACHINE LITERAL LKEY*

 * DENTRY   := DEFAULT LKEY*

 * NETRC   := (MENTRY | DENTRY | MACRO | JUNK )* EOF

 *

 * Tokens are separated by whitespace or newlines. which have otherwise

 * no special meaning, apart from the empty line ending a MACRO.

 *

 * Parsing is not strict, unmatched LITERALs are ignored

 */

#define MAX_NETRC_LINE  16384

#define MAX_NETRC_FILE  (128 * 1024)

#define MAX_NETRC_TOKEN 4096

#define NETRC_DEBUG   0

/* convert a dynbuf call CURLcode error to a NETRCcode error */

#define curl2netrc(r)                                  \

  ((!(r)) ? NETRC_OK : (((r) == CURLE_OUT_OF_MEMORY) ? \

   NETRC_OUT_OF_MEMORY : NETRC_SYNTAX_ERROR))

typedef enum {

  NETRC_TOK_EOF,

  NETRC_TOK_LITERAL,

  NETRC_TOK_MACHINE,

  NETRC_TOK_DEFAULT,

  NETRC_TOK_ACCOUNT,

  NETRC_TOK_LOGIN,

  NETRC_TOK_PASSWD,

  NETRC_TOK_MACDEF,

  NETRC_TOK_JUNK

} curl_netrc_token;

struct netrc_lexer {

  struct Curl_easy *data;

  const char *content;

  const char *pos;

  struct dynbuf literal;

  curl_netrc_token token;

  bool pushed;

};

#if NETRC_DEBUG

static const char *netrc_tokenstr(curl_netrc_token token)

{

  switch(token) {

  case NETRC_TOK_EOF:

    return "[EOF]";

  case NETRC_TOK_LITERAL:

    return "[LITERAL]";

  case NETRC_TOK_MACHINE:

    return "[MACHINE]";

  case NETRC_TOK_DEFAULT:

    return "[DEFAULT]";

  case NETRC_TOK_ACCOUNT:

    return "[ACCOUNT]";

  case NETRC_TOK_LOGIN:

    return "[LOGIN]";

  case NETRC_TOK_PASSWD:

    return "[PASSWORD]";

  case NETRC_TOK_MACDEF:

    return "[MACDEF]";

  case NETRC_TOK_JUNK:

    return "[JUNK]";

  default:

    return "[???]";

  }

}

#endif

static void netrc_lexer_init(struct netrc_lexer *lexer,

                             struct Curl_easy *data,

                             const char *content)

{

  curlx_dyn_init(&lexer->literal, MAX_NETRC_TOKEN);

  lexer->data = data;

  lexer->content = lexer->pos = content;

}

static void netrc_lexer_cleanup(struct netrc_lexer *lexer)

{

  lexer->content = lexer->pos = NULL;

  lexer->data = NULL;

  curlx_dyn_free(&lexer->literal);

}

static void netrc_skip_blanks(struct netrc_lexer *lexer)

{

  const char *s = lexer->pos;

  while(*s) {

    curlx_str_passblanks(&s);

    while(*s == '\r')

      ++s;

    if(*s == '\n') {

      ++s;

    }

    else

      break;

  }

  lexer->pos = s;

}

static void netrc_skip_to_empty_line(struct netrc_lexer *lexer)

{

  const char *s = lexer->pos;

  while(*s) {

    if(*s == '\r')

      ++s;

    else if(*s == '\n') {

      ++s;

      while(*s == '\r')

        ++s;

      if(*s == '\n')

        goto out;

    }

    else

      ++s;

  }

out:

  lexer->pos = s;

}

/*

 * Parse a quoted token starting after the opening '"'. Handles \n, \r, \t

 * escape sequences. Advances *tok_endp past the closing '"'.

 *

 * Returns NETRC_OK or error.

 */

static NETRCcode netrc_lexer_quoted(struct netrc_lexer *lexer)

{

  NETRCcode rc = NETRC_SYNTAX_ERROR;

  const char *s = lexer->pos;

  bool escape = FALSE;

  CURLcode result;

  DEBUGASSERT(*s == '\"');

  ++s; /* pass the leading quote */

  while(*s) {

    char c = *s;

    if(escape) {

      escape = FALSE;

      switch(c) {

      case 'n':

        c = '\n';

        break;

      case 'r':

        c = '\r';

        break;

      case 't':

        c = '\t';

        break;

      }

    }

    else if(c == '\\') {

      escape = TRUE;

      ++s;

      continue;

    }

    else if(c == '\"') {

      ++s; /* pass the ending quote */

      rc = NETRC_OK;

      goto out;

    }

    result = curlx_dyn_addn(&lexer->literal, &c, 1);

    if(result) {

      rc = curl2netrc(result);

      goto out;

    }

    ++s;

  }

out:

  lexer->pos = s;

  return rc;

}

static void netrc_lexer_push(struct netrc_lexer *lexer)

{

  lexer->pushed = TRUE;

}

static NETRCcode netrc_lexer_next(struct netrc_lexer *lexer,

                                  bool want_literal)

{

  const char *s = lexer->pos, *start;

  NETRCcode rc = NETRC_OK;

  size_t slen;

  CURLcode result;

  if(lexer->pushed) {

    lexer->pushed = FALSE;

    goto out;

  }

  curlx_dyn_reset(&lexer->literal);

  netrc_skip_blanks(lexer);

  s = lexer->pos;

  switch(*s) {

  case 0:

    lexer->token = NETRC_TOK_EOF;

    break;

  case '\"':

    rc = netrc_lexer_quoted(lexer);

    lexer->token = NETRC_TOK_LITERAL;

    s = lexer->pos;

    break;

  default:

    /* unquoted token */

    start = s;

    while(*s && !ISBLANK(*s) && !ISNEWLINE(*s))

      ++s;

    slen = s - start;

    if(!slen) {

      rc = NETRC_SYNTAX_ERROR;

    }

    if(want_literal) {

      lexer->token = NETRC_TOK_LITERAL;

      result = curlx_dyn_addn(&lexer->literal, start, slen);

      rc = curl2netrc(result);

    }

    else if((slen == 7) && curl_strnequal(start, "machine", slen)) {

      lexer->token = NETRC_TOK_MACHINE;

    }

    else if((slen == 7) && curl_strnequal(start, "default", slen)) {

      lexer->token = NETRC_TOK_DEFAULT;

    }

    else if((slen == 7) && curl_strnequal(start, "account", slen)) {

      lexer->token = NETRC_TOK_ACCOUNT;

    }

    else if((slen == 5) && curl_strnequal(start, "login", slen)) {

      lexer->token = NETRC_TOK_LOGIN;

    }

    else if((slen == 8) && curl_strnequal(start, "password", slen)) {

      lexer->token = NETRC_TOK_PASSWD;

    }

    else if((slen == 6) && curl_strnequal(start, "macdef", slen)) {

      lexer->token = NETRC_TOK_MACDEF;

    }

    else {

      lexer->token = NETRC_TOK_JUNK;

    }

    break;

  }

out:

#if NETRC_DEBUG

  CURL_TRC_M(lexer->data, "[NETRC] token %s '%s', rc=%d",

             netrc_tokenstr(lexer->token),

             curlx_dyn_ptr(&lexer->literal), rc);

#endif

  lexer->pos = s;

  return rc;

}

struct netrc_scanner {

  struct netrc_lexer lexer;

  const char *hostname; /* non-NULL, machine to scan for */

  const char *user; /* maybe NULL, login to scan for */

  char *login;

  char *passwd;

  struct Curl_creds *creds;

  bool matches_host;

  bool found;

};

static void netrc_scan_reset(struct netrc_scanner *sc)

{

  curlx_safefree(sc->login);

  curlx_safefree(sc->passwd);

  sc->matches_host = FALSE;

}

static void netrc_scan_init(struct netrc_scanner *sc,

                            struct Curl_easy *data,

                            const char *content,

                            const char *hostname,

                            const char *user)

{

  memset(sc, 0, sizeof(*sc));

  netrc_lexer_init(&sc->lexer, data, content);

  sc->hostname = hostname;

  sc->user = (user && user[0]) ? user : NULL;

  netrc_scan_reset(sc);

}

static void netrc_scan_cleanup(struct netrc_scanner *sc)

{

  netrc_scan_reset(sc);

  sc->hostname = NULL;

  sc->user = NULL;

  Curl_creds_unlink(&sc->creds);

  netrc_lexer_cleanup(&sc->lexer);

}

static NETRCcode netrc_scan_literal(struct netrc_scanner *sc,

                                    char **pdest)

{

  NETRCcode rc = netrc_lexer_next(&sc->lexer, TRUE);

  if(!rc) {

    if(sc->lexer.token == NETRC_TOK_LITERAL) {

      if(pdest && sc->matches_host) {

        curlx_free(*pdest);

        *pdest = curlx_strdup(curlx_dyn_ptr(&sc->lexer.literal));

        if(!*pdest)

          rc = NETRC_OUT_OF_MEMORY;

      }

    }

    else

      netrc_lexer_push(&sc->lexer);

  }

  return rc;

}

static NETRCcode netrc_scan_end_entry(struct netrc_scanner *sc)

{

  NETRCcode rc = NETRC_OK;

#if NETRC_DEBUG

  CURL_TRC_M(sc->lexer.data,

             "[NETRC] entry matches_host=%d, login='%s', passwd='%s'",

             sc->matches_host, sc->login, sc->passwd);

#endif

  if(sc->matches_host) {

    if(sc->login) {

      if(sc->user) {

        if(Curl_timestrcmp(sc->user, sc->login))

          goto out;

        /* We look for a specific user,

         * entry is only interesting with password */

        sc->found = !!sc->passwd;

      }

      else {

        sc->found = TRUE;

      }

    }

    else if(sc->passwd) {

      /* found a passwd that applies to any user */

      sc->found = TRUE;

    }

    else {

      /* entry has nothing interesting */

    }

    if(sc->found) {

#if NETRC_DEBUG

      CURL_TRC_M(sc->lexer.data, "[NETRC] entry match found");

#endif

      if(Curl_creds_create(sc->user ? sc->user : sc->login, sc->passwd,

                           NULL, NULL, NULL, CREDS_NETRC, &sc->creds))

        rc = NETRC_OUT_OF_MEMORY;

    }

  }

out:

  netrc_scan_reset(sc);

  return rc;

}

static NETRCcode netrc_scan(struct Curl_easy *data,

                            const char *content,

                            const char *hostname,

                            const char *user,

                            struct Curl_creds **pcreds)

{

  struct netrc_scanner sc;

  NETRCcode rc = NETRC_OK;

  Curl_creds_unlink(pcreds);

  netrc_scan_init(&sc, data, content, hostname, user);

  while(!rc && !sc.found) {

    rc = netrc_lexer_next(&sc.lexer, FALSE);

    if(!rc) {

      /* Does this token end any previous entry? */

      switch(sc.lexer.token) {

      case NETRC_TOK_EOF:

      case NETRC_TOK_MACHINE:

      case NETRC_TOK_DEFAULT:

      case NETRC_TOK_MACDEF:

        rc = netrc_scan_end_entry(&sc);

        if(rc || sc.found)

          goto out;

        break;

      default:

        break;

      }

      switch(sc.lexer.token) {

      case NETRC_TOK_EOF:

        goto out;

      case NETRC_TOK_MACHINE:

        rc = netrc_lexer_next(&sc.lexer, TRUE);

        if(!rc) {

          if(sc.lexer.token == NETRC_TOK_LITERAL) {

            sc.matches_host = curl_strequal(

              sc.hostname, curlx_dyn_ptr(&sc.lexer.literal));

          }

          else {

            sc.matches_host = FALSE;

            netrc_lexer_push(&sc.lexer);

          }

        }

        break;

      case NETRC_TOK_DEFAULT:

        sc.matches_host = TRUE;

        break;

      case NETRC_TOK_ACCOUNT:

        rc = netrc_scan_literal(&sc, NULL); /* ignore, not used */

        break;

      case NETRC_TOK_LOGIN:

        rc = netrc_scan_literal(&sc, &sc.login);

        break;

      case NETRC_TOK_PASSWD:

        rc = netrc_scan_literal(&sc, &sc.passwd);

        break;

      case NETRC_TOK_MACDEF:

        netrc_skip_to_empty_line(&sc.lexer);

        break;

      case NETRC_TOK_LITERAL:

      case NETRC_TOK_JUNK:

      default:

        /* skip this */

        break;

      }

    }

  }

out:

  if(!rc) {

    if(sc.creds)

      Curl_creds_link(pcreds, sc.creds);

    else

      rc = NETRC_NO_MATCH;

  }

  netrc_scan_cleanup(&sc);

  return rc;

}

static NETRCcode file2memory(const char *filename, struct dynbuf *filebuf)

{

  NETRCcode ret = NETRC_FILE_MISSING; /* if it cannot open the file */

  FILE *file = curlx_fopen(filename, FOPEN_READTEXT);

  curlx_dyn_reset(filebuf);

  if(file) {

    curlx_struct_stat stat;

    if((curlx_fstat(fileno(file), &stat) == -1) || !S_ISDIR(stat.st_mode)) {

      CURLcode result = CURLE_OK;

      bool eof;

      struct dynbuf linebuf;

      curlx_dyn_init(&linebuf, MAX_NETRC_LINE);

      ret = NETRC_OK;

      do {

        const char *line;

        /* Curl_get_line always returns lines ending with a newline */

        result = Curl_get_line(&linebuf, file, &eof);

        if(!result) {

          line = curlx_dyn_ptr(&linebuf);

          /* skip comments on load */

          curlx_str_passblanks(&line);

          if(*line == '#')

            continue;

          result = curlx_dyn_add(filebuf, line);

        }

        if(result) {

          curlx_dyn_free(filebuf);

          ret = curl2netrc(result);

          break;

        }

      } while(!eof);

      curlx_dyn_free(&linebuf);

    }

    curlx_fclose(file);

  }

  return ret;

}

static NETRCcode netrc_scan_file(struct Curl_easy *data,

                                 struct store_netrc *store,

                                 const char *hostname,

                                 const char *user,

                                 const char *netrcfile,

                                 struct Curl_creds **pcreds)

{

  struct dynbuf *filebuf = &store->filebuf;

  if(!store->loaded || strcmp(netrcfile, store->filename)) {

    NETRCcode ret;

    store->loaded = FALSE;

    ret = file2memory(netrcfile, filebuf);

    if(ret) {

      CURL_TRC_M(data, "[NETRC] could not load '%s'", netrcfile);

      return ret;

    }

    curlx_free(store->filename);

    store->filename = curlx_strdup(netrcfile);

    if(!store->filename) {

      curlx_dyn_reset(&store->filebuf);

      return NETRC_OUT_OF_MEMORY;

    }

    store->loaded = TRUE;

  }

  return netrc_scan(data, curlx_dyn_ptr(filebuf), hostname, user, pcreds);

}

/*

 * @unittest: 1304

 *

 * *loginp and *passwordp MUST be allocated if they are not NULL when passed

 * in.

 */

NETRCcode Curl_netrc_scan(struct Curl_easy *data,

                          struct store_netrc *store,

                          const char *hostname,

                          const char *user,

                          const char *netrcfile,

                          struct Curl_creds **pcreds)

{

  NETRCcode retcode = NETRC_OK;

  CURL_TRC_M(data, "[NETRC] scanning '%s' for host '%s' user '%s'",

             netrcfile, hostname, user);

  Curl_creds_unlink(pcreds);

  if(!netrcfile) {

    char *home = NULL;

    char *homea = NULL;

    char *filealloc = NULL;

#if defined(HAVE_GETPWUID_R) && defined(HAVE_GETEUID)

    char pwbuf[1024];

#endif

    filealloc = curl_getenv("NETRC");

    if(!filealloc) {

      homea = curl_getenv("HOME"); /* portable environment reader */

      if(homea) {

        home = homea;

#if defined(HAVE_GETPWUID_R) && defined(HAVE_GETEUID)

      }

      else {

        struct passwd pw, *pw_res;

        if(!getpwuid_r(geteuid(), &pw, pwbuf, sizeof(pwbuf), &pw_res) &&

           pw_res) {

          home = pw.pw_dir;

        }

#elif defined(HAVE_GETPWUID) && defined(HAVE_GETEUID)

      }

      else {

        struct passwd *pw;

        pw = getpwuid(geteuid());

        if(pw) {

          home = pw->pw_dir;

        }

#elif defined(_WIN32)

      }

      else {

        homea = curl_getenv("USERPROFILE");

        if(homea) {

          home = homea;

        }

#endif

      }

      if(!home)

        return NETRC_FILE_MISSING; /* no home directory found (or possibly out

                                      of memory) */

      filealloc = curl_maprintf("%s%s.netrc", home, DIR_CHAR);

      if(!filealloc) {

        curlx_free(homea);

        retcode = NETRC_OUT_OF_MEMORY;

        goto out;

      }

    }

    retcode = netrc_scan_file(

      data, store, hostname, user, filealloc, pcreds);

    curlx_free(filealloc);

#ifdef _WIN32

    if(retcode == NETRC_FILE_MISSING) {

      /* fallback to the old-style "_netrc" file */

      filealloc = curl_maprintf("%s%s_netrc", home, DIR_CHAR);

      if(!filealloc) {

        curlx_free(homea);

        return NETRC_OUT_OF_MEMORY;

      }

      retcode = netrc_scan_file(

        data, store, hostname, user, filealloc, pcreds);

      curlx_free(filealloc);

    }

#endif

    curlx_free(homea);

  }

  else

    retcode = netrc_scan_file(

      data, store, hostname, user, netrcfile, pcreds);

out:

  if(retcode)

    Curl_creds_unlink(pcreds);

  return retcode;

}

void Curl_netrc_init(struct store_netrc *store)

{

  curlx_dyn_init(&store->filebuf, MAX_NETRC_FILE);

  store->loaded = FALSE;

  store->filename = NULL;

}

void Curl_netrc_cleanup(struct store_netrc *store)

{

  curlx_dyn_free(&store->filebuf);

  curlx_safefree(store->filename);

  store->loaded = FALSE;

}

const char *Curl_netrc_strerror(NETRCcode ret)

{

  switch(ret) {

  default:

    return ""; /* not a legit error */

  case NETRC_FILE_MISSING:

    return "no such file";

  case NETRC_NO_MATCH:

    return "no matching entry";

  case NETRC_OUT_OF_MEMORY:

    return "out of memory";

  case NETRC_SYNTAX_ERROR:

    return "syntax error";

  }

  /* never reached */

}

#endif /* !CURL_DISABLE_NETRC */