607b668ff9
The primary purpose of this is to encourage adoption of libjpeg-turbo in downstream Windows projects that forbid the use of "deprecated" functions. libjpeg-turbo's usage of those functions was not actually unsafe, because: - libjpeg-turbo always checks the return value of fopen() and ensures that a NULL filename can never be passed to it. - libjpeg-turbo always checks the return value of getenv() and never passes a NULL argument to it. - The sprintf() calls in format_message() (jerror.c) could never overflow the destination string buffer or leave it unterminated as long as the buffer was at least JMSG_LENGTH_MAX bytes in length, as instructed. (Regardless, this commit replaces those calls with snprintf() calls.) - libjpeg-turbo never uses sscanf() to read strings or multi-byte character arrays. - Because ofb7d6e84d6a, wrjpgcom explicitly checks the bounds of the source and destination strings before calling strcat() and strcpy(). - libjpeg-turbo always ensures that the destination string is terminated when using strncpy(). (548490fe5emade this explicit.) Regarding thread safety: Technically speaking, getenv() is not thread-safe, because the returned pointer may be invalidated if another thread sets the same environment variable between the time that the first thread calls getenv() and the time that that thread uses the return value. In practice, however, this could only occur with libjpeg-turbo if: (1) A multithreaded calling application used the deprecated and undocumented TJFLAG_FORCEMMX/TJFLAG_FORCESSE/TJFLAG_FORCESSE2 flags in the TurboJPEG API or set one of the corresponding environment variables (which are only intended for testing purposes.) Since the TurboJPEG API library only ever passed string constants to putenv(), the only inherent risk (i.e. the only risk introduced by the library and not the calling application) was that the SIMD extensions may have read an incorrect value from one of the aforementioned environment variables. or (2) A multithreaded calling application modified the value of the JPEGMEM environment variable in one thread while another thread was reading the value of that environment variable (in the body of jpeg_create_compress() or jpeg_create_decompress().) Given that the libjpeg API provides a thread-safe way for applications to modify the default memory limit without using the JPEGMEM environment variable, direct modification of that environment variable by calling applications is not supported. Microsoft's implementation of getenv_s() does not claim to be thread-safe either, so this commit uses getenv_s() solely to mollify Visual Studio. New inline functions and macros (GETENV_S() and PUTENV_S) wrap getenv_s()/_putenv_s() when building for Visual Studio and getenv()/setenv() otherwise, but GETENV_S()/PUTENV_S() provide no advantages over getenv()/setenv() other than parameter validation. They are implemented solely for convenience. Technically speaking, strerror() is not thread-safe, because the returned pointer may be invalidated if another thread changes the locale and/or calls strerror() between the time that the first thread calls strerror() and the time that that thread uses the return value. In practice, however, this could only occur with libjpeg-turbo if a multithreaded calling application encountered a file I/O error in tjLoadImage() or tjSaveImage(). Since both of those functions immediately copy the string returned from strerror() into a thread-local buffer, the risk is minimal, and the worst case would involve an incorrect error string being reported to the calling application. Regardless, this commit uses strerror_s() in the TurboJPEG API library when building for Visual Studio. Note that strerror_r() could have been used on Un*x systems, but it would have been necessary to handle both the POSIX and GNU implementations of that function and perform widespread compatibility testing. Such is left as an exercise for another day. Fixes #568
166 lines
4.4 KiB
C
166 lines
4.4 KiB
C
/*
|
|
* Copyright (C)2022 D. R. Commander. All Rights Reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* - Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "jinclude.h"
|
|
|
|
|
|
#define CHECK_VALUE(actual, expected, desc) \
|
|
if (actual != expected) { \
|
|
printf("ERROR in line %d: " desc " is %d, should be %d\n", \
|
|
__LINE__, actual, expected); \
|
|
return -1; \
|
|
}
|
|
|
|
#define CHECK_ERRNO(errno_return, expected_errno) \
|
|
CHECK_VALUE(errno_return, expected_errno, "Return value") \
|
|
CHECK_VALUE(errno, expected_errno, "errno") \
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
void invalid_parameter_handler(const wchar_t *expression,
|
|
const wchar_t *function, const wchar_t *file,
|
|
unsigned int line, uintptr_t pReserved)
|
|
{
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int err;
|
|
char env[3];
|
|
|
|
#ifdef _MSC_VER
|
|
_set_invalid_parameter_handler(invalid_parameter_handler);
|
|
#endif
|
|
|
|
/***************************************************************************/
|
|
|
|
#ifndef NO_PUTENV
|
|
|
|
printf("PUTENV_S():\n");
|
|
|
|
errno = 0;
|
|
err = PUTENV_S(NULL, "12");
|
|
CHECK_ERRNO(err, EINVAL);
|
|
|
|
errno = 0;
|
|
err = PUTENV_S("TESTENV", NULL);
|
|
CHECK_ERRNO(err, EINVAL);
|
|
|
|
errno = 0;
|
|
err = PUTENV_S("TESTENV", "12");
|
|
CHECK_ERRNO(err, 0);
|
|
|
|
printf("SUCCESS!\n\n");
|
|
|
|
#endif
|
|
|
|
/***************************************************************************/
|
|
|
|
#ifndef NO_GETENV
|
|
|
|
printf("GETENV_S():\n");
|
|
|
|
errno = 0;
|
|
env[0] = 1;
|
|
env[1] = 2;
|
|
env[2] = 3;
|
|
err = GETENV_S(env, 3, NULL);
|
|
CHECK_ERRNO(err, 0);
|
|
CHECK_VALUE(env[0], 0, "env[0]");
|
|
CHECK_VALUE(env[1], 2, "env[1]");
|
|
CHECK_VALUE(env[2], 3, "env[2]");
|
|
|
|
errno = 0;
|
|
env[0] = 1;
|
|
env[1] = 2;
|
|
env[2] = 3;
|
|
err = GETENV_S(env, 3, "TESTENV2");
|
|
CHECK_ERRNO(err, 0);
|
|
CHECK_VALUE(env[0], 0, "env[0]");
|
|
CHECK_VALUE(env[1], 2, "env[1]");
|
|
CHECK_VALUE(env[2], 3, "env[2]");
|
|
|
|
errno = 0;
|
|
err = GETENV_S(NULL, 3, "TESTENV");
|
|
CHECK_ERRNO(err, EINVAL);
|
|
|
|
errno = 0;
|
|
err = GETENV_S(NULL, 0, "TESTENV");
|
|
CHECK_ERRNO(err, 0);
|
|
|
|
errno = 0;
|
|
env[0] = 1;
|
|
err = GETENV_S(env, 0, "TESTENV");
|
|
CHECK_ERRNO(err, EINVAL);
|
|
CHECK_VALUE(env[0], 1, "env[0]");
|
|
|
|
errno = 0;
|
|
env[0] = 1;
|
|
env[1] = 2;
|
|
env[2] = 3;
|
|
err = GETENV_S(env, 1, "TESTENV");
|
|
CHECK_VALUE(err, ERANGE, "Return value");
|
|
CHECK_VALUE(errno, 0, "errno");
|
|
CHECK_VALUE(env[0], 0, "env[0]");
|
|
CHECK_VALUE(env[1], 2, "env[1]");
|
|
CHECK_VALUE(env[2], 3, "env[2]");
|
|
|
|
errno = 0;
|
|
env[0] = 1;
|
|
env[1] = 2;
|
|
env[2] = 3;
|
|
err = GETENV_S(env, 2, "TESTENV");
|
|
CHECK_VALUE(err, ERANGE, "Return value");
|
|
CHECK_VALUE(errno, 0, "errno");
|
|
CHECK_VALUE(env[0], 0, "env[0]");
|
|
CHECK_VALUE(env[1], 2, "env[1]");
|
|
CHECK_VALUE(env[2], 3, "env[2]");
|
|
|
|
errno = 0;
|
|
env[0] = 1;
|
|
env[1] = 2;
|
|
env[2] = 3;
|
|
err = GETENV_S(env, 3, "TESTENV");
|
|
CHECK_ERRNO(err, 0);
|
|
CHECK_VALUE(env[0], '1', "env[0]");
|
|
CHECK_VALUE(env[1], '2', "env[1]");
|
|
CHECK_VALUE(env[2], 0, "env[2]");
|
|
|
|
printf("SUCCESS!\n\n");
|
|
|
|
#endif
|
|
|
|
/***************************************************************************/
|
|
|
|
return 0;
|
|
}
|