@@ -279,32 +279,6 @@ buf_puts(struct buffer *buf, const char *str)

     return ret;

 }

-

-/*

- * This is necessary due to certain buggy implementations of snprintf,

- * that don't guarantee null termination for size > 0.

- *

- * Return false on overflow.

- *

- * This functionality is duplicated in src/openvpnserv/common.c

- * Any modifications here should be done to the other place as well.

- */

-

-bool

-openvpn_snprintf(char *str, size_t size, const char *format, ...)

-{

-    va_list arglist;

-    int len = -1;

-    if (size > 0)

-    {

-        va_start(arglist, format);

-        len = vsnprintf(str, size, format, arglist);

-        va_end(arglist);

-        str[size - 1] = 0;

-    }

-    return (len >= 0 && len < size);

-}

-

 /*

  * write a string to the end of a buffer that was

  * truncated by buf_printf

@@ -448,19 +448,6 @@ __attribute__ ((format(__printf__, 2, 3)))

  */

 bool buf_puts(struct buffer *buf, const char *str);

-/*

- * Like snprintf but guarantees null termination for size > 0

- */

-bool openvpn_snprintf(char *str, size_t size, const char *format, ...)

-#ifdef __GNUC__

-#if __USE_MINGW_ANSI_STDIO

-__attribute__ ((format(gnu_printf, 3, 4)))

-#else

-__attribute__ ((format(__printf__, 3, 4)))

-#endif

-#endif

-;

-

 /*

  * remove/add trailing characters

@@ -874,11 +874,11 @@ init_key_ctx_bi(struct key_ctx_bi *ctx, const struct key2 *key2,

     key_direction_state_init(&kds, key_direction);

-    openvpn_snprintf(log_prefix, sizeof(log_prefix), "Outgoing %s", name);

+    snprintf(log_prefix, sizeof(log_prefix), "Outgoing %s", name);

     init_key_ctx(&ctx->encrypt, &key2->keys[kds.out_key], kt,

                  OPENVPN_OP_ENCRYPT, log_prefix);

-    openvpn_snprintf(log_prefix, sizeof(log_prefix), "Incoming %s", name);

+    snprintf(log_prefix, sizeof(log_prefix), "Incoming %s", name);

     init_key_ctx(&ctx->decrypt, &key2->keys[kds.in_key], kt,

                  OPENVPN_OP_DECRYPT, log_prefix);

@@ -128,7 +128,7 @@ mbed_log_func_line(unsigned int flags, int errval, const char *func,

 {

     char prefix[256];

-    if (!openvpn_snprintf(prefix, sizeof(prefix), "%s:%d", func, line))

+    if (!snprintf(prefix, sizeof(prefix), "%s:%d", func, line))

     {

         return mbed_log_err(flags, errval, func);

     }

@@ -239,11 +239,11 @@ crypto_pem_encode(const char *name, struct buffer *dst,

     char header[1000+1] = { 0 };

     char footer[1000+1] = { 0 };

-    if (!openvpn_snprintf(header, sizeof(header), "-----BEGIN %s-----\n", name))

+    if (!snprintf(header, sizeof(header), "-----BEGIN %s-----\n", name))

     {

         return false;

     }

-    if (!openvpn_snprintf(footer, sizeof(footer), "-----END %s-----\n", name))

+    if (!snprintf(footer, sizeof(footer), "-----END %s-----\n", name))

     {

         return false;

     }

@@ -278,11 +278,11 @@ crypto_pem_decode(const char *name, struct buffer *dst,

     char header[1000+1] = { 0 };

     char footer[1000+1] = { 0 };

-    if (!openvpn_snprintf(header, sizeof(header), "-----BEGIN %s-----", name))

+    if (!snprintf(header, sizeof(header), "-----BEGIN %s-----", name))

     {

         return false;

     }

-    if (!openvpn_snprintf(footer, sizeof(footer), "-----END %s-----", name))

+    if (!snprintf(footer, sizeof(footer), "-----END %s-----", name))

     {

         return false;

     }

@@ -349,11 +349,11 @@ setenv_dns_option(struct env_set *es,

     if (j < 0)

     {

-        name_ok = openvpn_snprintf(name, sizeof(name), format, i);

+        name_ok = snprintf(name, sizeof(name), format, i);

     }

     else

     {

-        name_ok = openvpn_snprintf(name, sizeof(name), format, i, j);

+        name_ok = snprintf(name, sizeof(name), format, i, j);

     }

     if (!name_ok)

@@ -259,7 +259,7 @@ void

 setenv_counter(struct env_set *es, const char *name, counter_type value)

 {

     char buf[64];

-    openvpn_snprintf(buf, sizeof(buf), counter_format, value);

+    snprintf(buf, sizeof(buf), counter_format, value);

     setenv_str(es, name, buf);

 }

@@ -267,7 +267,7 @@ void

 setenv_int(struct env_set *es, const char *name, int value)

 {

     char buf[64];

-    openvpn_snprintf(buf, sizeof(buf), "%d", value);

+    snprintf(buf, sizeof(buf), "%d", value);

     setenv_str(es, name, buf);

 }

@@ -275,7 +275,7 @@ void

 setenv_long_long(struct env_set *es, const char *name, long long value)

 {

     char buf[64];

-    openvpn_snprintf(buf, sizeof(buf), "%" PRIi64, (int64_t)value);

+    snprintf(buf, sizeof(buf), "%" PRIi64, (int64_t)value);

     setenv_str(es, name, buf);

 }

@@ -310,7 +310,7 @@ setenv_str_incr(struct env_set *es, const char *name, const char *value)

     strcpy(tmpname, name);

     while (NULL != env_set_get(es, tmpname) && counter < 1000)

     {

-        ASSERT(openvpn_snprintf(tmpname, tmpname_len, "%s_%u", name, counter));

+        ASSERT(snprintf(tmpname, tmpname_len, "%s_%u", name, counter));

         counter++;

     }

     if (counter < 1000)

@@ -274,14 +274,14 @@ x_msg_va(const unsigned int flags, const char *format, va_list arglist)

     if ((flags & M_ERRNO) && e)

     {

-        openvpn_snprintf(m2, ERR_BUF_SIZE, "%s: %s (errno=%d)",

-                         m1, openvpn_strerror(e, crt_error, &gc), e);

+        snprintf(m2, ERR_BUF_SIZE, "%s: %s (errno=%d)",

+                 m1, openvpn_strerror(e, crt_error, &gc), e);

         SWAP;

     }

     if (flags & M_OPTERR)

     {

-        openvpn_snprintf(m2, ERR_BUF_SIZE, "Options error: %s", m1);

+        snprintf(m2, ERR_BUF_SIZE, "Options error: %s", m1);

         SWAP;

     }

@@ -321,10 +321,10 @@ x_msg_va(const unsigned int flags, const char *format, va_list arglist)

         const struct virtual_output *vo = msg_get_virtual_output();

         if (vo)

         {

-            openvpn_snprintf(m2, ERR_BUF_SIZE, "%s%s%s",

-                             prefix,

-                             prefix_sep,

-                             m1);

+            snprintf(m2, ERR_BUF_SIZE, "%s%s%s",

+                     prefix,

+                     prefix_sep,

+                     m1);

             virtual_output_print(vo, flags, m2);

         }

     }

@@ -359,7 +359,7 @@ management_callback_remote_entry_get(void *arg, unsigned int index, char **remot

         char *out = malloc(len);

         check_malloc_return(out);

-        openvpn_snprintf(out, len, "%s,%s,%s,%s", ce->remote, ce->remote_port, proto, status);

+        snprintf(out, len, "%s,%s,%s,%s", ce->remote, ce->remote_port, proto, status);

         *remote = out;

     }

     else

@@ -515,8 +515,8 @@ man_bytecount_output_client(struct management *man,

     char out[32];

     /* do in a roundabout way to work around possible mingw or mingw-glibc bug */

