}

#ifndef _MSC_VER
#  define FMT_SNPRINTF snprintf
#else  // _MSC_VER
inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
  va_list args;
  va_start(args, format);
  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);

            

Reported by FlawFinder.

              
  // Build the format string.
  enum { max_format_size = 7 };  // The longest format is "%#.*Le".
  char format[max_format_size];
  char* format_ptr = format;
  *format_ptr++ = '%';
  if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
  if (precision >= 0) {
    *format_ptr++ = '.';

            

Reported by FlawFinder.

                  for (auto end = p + s.size() - block_size + 1; p < end;) p = transcode(p);
  }
  if (auto num_chars_left = s.data() + s.size() - p) {
    char buf[2 * block_size - 1] = {};
    memcpy(buf, p, to_unsigned(num_chars_left));
    p = buf;
    do {
      p = transcode(p);
    } while (p - buf < num_chars_left);

            

Reported by FlawFinder.

                }
  if (auto num_chars_left = s.data() + s.size() - p) {
    char buf[2 * block_size - 1] = {};
    memcpy(buf, p, to_unsigned(num_chars_left));
    p = buf;
    do {
      p = transcode(p);
    } while (p - buf < num_chars_left);
  }

            

Reported by FlawFinder.

                  FMT_MAYBE_UNUSED
    int handle(char* message) {
      // If the buffer is full then the message is probably truncated.
      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
        return ERANGE;
      buffer_ = message;
      return 0;
    }


            

Reported by FlawFinder.

                  FMT_MAYBE_UNUSED
    int fallback(int result) {
      // If the buffer is full then the message is probably truncated.
      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
                                                                : result;
    }

#if !FMT_MSC_VER
    // Fallback to strerror if strerror_r and strerror_s are not available.

            

Reported by FlawFinder.

              static inline int
