/*
  *  OpenVPN -- An application to securely tunnel IP networks
  *             over a single TCP/UDP port, with support for SSL/TLS-based
  *             session authentication and key exchange,
  *             packet encryption, packet authentication, and
  *             packet compression.
  *

  *  Copyright (C) 2002-2018 OpenVPN Inc <sales@openvpn.net>

  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
  *  as published by the Free Software Foundation.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *

  *  You should have received a copy of the GNU General Public License along
  *  with this program; if not, write to the Free Software Foundation, Inc.,
  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  *
  *
  *  A printf-like function (that only recognizes a subset of standard printf
  *  format operators) that prints arguments to an argv list instead
  *  of a standard string.  This is used to build up argv arrays for passing
  *  to execve.
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #elif defined(_MSC_VER)
 #include "config-msvc.h"
 #endif
 
 #include "syshead.h"
 
 #include "argv.h"

 #include "integer.h"

 #include "env_set.h"

 #include "options.h"
 

 static void

 argv_init(struct argv *a)

 {

     a->capacity = 0;
     a->argc = 0;
     a->argv = NULL;

 }
 
 struct argv

 argv_new(void)

 {

     struct argv ret;
     argv_init(&ret);
     return ret;

 }
 
 void

 argv_reset(struct argv *a)

 {

     size_t i;
     for (i = 0; i < a->argc; ++i)

     {

         free(a->argv[i]);

     }

     free(a->argv);
     argv_init(a);

 }
 
 static void

 argv_extend(struct argv *a, const size_t newcap)

 {

     if (newcap > a->capacity)

     {

         char **newargv;
         size_t i;
         ALLOC_ARRAY_CLEAR(newargv, char *, newcap);
         for (i = 0; i < a->argc; ++i)

         {

             newargv[i] = a->argv[i];

         }

         free(a->argv);
         a->argv = newargv;
         a->capacity = newcap;

     }
 }
 
 static void

 argv_grow(struct argv *a, const size_t add)

 {

     const size_t newargc = a->argc + add + 1;
     ASSERT(newargc > a->argc);
     argv_extend(a, adjust_power_of_2(newargc));

 }
 
 static void

 argv_append(struct argv *a, char *str)  /* str must have been malloced or be NULL */

 {

     argv_grow(a, 1);
     a->argv[a->argc++] = str;

 }
 
 static struct argv

 argv_clone(const struct argv *a, const size_t headroom)

 {

     struct argv r;
     size_t i;

     argv_init(&r);
     for (i = 0; i < headroom; ++i)

     {

         argv_append(&r, NULL);

     }

     if (a)

     {

         for (i = 0; i < a->argc; ++i)

         {

             argv_append(&r, string_alloc(a->argv[i], NULL));

         }

     }

     return r;

 }
 
 struct argv

 argv_insert_head(const struct argv *a, const char *head)

 {

     struct argv r;
     r = argv_clone(a, 1);
     r.argv[0] = string_alloc(head, NULL);
     return r;

 }
 

 static char *

 argv_term(const char **f)

 {

     const char *p = *f;
     const char *term = NULL;
     size_t termlen = 0;

     if (*p == '\0')
     {
         return NULL;
     }

     while (true)

     {

         const int c = *p;
         if (c == '\0')

         {
             break;
         }

         if (term)
         {
             if (!isspace(c))
             {
                 ++termlen;
             }
             else
             {
                 break;
             }
         }
         else

         {

             if (!isspace(c))

             {

                 term = p;
                 termlen = 1;

             }
         }

         ++p;

     }

     *f = p;

     if (term)
     {
         char *ret;
         ASSERT(termlen > 0);
         ret = malloc(termlen + 1);
         check_malloc_return(ret);
         memcpy(ret, term, termlen);
         ret[termlen] = '\0';
         return ret;
     }
     else

     {

         return NULL;

     }
 }
 
 const char *

 argv_str(const struct argv *a, struct gc_arena *gc, const unsigned int flags)

 {

     if (a->argv)
     {
         return print_argv((const char **)a->argv, gc, flags);
     }
     else
     {
         return "";
     }

 }
 
 void

 argv_msg(const int msglev, const struct argv *a)

 {

     struct gc_arena gc = gc_new();
     msg(msglev, "%s", argv_str(a, &gc, 0));
     gc_free(&gc);

 }
 
 void

 argv_msg_prefix(const int msglev, const struct argv *a, const char *prefix)

 {

     struct gc_arena gc = gc_new();
     msg(msglev, "%s: %s", prefix, argv_str(a, &gc, 0));
     gc_free(&gc);

 }
 

 static void

 argv_printf_arglist(struct argv *a, const char *format, va_list arglist)

 {

     char *term;
     const char *f = format;

     argv_extend(a, 1); /* ensure trailing NULL */

     while ((term = argv_term(&f)) != NULL)

     {

         if (term[0] == '%')

         {

             if (!strcmp(term, "%s"))

             {

                 char *s = va_arg(arglist, char *);
                 if (!s)
                 {
                     s = "";
                 }
                 argv_append(a, string_alloc(s, NULL));

             }

             else if (!strcmp(term, "%d"))

             {

                 char numstr[64];
                 openvpn_snprintf(numstr, sizeof(numstr), "%d", va_arg(arglist, int));
                 argv_append(a, string_alloc(numstr, NULL));

             }

             else if (!strcmp(term, "%u"))

             {

                 char numstr[64];
                 openvpn_snprintf(numstr, sizeof(numstr), "%u", va_arg(arglist, unsigned int));
                 argv_append(a, string_alloc(numstr, NULL));

             }

             else if (!strcmp(term, "%lu"))
             {
                 char numstr[64];
                 openvpn_snprintf(numstr, sizeof(numstr), "%lu",
                                  va_arg(arglist, unsigned long));
                 argv_append(a, string_alloc(numstr, NULL));
             }

             else if (!strcmp(term, "%s/%d"))

             {

                 char numstr[64];
                 char *s = va_arg(arglist, char *);
 
                 if (!s)
                 {
                     s = "";
                 }
 
                 openvpn_snprintf(numstr, sizeof(numstr), "%d", va_arg(arglist, int));
 
                 {
                     const size_t len = strlen(s) + strlen(numstr) + 2;
                     char *combined = (char *) malloc(len);
                     check_malloc_return(combined);
 
                     strcpy(combined, s);
                     strcat(combined, "/");
                     strcat(combined, numstr);
                     argv_append(a, combined);
                 }

             }

             else if (!strcmp(term, "%s%sc"))

             {

                 char *s1 = va_arg(arglist, char *);
                 char *s2 = va_arg(arglist, char *);
                 char *combined;
 
                 if (!s1)
                 {
                     s1 = "";
                 }
                 if (!s2)
                 {
                     s2 = "";
                 }
                 combined = (char *) malloc(strlen(s1) + strlen(s2) + 1);
                 check_malloc_return(combined);
                 strcpy(combined, s1);
                 strcat(combined, s2);
                 argv_append(a, combined);

             }

             else
             {
                 ASSERT(0);
             }
             free(term);

         }

         else

         {

             argv_append(a, term);

         }
     }
 }

 
 void

 argv_printf(struct argv *a, const char *format, ...)

 {

     va_list arglist;
     argv_reset(a);
     va_start(arglist, format);
     argv_printf_arglist(a, format, arglist);
     va_end(arglist);
 }

 
 void

 argv_printf_cat(struct argv *a, const char *format, ...)

 {

     va_list arglist;
     va_start(arglist, format);
     argv_printf_arglist(a, format, arglist);
     va_end(arglist);

 }

 
 void

 argv_parse_cmd(struct argv *a, const char *s)

 {

     int nparms;
     char *parms[MAX_PARMS + 1];
     struct gc_arena gc = gc_new();

     argv_reset(a);
     argv_extend(a, 1); /* ensure trailing NULL */

     nparms = parse_line(s, parms, MAX_PARMS, "SCRIPT-ARGV", 0, D_ARGV_PARSE_CMD, &gc);
     if (nparms)
     {
         int i;
         for (i = 0; i < nparms; ++i)

         {

             argv_append(a, string_alloc(parms[i], NULL));

         }

     }
     else

     {

         argv_append(a, string_alloc(s, NULL));

     }
 

     gc_free(&gc);

 }