-    openvpn_snprintf(in, sizeof(in), counter_format, man->persist.bytes_in + dco_read_bytes);

-    openvpn_snprintf(out, sizeof(out), counter_format, man->persist.bytes_out + dco_write_bytes);

+    snprintf(in, sizeof(in), counter_format, man->persist.bytes_in + dco_read_bytes);

+    snprintf(out, sizeof(out), counter_format, man->persist.bytes_out + dco_write_bytes);

     msg(M_CLIENT, ">BYTECOUNT:%s,%s", in, out);

 }

@@ -528,8 +528,8 @@ man_bytecount_output_server(const counter_type *bytes_in_total,

     char in[32];

     char out[32];

     /* do in a roundabout way to work around possible mingw or mingw-glibc bug */

-    openvpn_snprintf(in, sizeof(in), counter_format, *bytes_in_total);

-    openvpn_snprintf(out, sizeof(out), counter_format, *bytes_out_total);

+    snprintf(in, sizeof(in), counter_format, *bytes_in_total);

+    snprintf(out, sizeof(out), counter_format, *bytes_out_total);

     msg(M_CLIENT, ">BYTECOUNT_CLI:%lu,%s,%s", mdac->cid, in, out);

     mdac->bytecount_last_update = now;

 }

@@ -1427,7 +1427,7 @@ foreign_options_copy_dns(struct options *o, struct env_set *es)

     for (int i = 1; i <= opt_max; ++i)

     {

         char name[32];

-        openvpn_snprintf(name, sizeof(name), "foreign_option_%d", i);

+        snprintf(name, sizeof(name), "foreign_option_%d", i);

         const char *env_str = env_set_get(es, name);

         const char *value = strchr(env_str, '=') + 1;

@@ -1482,7 +1482,7 @@ foreign_options_copy_dns(struct options *o, struct env_set *es)

     while (o->foreign_option_index < opt_max)

     {

         char name[32];

-        openvpn_snprintf(name, sizeof(name), "foreign_option_%d", opt_max--);

+        snprintf(name, sizeof(name), "foreign_option_%d", opt_max--);

         setenv_del(es, name);

     }

 }

