269 lines
8.5 KiB
C++
269 lines
8.5 KiB
C++
/* Copyright (c) 2010 Wildfire Games
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* partial implementation of VC8's secure CRT functions
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "lib/secure_crt.h"
|
|
|
|
// we were included from wsecure_crt.cpp; skip all stuff that
|
|
// must only be done once.
|
|
#ifndef WSECURE_CRT
|
|
ERROR_ASSOCIATE(ERR::STRING_NOT_TERMINATED, L"Invalid string (no 0 terminator found in buffer)", -1);
|
|
#endif
|
|
|
|
|
|
// written against http://std.dkuug.dk/jtc1/sc22/wg14/www/docs/n1031.pdf .
|
|
// optimized for size - e.g. strcpy calls strncpy with n = SIZE_MAX.
|
|
|
|
// since char and wide versions of these functions are basically the same,
|
|
// this source file implements generic versions and bridges the differences
|
|
// with these macros. wsecure_crt.cpp #defines WSECURE_CRT and
|
|
// includes this file.
|
|
|
|
// Note: These defines are all #undef:ed at the end of the file - remember to
|
|
// add a corresponding #undef when adding a #define.
|
|
#ifdef WSECURE_CRT
|
|
# define tchar wchar_t
|
|
# define T(string_literal) L ## string_literal
|
|
# define tnlen wcsnlen
|
|
# define tncpy_s wcsncpy_s
|
|
# define tcpy_s wcscpy_s
|
|
# define tncat_s wcsncat_s
|
|
# define tcat_s wcscat_s
|
|
# define tcmp wcscmp
|
|
# define tcpy wcscpy
|
|
# define tvsnprintf vswprintf // used by implementation
|
|
# define tvsprintf_s vswprintf_s
|
|
# define tsprintf_s swprintf_s
|
|
#else
|
|
# define tchar char
|
|
# define T(string_literal) string_literal
|
|
# define tnlen strnlen
|
|
# define tncpy_s strncpy_s
|
|
# define tcpy_s strcpy_s
|
|
# define tncat_s strncat_s
|
|
# define tcat_s strcat_s
|
|
# define tcmp strcmp
|
|
# define tcpy strcpy
|
|
# define tvsnprintf vsnprintf // used by implementation
|
|
# define tvsprintf_s vsprintf_s
|
|
# define tsprintf_s sprintf_s
|
|
#endif // #ifdef WSECURE_CRT
|
|
|
|
|
|
// return <retval> and raise an assertion if <condition> doesn't hold.
|
|
// usable as a statement.
|
|
#define ENFORCE(condition, err_to_warn, retval) STMT(\
|
|
if(!(condition)) \
|
|
{ \
|
|
DEBUG_WARN_ERR(err_to_warn); \
|
|
return retval; \
|
|
} \
|
|
)
|
|
|
|
// raise a debug warning if <len> is the size of a pointer.
|
|
// catches bugs such as: tchar* s = ..; tcpy_s(s, sizeof(s), T(".."));
|
|
// if warnings get annoying, replace with debug_printf. usable as a statement.
|
|
//
|
|
// currently disabled due to high risk of false positives.
|
|
#define WARN_IF_PTR_LEN(len)\
|
|
/*
|
|
debug_assert(len != sizeof(char*));
|
|
*/
|
|
|
|
|
|
// skip our implementation if already available, but not the
|
|
// self-test and the t* defines (needed for test).
|
|
#if EMULATE_SECURE_CRT
|
|
|
|
#if !OS_UNIX || OS_MACOSX
|
|
// return length [in characters] of a string, not including the trailing
|
|
// null character. to protect against access violations, only the
|
|
// first <max_len> characters are examined; if the null character is
|
|
// not encountered by then, <max_len> is returned.
|
|
size_t tnlen(const tchar* str, size_t max_len)
|
|
{
|
|
// note: we can't bail - what would the return value be?
|
|
debug_assert(str != 0);
|
|
|
|
WARN_IF_PTR_LEN(max_len);
|
|
|
|
size_t len;
|
|
for(len = 0; len < max_len; len++)
|
|
if(*str++ == '\0')
|
|
break;
|
|
|
|
return len;
|
|
}
|
|
#endif // !OS_UNIX
|
|
|
|
|
|
// copy at most <max_src_chars> (not including trailing null) from
|
|
// <src> into <dst>, which must not overlap.
|
|
// if thereby <max_dst_chars> (including null) would be exceeded,
|
|
// <dst> is set to the empty string and ERANGE returned; otherwise,
|
|
// 0 is returned to indicate success and that <dst> is null-terminated.
|
|
//
|
|
// note: padding with zeroes is not called for by N1031.
|
|
int tncpy_s(tchar* dst, size_t max_dst_chars, const tchar* src, size_t max_src_chars)
|
|
{
|
|
// the MS implementation returns EINVAL and allows dst = 0 if
|
|
// max_dst_chars = max_src_chars = 0. no mention of this in
|
|
// 3.6.2.1.1, so don't emulate that behavior.
|
|
ENFORCE(dst != 0, ERR::INVALID_PARAM, EINVAL);
|
|
ENFORCE(max_dst_chars != 0, ERR::INVALID_PARAM, EINVAL); // N1031 says ERANGE, MSDN/MSVC says EINVAL
|
|
*dst = '\0'; // in case src ENFORCE is triggered
|
|
ENFORCE(src != 0, ERR::INVALID_PARAM, EINVAL);
|
|
|
|
WARN_IF_PTR_LEN(max_dst_chars);
|
|
WARN_IF_PTR_LEN(max_src_chars);
|
|
|
|
// copy string until null character encountered or limit reached.
|
|
// optimized for size (less comparisons than MS impl) and
|
|
// speed (due to well-predicted jumps; we don't bother unrolling).
|
|
tchar* p = dst;
|
|
size_t chars_left = std::min(max_dst_chars, max_src_chars);
|
|
while(chars_left != 0)
|
|
{
|
|
// success: reached end of string normally.
|
|
if((*p++ = *src++) == '\0')
|
|
return 0;
|
|
chars_left--;
|
|
}
|
|
|
|
// which limit did we hit?
|
|
// .. dst, and last character wasn't null: overflow.
|
|
if(max_dst_chars <= max_src_chars)
|
|
{
|
|
*dst = '\0';
|
|
ENFORCE(0, ERR::BUF_SIZE, ERANGE);
|
|
}
|
|
// .. source: success, but still need to null-terminate the destination.
|
|
*p = '\0';
|
|
return 0;
|
|
}
|
|
|
|
|
|
// copy <src> (including trailing null) into <dst>, which must not overlap.
|
|
// if thereby <max_dst_chars> (including null) would be exceeded,
|
|
// <dst> is set to the empty string and ERANGE returned; otherwise,
|
|
// 0 is returned to indicate success and that <dst> is null-terminated.
|
|
int tcpy_s(tchar* dst, size_t max_dst_chars, const tchar* src)
|
|
{
|
|
return tncpy_s(dst, max_dst_chars, src, SIZE_MAX);
|
|
}
|
|
|
|
|
|
// append <src> to <dst>, which must not overlap.
|
|
// if thereby <max_dst_chars> (including null) would be exceeded,
|
|
// <dst> is set to the empty string and ERANGE returned; otherwise,
|
|
// 0 is returned to indicate success and that <dst> is null-terminated.
|
|
int tncat_s(tchar* dst, size_t max_dst_chars, const tchar* src, size_t max_src_chars)
|
|
{
|
|
ENFORCE(dst != 0, ERR::INVALID_PARAM, EINVAL);
|
|
ENFORCE(max_dst_chars != 0, ERR::INVALID_PARAM, EINVAL); // N1031 says ERANGE, MSDN/MSVC says EINVAL
|
|
// src is checked in tncpy_s
|
|
|
|
// WARN_IF_PTR_LEN not necessary: both max_dst_chars and max_src_chars
|
|
// are checked by tnlen / tncpy_s (respectively).
|
|
|
|
const size_t dst_len = tnlen(dst, max_dst_chars);
|
|
if(dst_len == max_dst_chars)
|
|
{
|
|
*dst = '\0';
|
|
ENFORCE(0, ERR::STRING_NOT_TERMINATED, EINVAL); // N1031/MSDN says ERANGE, MSVC says EINVAL
|
|
}
|
|
|
|
tchar* const end = dst+dst_len;
|
|
const size_t chars_left = max_dst_chars-dst_len;
|
|
int ret = tncpy_s(end, chars_left, src, max_src_chars);
|
|
// if tncpy_s overflowed, we need to clear the start of our string
|
|
// (not just the appended part). can't do that by default, because
|
|
// the beginning of dst is not changed in normal operation.
|
|
if(ret != 0)
|
|
*dst = '\0';
|
|
return ret;
|
|
}
|
|
|
|
|
|
// append <src> to <dst>, which must not overlap.
|
|
// if thereby <max_dst_chars> (including null) would be exceeded,
|
|
// <dst> is set to the empty string and ERANGE returned; otherwise,
|
|
// 0 is returned to indicate success and that <dst> is null-terminated.
|
|
//
|
|
// note: implemented as tncat_s(dst, max_dst_chars, src, SIZE_MAX)
|
|
int tcat_s(tchar* dst, size_t max_dst_chars, const tchar* src)
|
|
{
|
|
return tncat_s(dst, max_dst_chars, src, SIZE_MAX);
|
|
}
|
|
|
|
|
|
int tvsprintf_s(tchar* dst, size_t max_dst_chars, const tchar* fmt, va_list ap)
|
|
{
|
|
if(!dst || !fmt || max_dst_chars == 0)
|
|
{
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
const int ret = tvsnprintf(dst, max_dst_chars, fmt, ap);
|
|
if(ret >= int(max_dst_chars)) // not enough space
|
|
{
|
|
dst[0] = '\0';
|
|
return -1;
|
|
}
|
|
return ret; // negative if error, else # chars written (excluding '\0')
|
|
}
|
|
|
|
|
|
int tsprintf_s(tchar* buf, size_t max_chars, const tchar* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int len = tvsprintf_s(buf, max_chars, fmt, ap);
|
|
va_end(ap);
|
|
return len;
|
|
}
|
|
|
|
#endif // #if EMULATE_SECURE_CRT
|
|
|
|
#undef tchar
|
|
#undef T
|
|
#undef tnlen
|
|
#undef tncpy_s
|
|
#undef tcpy_s
|
|
#undef tncat_s
|
|
#undef tcat_s
|
|
#undef tcmp
|
|
#undef tcpy
|
|
#undef tvsnprintf
|
|
#undef tvsprintf_s
|
|
#undef tsprintf_s
|