maps_init (struct map_iterator *mi, pid_t pid)
{
  char path[sizeof ("/proc/0123456789/maps")], *cp;

  memcpy (path, "/proc/", 6);
  cp = ltoa (path + 6, pid);
  assert (cp + 6 < path + sizeof (path));
  memcpy (cp, "/maps", 6);

            

Reported by FlawFinder.

              {
  char path[sizeof ("/proc/0123456789/maps")], *cp;

  memcpy (path, "/proc/", 6);
  cp = ltoa (path + 6, pid);
  assert (cp + 6 < path + sizeof (path));
  memcpy (cp, "/maps", 6);

  mi->fd = open (path, O_RDONLY);

            

Reported by FlawFinder.

                memcpy (path, "/proc/", 6);
  cp = ltoa (path + 6, pid);
  assert (cp + 6 < path + sizeof (path));
  memcpy (cp, "/maps", 6);

  mi->fd = open (path, O_RDONLY);
  if (mi->fd >= 0)
    {
      /* Try to allocate a page-sized buffer.  */

            

Reported by FlawFinder.

                assert (cp + 6 < path + sizeof (path));
  memcpy (cp, "/maps", 6);

  mi->fd = open (path, O_RDONLY);
  if (mi->fd >= 0)
    {
      /* Try to allocate a page-sized buffer.  */
      mi->buf_size = getpagesize ();
      cp = mmap (NULL, mi->buf_size, PROT_READ | PROT_WRITE,

            

Reported by FlawFinder.

              maps_next (struct map_iterator *mi,
           unsigned long *low, unsigned long *high, unsigned long *offset)
{
  char perm[16], dash = 0, colon = 0, *cp;
  unsigned long major, minor, inum;
  ssize_t i, nread;

  if (mi->fd < 0)
    return 0;

            

Reported by FlawFinder.

                          memmove (mi->buf_end - mi->buf_size, mi->buf, bytes_left);

          mi->buf = mi->buf_end - mi->buf_size;
          nread = read (mi->fd, mi->buf + bytes_left,
                        mi->buf_size - bytes_left);
          if (nread <= 0)
            return 0;
          else if ((size_t) (nread + bytes_left) < mi->buf_size)
            {

            

Reported by FlawFinder.

              #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
         int r = (::sprintf_s)(buf, sizeof(buf), "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
#else
         int r = (std::sprintf)(buf, "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
#endif
         if(r < 0)
         {
            // sprintf failed, skip this item:
            ++dstart;

            

Reported by FlawFinder.

                 if(recurse)
   {
      // go through sub directories:
      char buf[MAX_PATH];
      BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(buf, MAX_PATH, start.root()));
      if(*buf == 0)
      {
         BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(buf, MAX_PATH, "."));
         BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcat_s(buf, MAX_PATH, directory_iterator::separator()));

            

Reported by FlawFinder.

                    while(dstart != dend)
      {
         // Verify that sprintf will not overflow:
         if(std::strlen(dstart.path()) + std::strlen(directory_iterator::separator()) + std::strlen(ptr) >= MAX_PATH)
         {
            // Oops overflow, skip this item:
            ++dstart;
            continue;
         }

            

Reported by FlawFinder.

                    while(dstart != dend)
      {
         // Verify that sprintf will not overflow:
         if(std::strlen(dstart.path()) + std::strlen(directory_iterator::separator()) + std::strlen(ptr) >= MAX_PATH)
         {
            // Oops overflow, skip this item:
            ++dstart;
            continue;
         }

            

Reported by FlawFinder.

                    while(dstart != dend)
      {
         // Verify that sprintf will not overflow:
         if(std::strlen(dstart.path()) + std::strlen(directory_iterator::separator()) + std::strlen(ptr) >= MAX_PATH)
         {
            // Oops overflow, skip this item:
            ++dstart;
            continue;
         }

            

Reported by FlawFinder.

                 std::string result;
   if(!copy) flags |= format_no_copy;
   BOOST_REGEX_DETAIL_NS::string_out_iterator<std::string> i(result);
   regex_replace(i, in, in + std::strlen(in), pdata->e, fmt, flags);
   return result;
}

std::size_t RegEx::Split(std::vector<std::string>& v, 
                      std::string& s,

            

Reported by FlawFinder.

              namespace aux {

//! Hex character table, defined in dump.cpp
extern const char g_hex_char_table[2][16];

} // namespace aux

namespace ipc {


            

Reported by FlawFinder.

                      const boost::winapi::DWORD_ err = boost::winapi::GetLastError();
        if (BOOST_LIKELY(err == ERROR_ALREADY_EXISTS))
        {
            open(name);
            return;
        }
        else
        {
            BOOST_LOG_THROW_DESCR_PARAMS(boost::log::system_error, "Failed to create an interprocess event object", (err));

            

Reported by FlawFinder.

                  m_event.init(h);
}

void interprocess_event::open(const wchar_t* name)
{
    boost::winapi::HANDLE_ h = boost::winapi::OpenEventW(boost::winapi::SYNCHRONIZE_ | boost::winapi::EVENT_MODIFY_STATE_, false, name);
    if (BOOST_UNLIKELY(h == NULL))
    {
        const boost::winapi::DWORD_ err = boost::winapi::GetLastError();

            

Reported by FlawFinder.

                      boost::winapi::DWORD_ err = boost::winapi::GetLastError();
        if (BOOST_LIKELY(err == ERROR_ALREADY_EXISTS))
        {
            open(name);
            return;
        }
        else
        {
            BOOST_LOG_THROW_DESCR_PARAMS(boost::log::system_error, "Failed to create an interprocess semaphore object", (err));

            

Reported by FlawFinder.

                  m_sem.init(h);
}

void interprocess_semaphore::open(const wchar_t* name)
{
    boost::winapi::HANDLE_ h = boost::winapi::OpenSemaphoreW(boost::winapi::SYNCHRONIZE_ | boost::winapi::SEMAPHORE_MODIFY_STATE_ | boost::winapi::SEMAPHORE_QUERY_STATE_, false, name);
    if (BOOST_UNLIKELY(h == NULL))
    {
        const boost::winapi::DWORD_ err = boost::winapi::GetLastError();

            

Reported by FlawFinder.

                  );
    if (BOOST_UNLIKELY(err != 0u))
    {
        char buf[sizeof(unsigned int) * 2u + 4u];
        boost::log::aux::snprintf(buf, sizeof(buf), "0x%08x", static_cast< unsigned int >(err));
        BOOST_LOG_THROW_DESCR_PARAMS(boost::log::system_error, std::string("Failed to test an interprocess semaphore object for zero count, NT status: ") + buf, (ERROR_INVALID_HANDLE));
    }

    return info.current_count == 0u;

            

Reported by FlawFinder.

              import sys
import subprocess

from . import fileops


class RunCommand(object):
    """Class to abstract executing a subprocess."""


            

Reported by Pylint.

              import pipes
import shlex
import sys
import subprocess

from . import fileops


class RunCommand(object):

            

Reported by Bandit.

              
    def execute(self):
        """Execute 'cmd' and return err_code and output."""
        self._process = subprocess.Popen(self._cmd_list(), stdout=subprocess.PIPE,
                                         stderr=subprocess.STDOUT, **self._preexec_kargs)
        output, _ = self._process.communicate()
        error_code = self._process.returncode
        return error_code, output


            

Reported by Bandit.

              
    def execute_with_output(self):
        """Execute the command, return result as a string."""
        return subprocess.check_output(self._cmd_list()).decode('utf-8')

    def execute_save_output(self):
        """Execute the command, save result in 'self.output_file' and return returncode."""
        with fileops.get_file_handle(self.output_file, self.append_file) as file_handle:
            ret = subprocess.check_call(self._cmd_list(), stdout=file_handle)

            

Reported by Bandit.

                  def execute_save_output(self):
        """Execute the command, save result in 'self.output_file' and return returncode."""
        with fileops.get_file_handle(self.output_file, self.append_file) as file_handle:
            ret = subprocess.check_call(self._cmd_list(), stdout=file_handle)
        return ret

    def start_process(self):
        """Start to execute the command."""
        # Do not propagate interrupts to the child process.

            

Reported by Bandit.

                      """Start to execute the command."""
        # Do not propagate interrupts to the child process.
        with fileops.get_file_handle(self.output_file, self.append_file) as file_handle:
            self._process = subprocess.Popen(self._cmd_list(), stdin=subprocess.PIPE,
                                             stdout=file_handle, stderr=subprocess.STDOUT,
                                             **self._preexec_kargs)

    def send_to_process(self, string=None):
        """Send 'string' to a running processs and return stdout, stderr."""

            

Reported by Bandit.

              #ifdef LTC_YARROW
struct yarrow_prng {
    int                   cipher, hash;
    unsigned char         pool[MAXBLOCKSIZE];
    symmetric_CTR         ctr;
};
#endif

#ifdef LTC_RC4

            

Reported by FlawFinder.

              #ifdef LTC_CHACHA20_PRNG
struct chacha20_prng {
    chacha_state s;        /* chacha state */
    unsigned char ent[40]; /* entropy buffer */
    unsigned long idx;     /* entropy counter */
};
#endif

#ifdef LTC_FORTUNA

            

Reported by FlawFinder.

              
    symmetric_key skey;

    unsigned char K[32],      /* the current key */
                  IV[16];     /* IV for CTR mode */

    unsigned long pool_idx,   /* current pool we will add to */
                  pool0_len,  /* length of 0'th pool */
                  wd;

            

Reported by FlawFinder.

              #ifdef LTC_SOBER128
struct sober128_prng {
    sober128_state s;      /* sober128 state */
    unsigned char ent[40]; /* entropy buffer */
    unsigned long idx;     /* entropy counter */
};
#endif

typedef struct {

            

Reported by FlawFinder.

              
typedef struct {
   union {
      char dummy[1];
#ifdef LTC_YARROW
      struct yarrow_prng    yarrow;
#endif
#ifdef LTC_RC4
      struct rc4_prng       rc4;

            

Reported by FlawFinder.

                      @param prng    The PRNG state to read from
        @return Number of octets read
    */
    unsigned long (*read)(unsigned char *out, unsigned long outlen, prng_state *prng);
    /** Terminate a PRNG state
        @param prng   The PRNG state to terminate
        @return CRYPT_OK if successful
    */
    int (*done)(prng_state *prng);

            

Reported by FlawFinder.

                      //! A tag value to ensure the correct binary layout of the message queue data structures. Must be placed first and always have a fixed size and alignment.
        uint32_t m_abi_tag;
        //! Padding to protect against alignment changes in Boost.Atomic. Don't use BOOST_ALIGNMENT to ensure portability.
        unsigned char m_padding[BOOST_LOG_CPU_CACHE_LINE_SIZE - sizeof(uint32_t)];
        //! Reference counter. Also acts as a flag indicating that the queue is constructed (i.e. the queue is constructed when the counter is not 0).
        boost::atomic< uint32_t > m_ref_count;
        //! Number of allocation blocks in the queue.
        const uint32_t m_capacity;
        //! Size of an allocation block, in bytes.

            

Reported by FlawFinder.

                      block->m_size = message_size;

        size_type write_size = (std::min)(static_cast< size_type >((capacity - pos) * block_size - block_header::get_header_overhead()), message_size);
        std::memcpy(block->get_data(), message_data, write_size);

        pos += block_count;
        if (BOOST_UNLIKELY(pos >= capacity))
        {
            // Write the rest of the message at the beginning of the queue

            

Reported by FlawFinder.

                          message_data = static_cast< const unsigned char* >(message_data) + write_size;
            write_size = message_size - write_size;
            if (write_size > 0u)
                std::memcpy(hdr->get_block(0u), message_data, write_size);
        }

        hdr->m_put_pos = pos;

        const uint32_t old_queue_size = hdr->m_size;

            

Reported by FlawFinder.

                  }
}

BOOST_LOG_API void reliable_message_queue::open(object_name const& name, overflow_policy oflow_policy, permissions const&)
{
    BOOST_ASSERT(m_impl == NULL);
    try
    {
        m_impl = new implementation(open_mode::open_only, name, oflow_policy);

            

Reported by FlawFinder.

                  if (BOOST_UNLIKELY(size > p->size))
        BOOST_THROW_EXCEPTION(bad_alloc("Buffer too small to receive the message"));

    std::memcpy(p->data, data, size);
    p->data += size;
    p->size -= size;
}

BOOST_LOG_API void reliable_message_queue::remove(object_name const& name)

            

Reported by FlawFinder.

                              ts.tv_nsec = 1000;
                nanosleep(&ts, NULL);
#else
                usleep(1);
#endif
            }
        }

        BOOST_LOG_THROW_DESCR(setup_error, "Boost.Log interprocess message queue cannot be opened: shared memory segment is not initialized by creator for too long");

            

Reported by FlawFinder.

                           chain.  This is very crude, however, and won't be able to unwind
             any registers besides the IP, SP, and LR . */

          back_chain_offset = ((void *) &dummy.back_chain - (void *) &dummy);
          lr_save_offset = ((void *) &dummy.lr_save - (void *) &dummy);

          back_chain_loc = DWARF_LOC (c->dwarf.cfa + back_chain_offset, 0);

          if ((ret =

            

Reported by Cppcheck.

                           chain.  This is very crude, however, and won't be able to unwind
             any registers besides the IP, SP, and LR . */

          back_chain_offset = ((void *) &dummy.back_chain - (void *) &dummy);
          lr_save_offset = ((void *) &dummy.lr_save - (void *) &dummy);

          back_chain_loc = DWARF_LOC (c->dwarf.cfa + back_chain_offset, 0);

          if ((ret =

            

Reported by Cppcheck.

                           chain.  This is very crude, however, and won't be able to unwind
             any registers besides the IP, SP, and LR . */

          back_chain_offset = ((void *) &dummy.back_chain - (void *) &dummy);
          lr_save_offset = ((void *) &dummy.lr_save - (void *) &dummy);

          back_chain_loc = DWARF_LOC (c->dwarf.cfa + back_chain_offset, 0);

          if ((ret =

            

Reported by Cppcheck.

                           chain.  This is very crude, however, and won't be able to unwind
             any registers besides the IP, SP, and LR . */

          back_chain_offset = ((void *) &dummy.back_chain - (void *) &dummy);
          lr_save_offset = ((void *) &dummy.lr_save - (void *) &dummy);

          back_chain_loc = DWARF_LOC (c->dwarf.cfa + back_chain_offset, 0);

          if ((ret =

            

Reported by Cppcheck.

                           any registers besides the IP, SP, and LR . */

          back_chain_offset = ((void *) &dummy.back_chain - (void *) &dummy);
          lr_save_offset = ((void *) &dummy.lr_save - (void *) &dummy);

          back_chain_loc = DWARF_LOC (c->dwarf.cfa + back_chain_offset, 0);

          if ((ret =
               dwarf_get (&c->dwarf, back_chain_loc, &c->dwarf.cfa)) < 0)

            

Reported by Cppcheck.

                           any registers besides the IP, SP, and LR . */

          back_chain_offset = ((void *) &dummy.back_chain - (void *) &dummy);
          lr_save_offset = ((void *) &dummy.lr_save - (void *) &dummy);

          back_chain_loc = DWARF_LOC (c->dwarf.cfa + back_chain_offset, 0);

          if ((ret =
               dwarf_get (&c->dwarf, back_chain_loc, &c->dwarf.cfa)) < 0)

            

Reported by Cppcheck.

                                  throw std::runtime_error("Unsupported encoding" + encoding);
                }
                for(unsigned c=0;c<256;c++) {
                    char ibuf[2] = { char(c) , 0 };
                    char *in = ibuf;
                    size_t insize =2;
                    uint32_t obuf[2] = {illegal,illegal};
                    char *out = reinterpret_cast<char *>(obuf);
                    size_t outsize = 8;

            

Reported by FlawFinder.

                          else if(begin+1 == end)
                return incomplete;
            
            open(to_utf_,utf32_encoding(),encoding_.c_str());

            // maybe illegal or may be double byte

            char inseq[3] = { static_cast<char>(seq0) , begin[1], 0};
            char *inbuf = inseq;

            

Reported by FlawFinder.

              
            // maybe illegal or may be double byte

            char inseq[3] = { static_cast<char>(seq0) , begin[1], 0};
            char *inbuf = inseq;
            size_t insize = 3;
            uint32_t result[2] = { illegal, illegal };
            size_t outsize = 8;
            char *outbuf = reinterpret_cast<char*>(result);

            

Reported by FlawFinder.

                              }
            }

            open(from_utf_,encoding_.c_str(),utf32_encoding());

            uint32_t codepoints[2] = {cp,0};
            char *inbuf = reinterpret_cast<char *>(codepoints);
            size_t insize = sizeof(codepoints);
            char outseq[3] = {0};

            

Reported by FlawFinder.

                          uint32_t codepoints[2] = {cp,0};
            char *inbuf = reinterpret_cast<char *>(codepoints);
            size_t insize = sizeof(codepoints);
            char outseq[3] = {0};
            char *outbuf = outseq;
            size_t outsize = 3;

            call_iconv(from_utf_,&inbuf,&insize,&outbuf,&outsize);


            

Reported by FlawFinder.

                          return len;
        }

        void open(iconv_t &d,char const *to,char const *from)
        {
            if(d!=(iconv_t)(-1))
                return;
            d=iconv_open(to,from);
        }

            

Reported by FlawFinder.

              
static FILE *logfp; /* Log file */

static char home[512];

static int handle_error(WT_EVENT_HANDLER *, WT_SESSION *, int, const char *);
static int handle_message(WT_EVENT_HANDLER *, WT_SESSION *, const char *);
static void onint(int) WT_GCC_FUNC_DECL_ATTRIBUTE((noreturn));
static void shutdown(void);

            

Reported by FlawFinder.

                          working_dir = __wt_optarg;
            break;
        case 'l': /* log */
            if ((logfp = fopen(__wt_optarg, "w")) == NULL) {
                fprintf(stderr, "%s: %s\n", __wt_optarg, strerror(errno));
                return (EXIT_FAILURE);
            }
            break;
        case 'n': /* operations */

            

Reported by FlawFinder.

                          }
            break;
        case 'n': /* operations */
            nops = (u_int)atoi(__wt_optarg);
            break;
        case 'r': /* runs */
            runs = atoi(__wt_optarg);
            break;
        case 't':

            

Reported by FlawFinder.

                          nops = (u_int)atoi(__wt_optarg);
            break;
        case 'r': /* runs */
            runs = atoi(__wt_optarg);
            break;
        case 't':
            nthreads = (u_int)atoi(__wt_optarg);
            break;
        case 'x':

            

Reported by FlawFinder.

                          runs = atoi(__wt_optarg);
            break;
        case 't':
            nthreads = (u_int)atoi(__wt_optarg);
            break;
        case 'x':
            use_txn = true;
            break;
        default:

            

Reported by FlawFinder.

                  static WT_EVENT_HANDLER event_handler = {
      handle_error, handle_message, NULL, NULL /* Close handler. */
    };
    char config_buf[128];

    testutil_make_work_dir(home);

    testutil_check(__wt_snprintf(config_buf, sizeof(config_buf),
      "create,error_prefix=\"%s\",cache_size=5MB%s%s,operation_tracking=(enabled=false)", progname,

            

Reported by FlawFinder.