@@ -5674,8 +5674,8 @@ set_user_script(struct options *options,

 #ifndef ENABLE_SMALL

     {

         char script_name[100];

-        openvpn_snprintf(script_name, sizeof(script_name),

-                         "--%s script", type);

+        snprintf(script_name, sizeof(script_name),

+                 "--%s script", type);

         if (check_cmd_access(*script, script_name, (in_chroot ? options->chroot_dir : NULL)))

         {

@@ -201,7 +201,7 @@ _pkcs11_openvpn_token_prompt(

     CLEAR(token_resp);

     token_resp.defined = false;

     token_resp.nocache = true;

-    openvpn_snprintf(

+    snprintf(

         token_resp.username,

         sizeof(token_resp.username),

         "Please insert %s token",

@@ -245,7 +245,7 @@ _pkcs11_openvpn_pin_prompt(

     ASSERT(token!=NULL);

-    openvpn_snprintf(prompt, sizeof(prompt), "%s token", token->label);

+    snprintf(prompt, sizeof(prompt), "%s token", token->label);

     token_pass.defined = false;

     token_pass.nocache = true;

@@ -719,7 +719,7 @@ tls_ctx_use_pkcs11(

         id_resp.defined = false;

         id_resp.nocache = true;

-        openvpn_snprintf(

+        snprintf(

             id_resp.username,

             sizeof(id_resp.username),

             "Please specify PKCS#11 id to use"

@@ -564,9 +564,9 @@ platform_create_temp_file(const char *directory, const char *prefix, struct gc_a

     {

         ++attempts;

-        if (!openvpn_snprintf(fname, sizeof(fname), fname_fmt, max_prefix_len,

-                              prefix, (unsigned long) get_random(),

-                              (unsigned long) get_random()))

+        if (!snprintf(fname, sizeof(fname), fname_fmt, max_prefix_len,

+                      prefix, (unsigned long) get_random(),

+                      (unsigned long) get_random()))

         {

             msg(M_WARN, "ERROR: temporary filename too long");

             return NULL;

@@ -260,7 +260,7 @@ plugin_init_item(struct plugin *p, const struct plugin_option *o)

     {

         char full[PATH_MAX];

-        openvpn_snprintf(full, sizeof(full), "%s/%s", PLUGIN_LIBDIR, p->so_pathname);

+        snprintf(full, sizeof(full), "%s/%s", PLUGIN_LIBDIR, p->so_pathname);

         p->handle = dlopen(full, RTLD_NOW);

     }

     else

@@ -409,7 +409,7 @@ plugin_vlog(openvpn_plugin_log_flags_t flags, const char *name, const char *form

         gc_init(&gc);

         msg_fmt = gc_malloc(ERR_BUF_SIZE, false, &gc);

-        openvpn_snprintf(msg_fmt, ERR_BUF_SIZE, "PLUGIN %s: %s", name, format);

+        snprintf(msg_fmt, ERR_BUF_SIZE, "PLUGIN %s: %s", name, format);

         x_msg_va(msg_flags, msg_fmt, arglist);

         gc_free(&gc);

@@ -766,7 +766,7 @@ ifconfig_pool_test(in_addr_t start, in_addr_t end)

         ifconfig_pool_handle h;

         in_addr_t local, remote;

         char buf[256];

-        openvpn_snprintf(buf, sizeof(buf), "common-name-%d", i);

+        snprintf(buf, sizeof(buf), "common-name-%d", i);

 #ifdef DUP_CN

         cn = NULL;

 #else

@@ -582,9 +582,9 @@ add_proxy_headers(struct http_proxy_info *p,

     {

         if (p->options.custom_headers[i].content)

         {

-            openvpn_snprintf(buf, sizeof(buf), "%s: %s",

-                             p->options.custom_headers[i].name,

-                             p->options.custom_headers[i].content);

+            snprintf(buf, sizeof(buf), "%s: %s",

+                     p->options.custom_headers[i].name,

+                     p->options.custom_headers[i].content);

             if (!strcasecmp(p->options.custom_headers[i].name, "Host"))

             {

                 host_header_sent = true;

@@ -592,8 +592,8 @@ add_proxy_headers(struct http_proxy_info *p,

         }

         else

         {

-            openvpn_snprintf(buf, sizeof(buf), "%s",

-                             p->options.custom_headers[i].name);

+            snprintf(buf, sizeof(buf), "%s",

+                     p->options.custom_headers[i].name);

             if (!strncasecmp(p->options.custom_headers[i].name, "Host:", 5))

             {

                 host_header_sent = true;

@@ -609,7 +609,7 @@ add_proxy_headers(struct http_proxy_info *p,

     if (!host_header_sent)

     {

-        openvpn_snprintf(buf, sizeof(buf), "Host: %s", host);

+        snprintf(buf, sizeof(buf), "Host: %s", host);

         msg(D_PROXY, "Send to HTTP proxy: '%s'", buf);

         if (!send_line_crlf(sd, buf))

         {

@@ -620,8 +620,8 @@ add_proxy_headers(struct http_proxy_info *p,

     /* send User-Agent string if provided */

     if (p->options.user_agent)

     {

-        openvpn_snprintf(buf, sizeof(buf), "User-Agent: %s",

-                         p->options.user_agent);

+        snprintf(buf, sizeof(buf), "User-Agent: %s",

+                 p->options.user_agent);

         msg(D_PROXY, "Send to HTTP proxy: '%s'", buf);

         if (!send_line_crlf(sd, buf))

         {

@@ -667,10 +667,10 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

     else

     {

         /* format HTTP CONNECT message */

-        openvpn_snprintf(buf, sizeof(buf), "CONNECT %s:%s HTTP/%s",

-                         host,

-                         port,

-                         p->options.http_version);

+        snprintf(buf, sizeof(buf), "CONNECT %s:%s HTTP/%s",

+                 host,

+                 port,

+                 p->options.http_version);

         msg(D_PROXY, "Send to HTTP proxy: '%s'", buf);

@@ -692,8 +692,8 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

                 break;

             case HTTP_AUTH_BASIC:

-                openvpn_snprintf(buf, sizeof(buf), "Proxy-Authorization: Basic %s",

-                                 username_password_as_base64(p, &gc));

+                snprintf(buf, sizeof(buf), "Proxy-Authorization: Basic %s",

+                         username_password_as_base64(p, &gc));

                 msg(D_PROXY, "Attempting Basic Proxy-Authorization");

                 dmsg(D_SHOW_KEYS, "Send to HTTP proxy: '%s'", buf);

                 if (!send_line_crlf(sd, buf))

@@ -705,14 +705,14 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

 #if NTLM

             case HTTP_AUTH_NTLM2:

                 /* keep-alive connection */

-                openvpn_snprintf(buf, sizeof(buf), "Proxy-Connection: Keep-Alive");

+                snprintf(buf, sizeof(buf), "Proxy-Connection: Keep-Alive");

                 if (!send_line_crlf(sd, buf))

                 {

                     goto error;

                 }

-                openvpn_snprintf(buf, sizeof(buf), "Proxy-Authorization: NTLM %s",

-                                 ntlm_phase_1(p, &gc));

+                snprintf(buf, sizeof(buf), "Proxy-Authorization: NTLM %s",

+                         ntlm_phase_1(p, &gc));

                 msg(D_PROXY, "Attempting NTLM Proxy-Authorization phase 1");

                 dmsg(D_SHOW_KEYS, "Send to HTTP proxy: '%s'", buf);

                 if (!send_line_crlf(sd, buf))

@@ -773,7 +773,7 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

                 char get[80];

                 CLEAR(buf2);

-                openvpn_snprintf(get, sizeof(get), "%%*s NTLM %%%zus", sizeof(buf2) - 1);

+                snprintf(get, sizeof(get), "%%*s NTLM %%%zus", sizeof(buf2) - 1);

                 nparms = sscanf(buf, get, buf2);

                 /* check for "Proxy-Authenticate: NTLM TlRM..." */

@@ -795,10 +795,10 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

             /* now send the phase 3 reply */

             /* format HTTP CONNECT message */

-            openvpn_snprintf(buf, sizeof(buf), "CONNECT %s:%s HTTP/%s",

-                             host,

-                             port,

-                             p->options.http_version);

+            snprintf(buf, sizeof(buf), "CONNECT %s:%s HTTP/%s",

+                     host,

+                     port,

+                     p->options.http_version);

             msg(D_PROXY, "Send to HTTP proxy: '%s'", buf);

@@ -809,7 +809,7 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

             }

             /* keep-alive connection */

-            openvpn_snprintf(buf, sizeof(buf), "Proxy-Connection: Keep-Alive");

+            snprintf(buf, sizeof(buf), "Proxy-Connection: Keep-Alive");

             if (!send_line_crlf(sd, buf))

             {

                 goto error;

@@ -829,7 +829,7 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

                     msg(D_PROXY, "NTLM Proxy-Authorization phase 3 failed: received corrupted data from proxy server");

                     goto error;

                 }

-                openvpn_snprintf(buf, sizeof(buf), "Proxy-Authorization: NTLM %s", np3);

+                snprintf(buf, sizeof(buf), "Proxy-Authorization: NTLM %s", np3);

             }

             msg(D_PROXY, "Send to HTTP proxy: '%s'", buf);

@@ -899,15 +899,15 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

                 /* build the digest response */

-                openvpn_snprintf(uri, sizeof(uri), "%s:%s",

-                                 host,

-                                 port);

+                snprintf(uri, sizeof(uri), "%s:%s",

+                         host,

+                         port);

                 if (opaque)

                 {

                     const int len = strlen(opaque)+16;

                     opaque_kv = gc_malloc(len, false, &gc);

-                    openvpn_snprintf(opaque_kv, len, ", opaque=\"%s\"", opaque);

+                    snprintf(opaque_kv, len, ", opaque=\"%s\"", opaque);

                 }

                 DigestCalcHA1(algor,

@@ -928,10 +928,10 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

                                    response);

                 /* format HTTP CONNECT message */

-                openvpn_snprintf(buf, sizeof(buf), "%s %s HTTP/%s",

-                                 http_method,

-                                 uri,

-                                 p->options.http_version);

+                snprintf(buf, sizeof(buf), "%s %s HTTP/%s",

+                         http_method,

+                         uri,

+                         p->options.http_version);

                 msg(D_PROXY, "Send to HTTP proxy: '%s'", buf);

@@ -948,21 +948,22 @@ establish_http_proxy_passthru(struct http_proxy_info *p,

                 }

                 /* send digest response */

-                int sret = openvpn_snprintf(buf, sizeof(buf), "Proxy-Authorization: Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", qop=%s, nc=%s, cnonce=\"%s\", response=\"%s\"%s",

-                                            username,

-                                            realm,

-                                            nonce,

-                                            uri,

-                                            qop,

-                                            nonce_count,

-                                            cnonce,

-                                            response,

-                                            opaque_kv

-                                            );

+                int sret = snprintf(buf, sizeof(buf), "Proxy-Authorization: Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", qop=%s, nc=%s, cnonce=\"%s\", response=\"%s\"%s",

+                                    username,

+                                    realm,

+                                    nonce,

+                                    uri,

+                                    qop,

+                                    nonce_count,

+                                    cnonce,

+                                    response,

+                                    opaque_kv

+                                    );

                 if (sret >= sizeof(buf))

                 {

                     goto error;

                 }

+

                 msg(D_PROXY, "Send to HTTP proxy: '%s'", buf);

                 if (!send_line_crlf(sd, buf))

                 {

@@ -354,7 +354,7 @@ journal_add(const char *journal_dir, struct proxy_connection *pc, struct proxy_c

         fnlen =  strlen(journal_dir) + strlen(t) + 2;

         jfn = (char *) malloc(fnlen);

         check_malloc_return(jfn);

-        openvpn_snprintf(jfn, fnlen, "%s/%s", journal_dir, t);

+        snprintf(jfn, fnlen, "%s/%s", journal_dir, t);

         dmsg(D_PS_PROXY_DEBUG, "PORT SHARE PROXY: client origin %s -> %s", jfn, f);

         fd = platform_open(jfn, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP);

         if (fd != -1)

@@ -1621,11 +1621,11 @@ add_route(struct route_ipv4 *r,

     if (rgi)

     {

-        openvpn_snprintf(out, sizeof(out), "%s %s %s dev %s", network, netmask, gateway, rgi->iface);

+        snprintf(out, sizeof(out), "%s %s %s dev %s", network, netmask, gateway, rgi->iface);

     }

     else

     {

-        openvpn_snprintf(out, sizeof(out), "%s %s %s", network, netmask, gateway);

+        snprintf(out, sizeof(out), "%s %s %s", network, netmask, gateway);

     }

     bool ret = management_android_control(management, "ROUTE", out);

     status = ret ? RTA_SUCCESS : RTA_ERROR;

@@ -2000,7 +2000,7 @@ add_route_ipv6(struct route_ipv6 *r6, const struct tuntap *tt,

 #elif defined (TARGET_ANDROID)

     char out[64];

-    openvpn_snprintf(out, sizeof(out), "%s/%d %s", network, r6->netbits, device);

+    snprintf(out, sizeof(out), "%s/%d %s", network, r6->netbits, device);

     status = management_android_control(management, "ROUTE6", out);

@@ -66,8 +66,8 @@ openvpn_run_script(const struct argv *a, const struct env_set *es,

 {

     char msg[256];

-    openvpn_snprintf(msg, sizeof(msg),

-                     "WARNING: Failed running command (%s)", hook);

+    snprintf(msg, sizeof(msg),

+             "WARNING: Failed running command (%s)", hook);

     return openvpn_execve_check(a, es, flags | S_SCRIPT, msg);

 }

@@ -2983,11 +2983,11 @@ setenv_sockaddr(struct env_set *es, const char *name_prefix, const struct openvp

         case AF_INET:

             if (flags & SA_IP_PORT)

             {

-                openvpn_snprintf(name_buf, sizeof(name_buf), "%s_ip", name_prefix);

+                snprintf(name_buf, sizeof(name_buf), "%s_ip", name_prefix);

             }

             else

             {

-                openvpn_snprintf(name_buf, sizeof(name_buf), "%s", name_prefix);

+                snprintf(name_buf, sizeof(name_buf), "%s", name_prefix);

             }

             inet_ntop(AF_INET, &addr->addr.in4.sin_addr, buf, sizeof(buf));

@@ -2995,7 +2995,7 @@ setenv_sockaddr(struct env_set *es, const char *name_prefix, const struct openvp

             if ((flags & SA_IP_PORT) && addr->addr.in4.sin_port)

             {

-                openvpn_snprintf(name_buf, sizeof(name_buf), "%s_port", name_prefix);

+                snprintf(name_buf, sizeof(name_buf), "%s_port", name_prefix);

                 setenv_int(es, name_buf, ntohs(addr->addr.in4.sin_port));

             }

             break;

@@ -3006,19 +3006,19 @@ setenv_sockaddr(struct env_set *es, const char *name_prefix, const struct openvp

                 struct in_addr ia;

                 memcpy(&ia.s_addr, &addr->addr.in6.sin6_addr.s6_addr[12],

                        sizeof(ia.s_addr));

-                openvpn_snprintf(name_buf, sizeof(name_buf), "%s_ip", name_prefix);

+                snprintf(name_buf, sizeof(name_buf), "%s_ip", name_prefix);

                 inet_ntop(AF_INET, &ia, buf, sizeof(buf));

             }

             else

             {

-                openvpn_snprintf(name_buf, sizeof(name_buf), "%s_ip6", name_prefix);

+                snprintf(name_buf, sizeof(name_buf), "%s_ip6", name_prefix);

                 inet_ntop(AF_INET6, &addr->addr.in6.sin6_addr, buf, sizeof(buf));

             }

             setenv_str(es, name_buf, buf);

             if ((flags & SA_IP_PORT) && addr->addr.in6.sin6_port)

             {

-                openvpn_snprintf(name_buf, sizeof(name_buf), "%s_port", name_prefix);

+                snprintf(name_buf, sizeof(name_buf), "%s_port", name_prefix);

                 setenv_int(es, name_buf, ntohs(addr->addr.in6.sin6_port));

             }

             break;

@@ -109,9 +109,10 @@ socks_username_password_auth(struct socks_proxy_info *p,

             "Authentication not possible.");

         goto cleanup;

     }

-    int sret = openvpn_snprintf(to_send, sizeof(to_send), "\x01%c%s%c%s",

-                                (int) strlen(creds.username), creds.username,

-                                (int) strlen(creds.password), creds.password);

+

+    int sret = snprintf(to_send, sizeof(to_send), "\x01%c%s%c%s",

+                        (int) strlen(creds.username), creds.username,

+                        (int) strlen(creds.password), creds.password);

     ASSERT(sret <= sizeof(to_send));

     size = send(sd, to_send, strlen(to_send), MSG_NOSIGNAL);

@@ -1531,16 +1531,16 @@ print_details(struct key_state_ssl *ks_ssl, const char *prefix)

     char s2[256];

     s1[0] = s2[0] = 0;

-    openvpn_snprintf(s1, sizeof(s1), "%s %s, cipher %s",

-                     prefix,

-                     mbedtls_ssl_get_version(ks_ssl->ctx),

-                     mbedtls_ssl_get_ciphersuite(ks_ssl->ctx));

+    snprintf(s1, sizeof(s1), "%s %s, cipher %s",

+             prefix,

+             mbedtls_ssl_get_version(ks_ssl->ctx),

+             mbedtls_ssl_get_ciphersuite(ks_ssl->ctx));

     cert = mbedtls_ssl_get_peer_cert(ks_ssl->ctx);

     if (cert != NULL)

     {

-        openvpn_snprintf(s2, sizeof(s2), ", %u bit key",

-                         (unsigned int) mbedtls_pk_get_bitlen(&cert->pk));

+        snprintf(s2, sizeof(s2), ", %u bit key",

+                 (unsigned int) mbedtls_pk_get_bitlen(&cert->pk));

     }

     msg(D_HANDSHAKE, "%s%s", s1, s2);

@@ -198,8 +198,8 @@ append_cipher_to_ncp_list(struct options *o, const char *ciphername)

     size_t newlen = strlen(o->ncp_ciphers) + 1 + strlen(ciphername) + 1;

     char *ncp_ciphers = gc_malloc(newlen, false, &o->gc);

-    ASSERT(openvpn_snprintf(ncp_ciphers, newlen, "%s:%s", o->ncp_ciphers,

-                            ciphername));

+    ASSERT(snprintf(ncp_ciphers, newlen, "%s:%s", o->ncp_ciphers,

+                    ciphername));

     o->ncp_ciphers = ncp_ciphers;

 }

@@ -1774,7 +1774,7 @@ open_biofp(void)

     if (!biofp)

     {

         char fn[256];

-        openvpn_snprintf(fn, sizeof(fn), "bio/%d-%d.log", pid, biofp_toggle);

+        snprintf(fn, sizeof(fn), "bio/%d-%d.log", pid, biofp_toggle);

         biofp = fopen(fn, "w");

         ASSERT(biofp);

         biofp_last_open = time(NULL);

@@ -2116,8 +2116,8 @@ print_pkey_details(EVP_PKEY *pkey, char *buf, size_t buflen)

 #endif /* if OPENSSL_VERSION_NUMBER < 0x30000000L */

     }

-    openvpn_snprintf(buf, buflen, "%d bits %s%s",

-                     EVP_PKEY_bits(pkey), type, curve);

+    snprintf(buf, buflen, "%d bits %s%s",

+             EVP_PKEY_bits(pkey), type, curve);

 }

 /**

@@ -2137,12 +2137,12 @@ print_cert_details(X509 *cert, char *buf, size_t buflen)

     int signature_nid = X509_get_signature_nid(cert);

     if (signature_nid != 0)

     {

-        openvpn_snprintf(sig, sizeof(sig), ", signature: %s",

-                         OBJ_nid2sn(signature_nid));

+        snprintf(sig, sizeof(sig), ", signature: %s",

+                 OBJ_nid2sn(signature_nid));

     }

-    openvpn_snprintf(buf, buflen, ", peer certificate: %s%s",

-                     pkeybuf, sig);

+    snprintf(buf, buflen, ", peer certificate: %s%s",

+             pkeybuf, sig);

     EVP_PKEY_free(pkey);

 }

@@ -2160,8 +2160,8 @@ print_server_tempkey(SSL *ssl, char *buf, size_t buflen)

     char pkeybuf[128] = { 0 };

     print_pkey_details(pkey, pkeybuf, sizeof(pkeybuf));

-    openvpn_snprintf(buf, buflen, ", peer temporary key: %s",

-                     pkeybuf);

+    snprintf(buf, buflen, ", peer temporary key: %s",

+             pkeybuf);

     EVP_PKEY_free(pkey);

 }

@@ -2238,8 +2238,8 @@ print_peer_signature(SSL *ssl, char *buf, size_t buflen)

         return;

     }

-    openvpn_snprintf(buf, buflen, ", peer signing digest/type: %s %s",

-                     peer_sig, peer_sig_type);

+    snprintf(buf, buflen, ", peer signing digest/type: %s %s",

+             peer_sig, peer_sig_type);

 }

@@ -2262,11 +2262,11 @@ print_details(struct key_state_ssl *ks_ssl, const char *prefix)

     s1[0] = s2[0] = s3[0] = s4[0] = 0;

     ciph = SSL_get_current_cipher(ks_ssl->ssl);

-    openvpn_snprintf(s1, sizeof(s1), "%s %s, cipher %s %s",

-                     prefix,

-                     SSL_get_version(ks_ssl->ssl),

-                     SSL_CIPHER_get_version(ciph),

-                     SSL_CIPHER_get_name(ciph));

+    snprintf(s1, sizeof(s1), "%s %s, cipher %s %s",

+             prefix,

+             SSL_get_version(ks_ssl->ssl),

+             SSL_CIPHER_get_version(ciph),

+             SSL_CIPHER_get_name(ciph));

     X509 *cert = SSL_get_peer_certificate(ks_ssl->ssl);

     if (cert)

@@ -421,12 +421,12 @@ verify_cert_set_env(struct env_set *es, openvpn_x509_cert_t *peer_cert, int cert

     }

     /* export subject name string as environmental variable */

-    openvpn_snprintf(envname, sizeof(envname), "tls_id_%d", cert_depth);

+    snprintf(envname, sizeof(envname), "tls_id_%d", cert_depth);

     setenv_str(es, envname, subject);

 #if 0

     /* export common name string as environmental variable */

-    openvpn_snprintf(envname, sizeof(envname), "tls_common_name_%d", cert_depth);

+    snprintf(envname, sizeof(envname), "tls_common_name_%d", cert_depth);

     setenv_str(es, envname, common_name);

 #endif

@@ -435,24 +435,24 @@ verify_cert_set_env(struct env_set *es, openvpn_x509_cert_t *peer_cert, int cert

         struct buffer sha1 = x509_get_sha1_fingerprint(peer_cert, &gc);

         struct buffer sha256 = x509_get_sha256_fingerprint(peer_cert, &gc);

-        openvpn_snprintf(envname, sizeof(envname), "tls_digest_%d", cert_depth);

+        snprintf(envname, sizeof(envname), "tls_digest_%d", cert_depth);

         setenv_str(es, envname,

                    format_hex_ex(BPTR(&sha1), BLEN(&sha1), 0, 1, ":", &gc));

-        openvpn_snprintf(envname, sizeof(envname), "tls_digest_sha256_%d",

-                         cert_depth);

+        snprintf(envname, sizeof(envname), "tls_digest_sha256_%d",

+                 cert_depth);

         setenv_str(es, envname,

                    format_hex_ex(BPTR(&sha256), BLEN(&sha256), 0, 1, ":", &gc));

     }

     /* export serial number as environmental variable */

     serial = backend_x509_get_serial(peer_cert, &gc);

-    openvpn_snprintf(envname, sizeof(envname), "tls_serial_%d", cert_depth);

+    snprintf(envname, sizeof(envname), "tls_serial_%d", cert_depth);

     setenv_str(es, envname, serial);

     /* export serial number in hex as environmental variable */

     serial = backend_x509_get_serial_hex(peer_cert, &gc);

-    openvpn_snprintf(envname, sizeof(envname), "tls_serial_hex_%d", cert_depth);

+    snprintf(envname, sizeof(envname), "tls_serial_hex_%d", cert_depth);

     setenv_str(es, envname, serial);

     gc_free(&gc);

@@ -569,7 +569,7 @@ verify_check_crl_dir(const char *crl_dir, openvpn_x509_cert_t *cert,

         goto cleanup;

     }

-    if (!openvpn_snprintf(fn, sizeof(fn), "%s%c%s", crl_dir, PATH_SEPARATOR, serial))

+    if (!snprintf(fn, sizeof(fn), "%s%c%s", crl_dir, PATH_SEPARATOR, serial))

     {

         msg(D_HANDSHAKE, "VERIFY CRL: filename overflow");

         goto cleanup;

@@ -938,9 +938,9 @@ key_state_check_auth_pending_file(struct auth_deferred_status *ads,

             if (!check_auth_pending_method(multi->peer_info, pending_method))

             {

                 char buf[128];

-                openvpn_snprintf(buf, sizeof(buf),

-                                 "Authentication failed, required pending auth "

-                                 "method '%s' not supported", pending_method);

+                snprintf(buf, sizeof(buf),

+                         "Authentication failed, required pending auth "

+                         "method '%s' not supported", pending_method);

                 auth_set_client_reason(multi, buf);

                 msg(M_INFO, "Client does not supported auth pending method "

                     "'%s'", pending_method);

@@ -86,8 +86,8 @@ verify_callback(void *session_obj, mbedtls_x509_crt *cert, int cert_depth,

         char *serial = backend_x509_get_serial(cert, &gc);

         ret = mbedtls_x509_crt_verify_info(errstr, sizeof(errstr)-1, "", *flags);

-        if (ret <= 0 && !openvpn_snprintf(errstr, sizeof(errstr),

-                                          "Could not retrieve error string, flags=%" PRIx32, *flags))

+        if (ret <= 0 && !snprintf(errstr, sizeof(errstr),

+                                  "Could not retrieve error string, flags=%" PRIx32, *flags))

         {

             errstr[0] = '\0';

         }

@@ -307,7 +307,7 @@ do_setenv_x509(struct env_set *es, const char *name, char *value, int depth)

     name_expand_size = 64 + strlen(name);

     name_expand = (char *) malloc(name_expand_size);

     check_malloc_return(name_expand);

-    openvpn_snprintf(name_expand, name_expand_size, "X509_%d_%s", depth, name);

+    snprintf(name_expand, name_expand_size, "X509_%d_%s", depth, name);

     setenv_str(es, name_expand, value);

     free(name_expand);

 }

@@ -431,13 +431,13 @@ x509_setenv(struct env_set *es, int cert_depth, mbedtls_x509_crt *cert)

         if (0 == mbedtls_oid_get_attr_short_name(&name->oid, &shortname) )

         {

-            openvpn_snprintf(name_expand, sizeof(name_expand), "X509_%d_%s",

-                             cert_depth, shortname);

+            snprintf(name_expand, sizeof(name_expand), "X509_%d_%s",

+                     cert_depth, shortname);

         }

         else

         {

-            openvpn_snprintf(name_expand, sizeof(name_expand), "X509_%d_\?\?",

-                             cert_depth);

+            snprintf(name_expand, sizeof(name_expand), "X509_%d_\?\?",

+                     cert_depth);

         }

         for (i = 0; i < name->val.len; i++)

@@ -279,7 +279,7 @@ backend_x509_get_username(char *common_name, int cn_len,

             gc_free(&gc);

             return FAILURE;

         }

-        openvpn_snprintf(common_name, cn_len, "0x%s", serial);

+        snprintf(common_name, cn_len, "0x%s", serial);

         gc_free(&gc);

     }

     else

@@ -454,7 +454,7 @@ do_setenv_x509(struct env_set *es, const char *name, char *value, int depth)

     name_expand_size = 64 + strlen(name);

     name_expand = (char *) malloc(name_expand_size);

     check_malloc_return(name_expand);

-    openvpn_snprintf(name_expand, name_expand_size, "X509_%d_%s", depth, name);

+    snprintf(name_expand, name_expand_size, "X509_%d_%s", depth, name);

     setenv_str(es, name_expand, value);

     free(name_expand);

 }

@@ -597,8 +597,8 @@ x509_setenv(struct env_set *es, int cert_depth, openvpn_x509_cert_t *peer_cert)

         name_expand_size = 64 + strlen(objbuf);

         name_expand = (char *) malloc(name_expand_size);

         check_malloc_return(name_expand);

-        openvpn_snprintf(name_expand, name_expand_size, "X509_%d_%s", cert_depth,

-                         objbuf);