diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1e7da8f..9edc562 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -108,9 +108,8 @@
 # Enable usage of the VERSION specifier
 include(CheckCXXCompilerFlag)
 if (WIN32)
-	add_definitions(-DWIN32_LEAN_AND_MEAN)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-	add_compile_options("/W1")
+    add_compile_definitions(WIN32_LEAN_AND_MEAN _CRT_SECURE_NO_WARNINGS)
+    add_compile_options(/W3 /utf-8)
   if ((MSVC_VERSION GREATER "1900") OR (MSVC_VERSION EQUAL "1900"))
     CHECK_CXX_COMPILER_FLAG("/std:c++14" _cpp_latest_flag_supported)
     if (_cpp_latest_flag_supported)
diff --git a/extensions/civetweb/processors/ListenHTTP.cpp b/extensions/civetweb/processors/ListenHTTP.cpp
index be66960..cb21f41 100644
--- a/extensions/civetweb/processors/ListenHTTP.cpp
+++ b/extensions/civetweb/processors/ListenHTTP.cpp
@@ -467,7 +467,7 @@
     }
 
     // Transfer buffer data to the output stream
-    stream->write(&buf[0], rlen);
+    stream->write(&buf[0], gsl::narrow<int>(rlen));
 
     nlen += rlen;
   }
diff --git a/extensions/civetweb/processors/ListenHTTP.h b/extensions/civetweb/processors/ListenHTTP.h
index 847a536..ce9601e 100644
--- a/extensions/civetweb/processors/ListenHTTP.h
+++ b/extensions/civetweb/processors/ListenHTTP.h
@@ -139,7 +139,7 @@
     int64_t process(std::shared_ptr<io::BaseStream> stream) {
       out_str_->resize(stream->getSize());
       uint64_t num_read = stream->readData(reinterpret_cast<uint8_t *>(&(*out_str_)[0]),
-                                           static_cast<int>(stream->getSize()));
+                                           gsl::narrow<int>(stream->getSize()));
 
       if (num_read != stream->getSize()) {
         throw std::runtime_error("GraphReadCallback failed to fully read flow file input stream");
diff --git a/extensions/civetweb/tests/ListenHTTPTests.cpp b/extensions/civetweb/tests/ListenHTTPTests.cpp
index b628139..89699be 100644
--- a/extensions/civetweb/tests/ListenHTTPTests.cpp
+++ b/extensions/civetweb/tests/ListenHTTPTests.cpp
@@ -35,8 +35,7 @@
 
 class ListenHTTPTestsFixture {
  public:
-  ListenHTTPTestsFixture()
-   : tmp_dir_format(strdup("/tmp/gt.XXXXXX")) {
+  ListenHTTPTestsFixture() {
     LogTestController::getInstance().setDebug<TestPlan>();
     LogTestController::getInstance().setDebug<minifi::FlowController>();
     LogTestController::getInstance().setDebug<minifi::SchedulingAgent>();
@@ -50,6 +49,7 @@
     LogTestController::getInstance().setDebug<minifi::controllers::SSLContextService>();
 
     // Create temporary directories
+    char tmp_dir_format[] = "/tmp/gt.XXXXXX";
     tmp_dir = testController.createTempDirectory(tmp_dir_format);
     REQUIRE(!tmp_dir.empty());
 
@@ -92,7 +92,6 @@
   }
 
   virtual ~ListenHTTPTestsFixture() {
-    free(tmp_dir_format);
     LogTestController::getInstance().reset();
   }
 
@@ -169,7 +168,6 @@
   }
 
  protected:
-  char* tmp_dir_format;
   std::string tmp_dir;
   TestController testController;
   std::shared_ptr<TestPlan> plan;
diff --git a/extensions/expression-language/Expression.cpp b/extensions/expression-language/Expression.cpp
index 2ddc68d..d1d4c56 100644
--- a/extensions/expression-language/Expression.cpp
+++ b/extensions/expression-language/Expression.cpp
@@ -194,9 +194,12 @@
 
 Value expr_substring(const std::vector<Value> &args) {
   if (args.size() < 3) {
-    return Value(args[0].asString().substr(args[1].asUnsignedLong()));
+    size_t offset = gsl::narrow<size_t>(args[1].asUnsignedLong());
+    return Value(args[0].asString().substr(offset));
   } else {
-    return Value(args[0].asString().substr(args[1].asUnsignedLong(), args[2].asUnsignedLong()));
+    size_t offset = gsl::narrow<size_t>(args[1].asUnsignedLong());
+    size_t count = gsl::narrow<size_t>(args[2].asUnsignedLong());
+    return Value(args[0].asString().substr(offset, count));
   }
 }
 
@@ -269,7 +272,7 @@
   std::string result;
   result.resize(1024);
 
-  for (uint64_t parse_pos = 0; parse_pos < subject.length(); parse_pos++) {
+  for (size_t parse_pos = 0; parse_pos < subject.length(); parse_pos++) {
     char cur_ch = subject[parse_pos];
 
     if (cur_ch == escape_ch) {
@@ -808,7 +811,7 @@
     } else {
       return Value(ldop(args[0].asLongDouble(), args[1].asLongDouble()));
     }
-  } catch (const std::exception &e) {
+  } catch (const std::exception &) {
     return Value();
   }
 }
@@ -873,7 +876,7 @@
 }
 
 Value expr_fromRadix(const std::vector<Value> &args) {
-  auto radix = args[1].asSignedLong();
+  int radix = gsl::narrow<int>(args[1].asSignedLong());
 
   if (radix < 2 || radix > 36) {
     throw std::runtime_error("Cannot perform conversion due to invalid radix");
diff --git a/extensions/expression-language/common/Value.h b/extensions/expression-language/common/Value.h
index 26918c7..bc29f68 100644
--- a/extensions/expression-language/common/Value.h
+++ b/extensions/expression-language/common/Value.h
@@ -185,9 +185,9 @@
     } else if (is_signed_long_) {
       return signed_long_val_;
     } else if (is_long_double_) {
-      return long_double_val_;
+      return static_cast<uint64_t >(long_double_val_);
     } else {
-      return 0.0;
+      return 0;
     }
   }
 
@@ -199,17 +199,17 @@
     } else if (is_string_) {
       return string_val_.empty() ? 0 : std::stol(string_val_);
     } else if (is_long_double_) {
-      return long_double_val_;
+      return static_cast<int64_t >(long_double_val_);
     } else {
-      return 0.0;
+      return 0;
     }
   }
 
   long double asLongDouble() const {
     if (is_signed_long_) {
-      return signed_long_val_;
+      return static_cast<long double>(signed_long_val_);
     } else if (is_unsigned_long_) {
-      return unsigned_long_val_;
+      return static_cast<long double>(unsigned_long_val_);
     } else if (is_long_double_) {
       return long_double_val_;
     } else if (is_string_) {
diff --git a/extensions/http-curl/client/HTTPCallback.h b/extensions/http-curl/client/HTTPCallback.h
index 12d4b92..b124bc6 100644
--- a/extensions/http-curl/client/HTTPCallback.h
+++ b/extensions/http-curl/client/HTTPCallback.h
@@ -83,7 +83,7 @@
 
     if (stream->getSize() > 0) {
       vec.resize(stream->getSize());
-      stream->readData(reinterpret_cast<uint8_t*>(vec.data()), stream->getSize());
+      stream->readData(reinterpret_cast<uint8_t*>(vec.data()), gsl::narrow<int>(stream->getSize()));
     }
 
     return processInner(std::move(vec));
diff --git a/extensions/http-curl/client/HTTPClient.cpp b/extensions/http-curl/client/HTTPClient.cpp
index 518da4a..9c36693 100644
--- a/extensions/http-curl/client/HTTPClient.cpp
+++ b/extensions/http-curl/client/HTTPClient.cpp
@@ -288,7 +288,9 @@
   if (callback == nullptr) {
     read_callback_.close();
   }
+  long http_code;
   curl_easy_getinfo(http_session_, CURLINFO_RESPONSE_CODE, &http_code);
+  http_code_ = http_code;
   curl_easy_getinfo(http_session_, CURLINFO_CONTENT_TYPE, &content_type_str_);
   if (res == CURLE_OPERATION_TIMEDOUT) {
     logger_->log_error("HTTP operation timed out, with absolute timeout %dms\n", absoluteTimeout);
@@ -306,8 +308,8 @@
   return res;
 }
 
-int64_t &HTTPClient::getResponseCode() {
-  return http_code;
+int64_t HTTPClient::getResponseCode() const {
+  return http_code_;
 }
 
 const char *HTTPClient::getContentType() {
@@ -367,7 +369,7 @@
   try {
     utils::Regex rgx(sregex);
     return rgx.match(value);
-  } catch (const Exception &e) {
+  } catch (const Exception &) {
     return false;
   }
 }
diff --git a/extensions/http-curl/client/HTTPClient.h b/extensions/http-curl/client/HTTPClient.h
index 8cc38ab..3b1941a 100644
--- a/extensions/http-curl/client/HTTPClient.h
+++ b/extensions/http-curl/client/HTTPClient.h
@@ -15,6 +15,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+// Visual Studio 2017 warns when overriding a deprecated function, even if
+// the override is also deprecated.  Note that we need to put this #pragma
+// here, because it doesn't work inside the #ifndef
+#ifdef WIN32
+#pragma warning(push)
+#pragma warning(disable: 4996)
+#endif
+
 #ifndef EXTENSIONS_HTTP_CURL_CLIENT_HTTPCLIENT_H_
 #define EXTENSIONS_HTTP_CURL_CLIENT_HTTPCLIENT_H_
 
@@ -117,7 +126,7 @@
 
   CURLcode getResponseResult();
 
-  int64_t &getResponseCode() override;
+  int64_t getResponseCode() const override;
 
   const char *getContentType() override;
 
@@ -269,7 +278,7 @@
   struct curl_slist *headers_{nullptr};
   HTTPReadCallback *callback{nullptr};
   HTTPUploadCallback *write_callback_{nullptr};
-  int64_t http_code{0};
+  int64_t http_code_{0};
   ByteOutputCallback read_callback_{INT_MAX};
   utils::HTTPHeaderResponse header_response_{-1};
 
@@ -293,3 +302,7 @@
 }  // namespace org
 
 #endif  // EXTENSIONS_HTTP_CURL_CLIENT_HTTPCLIENT_H_
+
+#ifdef WIN32
+#pragma warning(pop)
+#endif
diff --git a/extensions/http-curl/client/HTTPStream.h b/extensions/http-curl/client/HTTPStream.h
index ce6796b..9ca4821 100644
--- a/extensions/http-curl/client/HTTPStream.h
+++ b/extensions/http-curl/client/HTTPStream.h
@@ -79,7 +79,7 @@
    */
   virtual void seek(uint64_t offset) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     return written;
   }
 
diff --git a/extensions/http-curl/processors/InvokeHTTP.cpp b/extensions/http-curl/processors/InvokeHTTP.cpp
index 78d9db3..e696569 100644
--- a/extensions/http-curl/processors/InvokeHTTP.cpp
+++ b/extensions/http-curl/processors/InvokeHTTP.cpp
@@ -26,6 +26,7 @@
 #include <memory>
 #include <algorithm>
 #include <cctype>
+#include <cinttypes>
 #include <cstdint>
 #include <cstring>
 #include <iostream>
@@ -345,10 +346,10 @@
     flowFile->addAttribute(REQUEST_URL, url_);
     flowFile->addAttribute(TRANSACTION_ID, tx_id);
 
-    bool isSuccess = ((int32_t) (http_code / 100)) == 2;
+    bool isSuccess = (static_cast<int32_t>(http_code / 100) == 2);
     bool output_body_to_content = isSuccess && !putToAttribute;
 
-    logger_->log_debug("isSuccess: %d, response code %d", isSuccess, http_code);
+    logger_->log_debug("isSuccess: %d, response code %" PRId64, isSuccess, http_code);
     std::shared_ptr<FlowFileRecord> response_flow = nullptr;
 
     if (output_body_to_content) {
@@ -378,7 +379,7 @@
 }
 
 void InvokeHTTP::route(std::shared_ptr<FlowFileRecord> &request, std::shared_ptr<FlowFileRecord> &response, const std::shared_ptr<core::ProcessSession> &session,
-                       const std::shared_ptr<core::ProcessContext> &context, bool isSuccess, int statusCode) {
+                       const std::shared_ptr<core::ProcessContext> &context, bool isSuccess, int64_t statusCode) {
   // check if we should yield the processor
   if (!isSuccess && request == nullptr) {
     context->yield();
diff --git a/extensions/http-curl/processors/InvokeHTTP.h b/extensions/http-curl/processors/InvokeHTTP.h
index 15f0511..b0bb770 100644
--- a/extensions/http-curl/processors/InvokeHTTP.h
+++ b/extensions/http-curl/processors/InvokeHTTP.h
@@ -123,7 +123,7 @@
    * @param statuscode http response code.
    */
   void route(std::shared_ptr<FlowFileRecord> &request, std::shared_ptr<FlowFileRecord> &response, const std::shared_ptr<core::ProcessSession> &session,
-             const std::shared_ptr<core::ProcessContext> &context, bool isSuccess, int statusCode);
+             const std::shared_ptr<core::ProcessContext> &context, bool isSuccess, int64_t statusCode);
   /**
    * Determine if we should emit a new flowfile based on our activity
    * @param method method type
diff --git a/extensions/http-curl/sitetosite/PeersEntity.h b/extensions/http-curl/sitetosite/PeersEntity.h
index a43df8c..b5c651b 100644
--- a/extensions/http-curl/sitetosite/PeersEntity.h
+++ b/extensions/http-curl/sitetosite/PeersEntity.h
@@ -88,7 +88,7 @@
 
           if (peer.HasMember("flowFileCount")) {
             if (peer["flowFileCount"].IsNumber()) {
-              flowFileCount = peer["flowFileCount"].GetInt64();
+              flowFileCount = gsl::narrow<int>(peer["flowFileCount"].GetInt64());
             } else {
               logger->log_debug("Could not parse flowFileCount, so we're going to continue without it");
             }
diff --git a/extensions/http-curl/tests/C2VerifyServeResults.cpp b/extensions/http-curl/tests/C2VerifyServeResults.cpp
index e814e7c..1673698 100644
--- a/extensions/http-curl/tests/C2VerifyServeResults.cpp
+++ b/extensions/http-curl/tests/C2VerifyServeResults.cpp
@@ -17,6 +17,7 @@
  */
 
 #undef NDEBUG
+#include <cstdio>
 #include <memory>
 #include <string>
 #include <sstream>
@@ -46,7 +47,7 @@
   }
 
   void cleanup() override {
-    unlink(ss.str().c_str());
+    std::remove(ss.str().c_str());
   }
 
   void runAssertions() override {
diff --git a/extensions/http-curl/tests/CivetStream.h b/extensions/http-curl/tests/CivetStream.h
index 4503ec3..d096112 100644
--- a/extensions/http-curl/tests/CivetStream.h
+++ b/extensions/http-curl/tests/CivetStream.h
@@ -51,7 +51,7 @@
    */
   void seek(uint64_t offset) override { }
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     return BaseStream::readBuffer;
   }
 
@@ -66,7 +66,7 @@
       throw minifi::Exception{ExceptionType::GENERAL_EXCEPTION, "negative buflen"};
     }
 
-    if (buf.size() < buflen) {
+    if (buf.size() < gsl::narrow<size_t>(buflen)) {
       buf.resize(buflen);
     }
     int ret = readData(buf.data(), buflen);
diff --git a/extensions/http-curl/tests/HTTPHandlers.h b/extensions/http-curl/tests/HTTPHandlers.h
index 3fd3f14..3586b9a 100644
--- a/extensions/http-curl/tests/HTTPHandlers.h
+++ b/extensions/http-curl/tests/HTTPHandlers.h
@@ -219,7 +219,7 @@
 
       auto flow = std::make_shared<FlowObj>();
 
-      for (int i = 0; i < num_attributes; i++) {
+      for (uint32_t i = 0; i < num_attributes; i++) {
         std::string name, value;
         read = stream.readUTF(name, true);
         if(!isServerRunning())return false;
@@ -235,10 +235,10 @@
       assert(read > 0); total_size += read;
 
       total_size += length;
-      flow->data.resize(length);
+      flow->data.resize(gsl::narrow<size_t>(length));
       flow->total_size = total_size;
 
-      read = stream.readData(flow->data.data(), length);
+      read = stream.readData(flow->data.data(), gsl::narrow<int>(length));
       if(!isServerRunning())return false;
       assert(read == length);
 
@@ -267,7 +267,6 @@
 
     if (flow_files_feed_->size_approx() > 0) {
       std::shared_ptr<FlowObj> flowobj;
-      uint8_t buf[1];
       std::vector<std::shared_ptr<FlowObj>> flows;
       uint64_t total = 0;
 
@@ -292,7 +291,7 @@
         }
         uint64_t length = flow->data.size();
         stream.write(length);
-        stream.writeData(flow->data.data(), length);
+        stream.writeData(flow->data.data(), gsl::narrow<int>(length));
       }
     } else {
       mg_printf(conn, "HTTP/1.1 200 OK\r\nConnection: "
diff --git a/extensions/http-curl/tests/HttpPostIntegrationTest.cpp b/extensions/http-curl/tests/HttpPostIntegrationTest.cpp
index b36f811..2ca3c2b 100644
--- a/extensions/http-curl/tests/HttpPostIntegrationTest.cpp
+++ b/extensions/http-curl/tests/HttpPostIntegrationTest.cpp
@@ -18,6 +18,7 @@
 
 #undef NDEBUG
 #include <cassert>
+#include <cstdio>
 #include <string>
 #include <iostream>
 #include "InvokeHTTP.h"
@@ -62,7 +63,7 @@
   }
 
   void cleanup() override {
-    unlink(ss.str().c_str());
+    std::remove(ss.str().c_str());
   }
 
   void runAssertions() override {
diff --git a/extensions/http-curl/tests/SiteToSiteRestTest.cpp b/extensions/http-curl/tests/SiteToSiteRestTest.cpp
index cfa09d7..cd4a124 100644
--- a/extensions/http-curl/tests/SiteToSiteRestTest.cpp
+++ b/extensions/http-curl/tests/SiteToSiteRestTest.cpp
@@ -19,6 +19,7 @@
 #define CURLOPT_SSL_VERIFYPEER_DISABLE 1
 #undef NDEBUG
 #include <cassert>
+#include <cstdio>
 #include <string>
 #include <iostream>
 #include "InvokeHTTP.h"
@@ -83,7 +84,7 @@
   }
 
   void cleanup() override {
-    unlink(ss.str().c_str());
+    std::remove(ss.str().c_str());
   }
 
   void runAssertions() override {
diff --git a/extensions/http-curl/tests/ThreadPoolAdjust.cpp b/extensions/http-curl/tests/ThreadPoolAdjust.cpp
index fffbf10..4d484f3 100644
--- a/extensions/http-curl/tests/ThreadPoolAdjust.cpp
+++ b/extensions/http-curl/tests/ThreadPoolAdjust.cpp
@@ -18,6 +18,7 @@
 
 #undef NDEBUG
 #include <cassert>
+#include <cstdio>
 #include <string>
 #include <iostream>
 #include "InvokeHTTP.h"
@@ -61,7 +62,7 @@
   }
 
   void cleanup() override {
-    unlink(ss.str().c_str());
+    std::remove(ss.str().c_str());
   }
 
   void runAssertions() override {
diff --git a/extensions/libarchive/ArchiveMetadata.cpp b/extensions/libarchive/ArchiveMetadata.cpp
index 7503ab6..eea31a8 100644
--- a/extensions/libarchive/ArchiveMetadata.cpp
+++ b/extensions/libarchive/ArchiveMetadata.cpp
@@ -60,10 +60,10 @@
 
 void ArchiveEntryMetadata::loadJson(const rapidjson::Value& entryVal) {
     entryName.assign(entryVal["entry_name"].GetString());
-    entryType = entryVal["entry_type"].GetUint64();
-    entryPerm = entryVal["entry_perm"].GetUint64();
+    entryType = gsl::narrow<mode_t>(entryVal["entry_type"].GetUint64());
+    entryPerm = gsl::narrow<mode_t>(entryVal["entry_perm"].GetUint64());
     entrySize = entryVal["entry_size"].GetUint64();
-    entryUID = entryVal["entry_uid"].GetUint64();
+    entryUID = gsl::narrow<uid_t>(entryVal["entry_uid"].GetUint64());
     entryGID = entryVal["entry_gid"].GetUint64();
     entryMTime = entryVal["entry_mtime"].GetUint64();
     entryMTimeNsec = entryVal["entry_mtime_nsec"].GetInt64();
@@ -138,7 +138,7 @@
         archiveName.assign(itr->value.GetString());
 
     archiveFormatName.assign(metadataDoc["archive_format_name"].GetString());
-    archiveFormat = metadataDoc["archive_format"].GetUint64();
+    archiveFormat = gsl::narrow<int>(metadataDoc["archive_format"].GetUint64());
 
     focusedEntry = metadataDoc["focused_entry"].GetString();
   
diff --git a/extensions/libarchive/BinFiles.cpp b/extensions/libarchive/BinFiles.cpp
index a7881ba..4de844c 100644
--- a/extensions/libarchive/BinFiles.cpp
+++ b/extensions/libarchive/BinFiles.cpp
@@ -75,15 +75,16 @@
 
 void BinFiles::onSchedule(core::ProcessContext *context, core::ProcessSessionFactory *sessionFactory) {
   std::string value;
-  int64_t valInt;
-  if (context->getProperty(MinSize.getName(), value) && !value.empty() && core::Property::StringToInt(value, valInt)) {
-    this->binManager_.setMinSize(valInt);
-    logger_->log_debug("BinFiles: MinSize [%d]", valInt);
+  int64_t valInt64;
+  int valInt;
+  if (context->getProperty(MinSize.getName(), value) && !value.empty() && core::Property::StringToInt(value, valInt64)) {
+    this->binManager_.setMinSize(valInt64);
+    logger_->log_debug("BinFiles: MinSize [%" PRId64 "]", valInt64);
   }
   value = "";
-  if (context->getProperty(MaxSize.getName(), value) && !value.empty() && core::Property::StringToInt(value, valInt)) {
-    this->binManager_.setMaxSize(valInt);
-    logger_->log_debug("BinFiles: MaxSize [%d]", valInt);
+  if (context->getProperty(MaxSize.getName(), value) && !value.empty() && core::Property::StringToInt(value, valInt64)) {
+    this->binManager_.setMaxSize(valInt64);
+    logger_->log_debug("BinFiles: MaxSize [%" PRId64 "]", valInt64);
   }
   value = "";
   if (context->getProperty(MinEntries.getName(), value) && !value.empty() && core::Property::StringToInt(value, valInt)) {
@@ -97,15 +98,15 @@
   }
   value = "";
   if (context->getProperty(MaxBinCount.getName(), value) && !value.empty() && core::Property::StringToInt(value, valInt)) {
-    maxBinCount_ = static_cast<int> (valInt);
+    maxBinCount_ = valInt;
     logger_->log_debug("BinFiles: MaxBinCount [%d]", valInt);
   }
   value = "";
   if (context->getProperty(MaxBinAge.getName(), value) && !value.empty()) {
     core::TimeUnit unit;
-    if (core::Property::StringToTime(value, valInt, unit) && core::Property::ConvertTimeUnitToMS(valInt, unit, valInt)) {
-      this->binManager_.setBinAge(valInt);
-      logger_->log_debug("BinFiles: MaxBinAge [%d]", valInt);
+    if (core::Property::StringToTime(value, valInt64, unit) && core::Property::ConvertTimeUnitToMS(valInt64, unit, valInt64)) {
+      this->binManager_.setBinAge(valInt64);
+      logger_->log_debug("BinFiles: MaxBinAge [%" PRId64 "]", valInt64);
     }
   }
 }
diff --git a/extensions/libarchive/BinFiles.h b/extensions/libarchive/BinFiles.h
index f8b89ea..c52bc34 100644
--- a/extensions/libarchive/BinFiles.h
+++ b/extensions/libarchive/BinFiles.h
@@ -20,6 +20,7 @@
 #ifndef __BIN_FILES_H__
 #define __BIN_FILES_H__
 
+#include <cinttypes>
 #include <climits>
 #include <deque>
 #include <map>
@@ -44,7 +45,7 @@
   /*!
    * Create a new Bin. Note: this object is not thread safe
    */
-  explicit Bin(const uint64_t &minSize, const uint64_t &maxSize, const int &minEntries, const int & maxEntries, const std::string &fileCount, const std::string &groupId)
+  explicit Bin(const uint64_t &minSize, const uint64_t &maxSize, const size_t &minEntries, const size_t & maxEntries, const std::string &fileCount, const std::string &groupId)
       : minSize_(minSize),
         maxSize_(maxSize),
         maxEntries_(maxEntries),
@@ -91,7 +92,7 @@
       if (flow->getAttribute(fileCount_, value)) {
         try {
           // for defrag case using the identification
-          int count = std::stoi(value);
+          size_t count = std::stoul(value);
           maxEntries_ = count;
           minEntries_ = count;
         } catch (...) {
@@ -105,7 +106,7 @@
 
     queue_.push_back(flow);
     queued_data_size_ += flow->getSize();
-    logger_->log_debug("Bin %s for group %s offer size %d byte %d min_entry %d max_entry %d", uuid_str_, groupId_, queue_.size(), queued_data_size_, minEntries_, maxEntries_);
+    logger_->log_debug("Bin %s for group %s offer size %zu byte %" PRIu64 " min_entry %zu max_entry %zu", uuid_str_, groupId_, queue_.size(), queued_data_size_, minEntries_, maxEntries_);
 
     return true;
   }
@@ -129,8 +130,8 @@
  private:
   uint64_t minSize_;
   uint64_t maxSize_;
-  int maxEntries_;
-  int minEntries_;
+  size_t maxEntries_;
+  size_t minEntries_;
   // Queued data size
   uint64_t queued_data_size_;
   // Queue for the Flow File
diff --git a/extensions/libarchive/CompressContent.h b/extensions/libarchive/CompressContent.h
index b635357..1a92dc8 100644
--- a/extensions/libarchive/CompressContent.h
+++ b/extensions/libarchive/CompressContent.h
@@ -20,6 +20,8 @@
 #ifndef __COMPRESS_CONTENT_H__
 #define __COMPRESS_CONTENT_H__
 
+#include <cinttypes>
+
 #include "archive_entry.h"
 #include "archive.h"
 
@@ -101,7 +103,7 @@
           return -1;
         }
         if (ret > 0) {
-          ret = archive_write_data(arch_, buffer, ret);
+          ret = archive_write_data(arch_, buffer, gsl::narrow<size_t>(ret));
           if (ret < 0) {
             logger_->log_error("Compress Content archive error %s", archive_error_string(arch_));
             status_ = -1;
@@ -147,7 +149,7 @@
   // Nest Callback Class for write stream
   class WriteCallback: public OutputStreamCallback {
   public:
-    WriteCallback(std::string &compress_mode, int64_t compress_level, std::string &compress_format,
+    WriteCallback(std::string &compress_mode, int compress_level, std::string &compress_format,
         std::shared_ptr<core::FlowFile> &flow, const std::shared_ptr<core::ProcessSession> &session) :
         compress_mode_(compress_mode), compress_level_(compress_level), compress_format_(compress_format),
         flow_(flow), session_(session),
@@ -160,7 +162,7 @@
     ~WriteCallback() = default;
 
     std::string compress_mode_;
-    int64_t compress_level_;
+    int compress_level_;
     std::string compress_format_;
     std::shared_ptr<core::FlowFile> flow_;
     std::shared_ptr<core::ProcessSession> session_;
@@ -183,7 +185,7 @@
       callback->session_->read(callback->flow_, &callback->readDecompressCb_);
       if (callback->readDecompressCb_.read_size_ >= 0) {
         *buff = callback->readDecompressCb_.buffer_;
-        return callback->readDecompressCb_.read_size_;
+        return gsl::narrow<la_ssize_t>(callback->readDecompressCb_.read_size_);
       } else {
         archive_set_error(arch, EIO, "Error reading flowfile");
         return -1;
@@ -228,7 +230,7 @@
             return -1;
           }
           std::string option;
-          option = "gzip:compression-level=" + std::to_string((int) compress_level_);
+          option = "gzip:compression-level=" + std::to_string(compress_level_);
           r = archive_write_set_options(arch, option.c_str());
           if (r != ARCHIVE_OK) {
             archive_write_log_error_cleanup(arch);
@@ -316,8 +318,8 @@
           archive_read_log_error_cleanup(arch);
           return -1;
         }
-        int entry_size = archive_entry_size(entry);
-        logger_->log_debug("Decompress Content archive entry size %d", entry_size);
+        int64_t entry_size = archive_entry_size(entry);
+        logger_->log_debug("Decompress Content archive entry size %" PRId64, entry_size);
         size_ = 0;
         while (size_ < entry_size) {
           char buffer[8192];
@@ -344,7 +346,7 @@
 
   class GzipWriteCallback : public OutputStreamCallback {
    public:
-    GzipWriteCallback(std::string compress_mode, int64_t compress_level, std::shared_ptr<core::FlowFile> flow, std::shared_ptr<core::ProcessSession> session)
+    GzipWriteCallback(std::string compress_mode, int compress_level, std::shared_ptr<core::FlowFile> flow, std::shared_ptr<core::ProcessSession> session)
       : logger_(logging::LoggerFactory<CompressContent>::getLogger())
       , compress_mode_(std::move(compress_mode))
       , compress_level_(compress_level)
@@ -355,7 +357,7 @@
 
     std::shared_ptr<logging::Logger> logger_;
     std::string compress_mode_;
-    int64_t compress_level_;
+    int compress_level_;
     std::shared_ptr<core::FlowFile> flow_;
     std::shared_ptr<core::ProcessSession> session_;
     bool success_{false};
@@ -371,7 +373,7 @@
         int64_t process(std::shared_ptr<io::BaseStream> inputStream) override {
           std::vector<uint8_t> buffer(16 * 1024U);
           int64_t read_size = 0;
-          while (read_size < writer_.flow_->getSize()) {
+          while (read_size < gsl::narrow<int64_t>(writer_.flow_->getSize())) {
             int ret = inputStream->read(buffer.data(), buffer.size());
             if (ret < 0) {
               return -1;
@@ -427,7 +429,7 @@
 
 private:
   std::shared_ptr<logging::Logger> logger_;
-  int64_t compressLevel_;
+  int compressLevel_;
   std::string compressMode_;
   std::string compressFormat_;
   bool updateFileName_;
diff --git a/extensions/libarchive/FocusArchiveEntry.cpp b/extensions/libarchive/FocusArchiveEntry.cpp
index 0795b4c..1465ba1 100644
--- a/extensions/libarchive/FocusArchiveEntry.cpp
+++ b/extensions/libarchive/FocusArchiveEntry.cpp
@@ -162,8 +162,8 @@
 la_ssize_t FocusArchiveEntry::ReadCallback::read_cb(struct archive * a, void *d, const void **buf) {
   auto data = static_cast<FocusArchiveEntryReadData *>(d);
   *buf = data->buf;
-  int64_t read = 0;
-  int64_t last_read = 0;
+  int read = 0;
+  int last_read = 0;
 
   do {
     last_read = data->stream->readData(reinterpret_cast<uint8_t *>(data->buf), 8196 - read);
@@ -245,7 +245,11 @@
       auto fd = fopen(tmpFileName.c_str(), "w");
 
       if (archive_entry_size(entry) > 0) {
+#ifdef WIN32
+        nlen += archive_read_data_into_fd(inputArchive, _fileno(fd));
+#else
         nlen += archive_read_data_into_fd(inputArchive, fileno(fd));
+#endif
       }
 
       fclose(fd);
diff --git a/extensions/libarchive/MergeContent.cpp b/extensions/libarchive/MergeContent.cpp
index 137a872..dc07915 100644
--- a/extensions/libarchive/MergeContent.cpp
+++ b/extensions/libarchive/MergeContent.cpp
@@ -98,7 +98,7 @@
   std::ifstream in(path.c_str(), std::ios::in | std::ios::binary);
   if (in) {
     in.seekg(0, std::ios::end);
-    contents.resize(in.tellg());
+    contents.resize(gsl::narrow<size_t>(in.tellg()));
     in.seekg(0, std::ios::beg);
     in.read(&contents[0], contents.size());
     in.close();
diff --git a/extensions/libarchive/UnfocusArchiveEntry.cpp b/extensions/libarchive/UnfocusArchiveEntry.cpp
index 8468efd..b3273a8 100644
--- a/extensions/libarchive/UnfocusArchiveEntry.cpp
+++ b/extensions/libarchive/UnfocusArchiveEntry.cpp
@@ -202,7 +202,7 @@
     archive_entry_set_size(entry, entryMetadata.entrySize);
     archive_entry_set_uid(entry, entryMetadata.entryUID);
     archive_entry_set_gid(entry, entryMetadata.entryGID);
-    archive_entry_set_mtime(entry, entryMetadata.entryMTime, entryMetadata.entryMTimeNsec);
+    archive_entry_set_mtime(entry, entryMetadata.entryMTime, gsl::narrow<long>(entryMetadata.entryMTimeNsec));
 
     logger_->log_info("Writing %s with type %d, perms %d, size %d, uid %d, gid %d, mtime %d,%d", entryMetadata.entryName, entryMetadata.entryType, entryMetadata.entryPerm,
                       entryMetadata.entrySize, entryMetadata.entryUID, entryMetadata.entryGID, entryMetadata.entryMTime, entryMetadata.entryMTimeNsec);
@@ -218,7 +218,7 @@
 
       while (ifs.good()) {
         ifs.read(buf, sizeof(buf));
-        auto len = ifs.gcount();
+        size_t len = gsl::narrow<size_t>(ifs.gcount());
         int64_t written = archive_write_data(outputArchive, buf, len);
         if (written < 0) {
           logger_->log_error("UnfocusArchiveEntry failed to write data to "
diff --git a/extensions/rocksdb-repos/ProvenanceRepository.h b/extensions/rocksdb-repos/ProvenanceRepository.h
index 39a9e85..87728ef 100644
--- a/extensions/rocksdb-repos/ProvenanceRepository.h
+++ b/extensions/rocksdb-repos/ProvenanceRepository.h
@@ -92,7 +92,7 @@
     // Rocksdb write buffers act as a log of database operation: grow till reaching the limit, serialized after
     // This shouldn't go above 16MB and the configured total size of the db should cap it as well
     int64_t max_buffer_size = 16 << 20;
-    options.write_buffer_size = std::min(max_buffer_size, max_partition_bytes_);
+    options.write_buffer_size = gsl::narrow<size_t>(std::min(max_buffer_size, max_partition_bytes_));
     options.max_write_buffer_number = 4;
     options.min_write_buffer_number_to_merge = 1;
 
diff --git a/extensions/rocksdb-repos/RocksDbStream.cpp b/extensions/rocksdb-repos/RocksDbStream.cpp
index 7bcc2e1..a6526ec 100644
--- a/extensions/rocksdb-repos/RocksDbStream.cpp
+++ b/extensions/rocksdb-repos/RocksDbStream.cpp
@@ -90,7 +90,7 @@
     throw minifi::Exception{ExceptionType::GENERAL_EXCEPTION, "negative buflen"};
   }
 
-  if (buf.size() < buflen) {
+  if (buf.size() < gsl::narrow<size_t>(buflen)) {
     buf.resize(buflen);
   }
   int ret = readData(buf.data(), buflen);
@@ -103,16 +103,16 @@
 
 int RocksDbStream::readData(uint8_t *buf, int buflen) {
   if (!IsNullOrEmpty(buf) && exists_) {
-    int amtToRead = buflen;
+    size_t amtToRead = gsl::narrow<size_t>(buflen);
     if (offset_ >= value_.size()) {
       return 0;
     }
-    if (buflen > value_.size() - offset_) {
+    if (amtToRead > value_.size() - offset_) {
       amtToRead = value_.size() - offset_;
     }
     std::memcpy(buf, value_.data() + offset_, amtToRead);
     offset_ += amtToRead;
-    return amtToRead;
+    return gsl::narrow<int>(amtToRead);
   } else {
     return -1;
   }
diff --git a/extensions/rocksdb-repos/RocksDbStream.h b/extensions/rocksdb-repos/RocksDbStream.h
index 6bec50f..57f5c4e 100644
--- a/extensions/rocksdb-repos/RocksDbStream.h
+++ b/extensions/rocksdb-repos/RocksDbStream.h
@@ -59,7 +59,7 @@
    */
   void seek(uint64_t offset) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     return size_;
   }
 
@@ -156,7 +156,7 @@
 
   bool exists_;
 
-  int64_t offset_;
+  size_t offset_;
 
   std::string value_;
 
diff --git a/extensions/standard-processors/processors/ExtractText.cpp b/extensions/standard-processors/processors/ExtractText.cpp
index 42c5cc8..f386a11 100644
--- a/extensions/standard-processors/processors/ExtractText.cpp
+++ b/extensions/standard-processors/processors/ExtractText.cpp
@@ -41,8 +41,8 @@
 namespace minifi {
 namespace processors {
 
-#define MAX_BUFFER_SIZE 4096
-#define MAX_CAPTURE_GROUP_SIZE 1024
+constexpr size_t MAX_BUFFER_SIZE = 4096;
+constexpr int MAX_CAPTURE_GROUP_SIZE = 1024;
 
 core::Property ExtractText::Attribute(core::PropertyBuilder::createProperty("Attribute")->withDescription("Attribute to set from content")->build());
 
@@ -132,7 +132,8 @@
 
   while (read_size < size_limit) {
     // Don't read more than config limit or the size of the buffer
-    ret = stream->readData(buffer_, std::min<uint64_t>(size_limit - read_size, buffer_.size()));
+    int length = gsl::narrow<int>(std::min<uint64_t>(size_limit - read_size, buffer_.size()));
+    ret = stream->readData(buffer_, length);
 
     if (ret < 0) {
       return -1;  // Stream error
@@ -161,8 +162,9 @@
     bool repeatingcapture;
     ctx_->getProperty(EnableRepeatingCaptureGroup.getName(), repeatingcapture);
 
-    int maxCaptureSize;
-    ctx_->getProperty(MaxCaptureGroupLen.getName(), maxCaptureSize);
+    int maxCaptureSizeProperty;
+    ctx_->getProperty(MaxCaptureGroupLen.getName(), maxCaptureSizeProperty);
+    size_t maxCaptureSize = gsl::narrow<size_t>(maxCaptureSizeProperty);
 
     std::string contentStr = contentStream.str();
 
@@ -217,7 +219,7 @@
     : flowFile_(std::move(flowFile)),
       ctx_(ctx),
       logger_(std::move(lgr)) {
-  buffer_.resize(std::min<uint64_t>(flowFile_->getSize(), MAX_BUFFER_SIZE));
+  buffer_.resize(std::min(gsl::narrow<size_t>(flowFile_->getSize()), MAX_BUFFER_SIZE));
 }
 
 }  // namespace processors
diff --git a/extensions/standard-processors/processors/GenerateFlowFile.cpp b/extensions/standard-processors/processors/GenerateFlowFile.cpp
index 6b4652a..d639533 100644
--- a/extensions/standard-processors/processors/GenerateFlowFile.cpp
+++ b/extensions/standard-processors/processors/GenerateFlowFile.cpp
@@ -111,7 +111,7 @@
   }
 
   if (!uniqueFlowFile_) {
-    data_.resize(fileSize_);
+    data_.resize(gsl::narrow<size_t>(fileSize_));
     generateData(data_, textData_);
   }
 }
@@ -126,7 +126,7 @@
     }
     if (fileSize_ > 0) {
       if (uniqueFlowFile_) {
-        std::vector<char> data(fileSize_);
+        std::vector<char> data(gsl::narrow<size_t>(fileSize_));
         generateData(data, textData_);
         GenerateFlowFile::WriteCallback callback(std::move(data));
         session->write(flowFile, &callback);
diff --git a/extensions/standard-processors/processors/GetFile.cpp b/extensions/standard-processors/processors/GetFile.cpp
index 6b2a707..eee4eb0 100644
--- a/extensions/standard-processors/processors/GetFile.cpp
+++ b/extensions/standard-processors/processors/GetFile.cpp
@@ -247,10 +247,10 @@
     if (request.ignoreHiddenFile && utils::file::FileUtils::is_hidden(fullName))
       return false;
 
-    if (access(fullName.c_str(), R_OK) != 0)
+    if (utils::file::FileUtils::access(fullName.c_str(), R_OK) != 0)
       return false;
 
-    if (request.keepSourceFile == false && access(fullName.c_str(), W_OK) != 0)
+    if (request.keepSourceFile == false && utils::file::FileUtils::access(fullName.c_str(), W_OK) != 0)
       return false;
 
     utils::Regex rgx(request.fileFilter);
diff --git a/extensions/standard-processors/processors/GetTCP.cpp b/extensions/standard-processors/processors/GetTCP.cpp
index 5a8ab19..44d89e7 100644
--- a/extensions/standard-processors/processors/GetTCP.cpp
+++ b/extensions/standard-processors/processors/GetTCP.cpp
@@ -166,7 +166,7 @@
       int reconnects = 0;
       do {
         if ( socket_ring_buffer_.try_dequeue(socket_ptr) ) {
-          int size_read = socket_ptr->readData(buffer, receive_buffer_size_, false);
+          int size_read = socket_ptr->readData(buffer, gsl::narrow<int>(receive_buffer_size_), false);
           if (size_read >= 0) {
             if (size_read > 0) {
               // determine cut location
diff --git a/extensions/standard-processors/processors/LogAttribute.cpp b/extensions/standard-processors/processors/LogAttribute.cpp
index 0021877..ec6539d 100644
--- a/extensions/standard-processors/processors/LogAttribute.cpp
+++ b/extensions/standard-processors/processors/LogAttribute.cpp
@@ -143,7 +143,7 @@
     }
     if (logPayload && flow->getSize() <= 1024 * 1024) {
       message << "\n" << "Payload:" << "\n";
-      ReadCallback callback(logger_, flow->getSize());
+      ReadCallback callback(logger_, gsl::narrow<size_t>(flow->getSize()));
       session->read(flow, &callback);
 
       std::string printable_payload;
diff --git a/extensions/standard-processors/processors/LogAttribute.h b/extensions/standard-processors/processors/LogAttribute.h
index 076ef90..190d3d1 100644
--- a/extensions/standard-processors/processors/LogAttribute.h
+++ b/extensions/standard-processors/processors/LogAttribute.h
@@ -98,7 +98,7 @@
   // Nest Callback Class for read stream
   class ReadCallback : public InputStreamCallback {
    public:
-    ReadCallback(std::shared_ptr<logging::Logger> logger, uint64_t size)
+    ReadCallback(std::shared_ptr<logging::Logger> logger, size_t size)
         : logger_(std::move(logger))
         , buffer_(size)  {
     }
diff --git a/extensions/standard-processors/processors/PutFile.cpp b/extensions/standard-processors/processors/PutFile.cpp
index 43ace43..1d7de94 100644
--- a/extensions/standard-processors/processors/PutFile.cpp
+++ b/extensions/standard-processors/processors/PutFile.cpp
@@ -30,9 +30,6 @@
 #include <Windows.h>
 #endif
 #include "utils/file/FileUtils.h"
-#ifndef S_ISDIR
-#define S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)
-#endif
 
 namespace org {
 namespace apache {
@@ -133,26 +130,22 @@
   // If file exists, apply conflict resolution strategy
   struct stat statResult;
 
-  if ((max_dest_files_ != -1) && (stat(directory.c_str(), &statResult) == 0)) {
-    // something exists at directory path
-    if (S_ISDIR(statResult.st_mode)) {
-      // it's a directory, count the files
-      int64_t ct = 0;
+  if ((max_dest_files_ != -1) && utils::file::FileUtils::is_directory(directory.c_str())) {
+    int64_t count = 0;
 
-      // Callback, called for each file entry in the listed directory
-      // Return value is used to break (false) or continue (true) listing
-      auto lambda = [&ct, this](const std::string&, const std::string&) -> bool {
-        return ++ct < max_dest_files_;
-      };
+    // Callback, called for each file entry in the listed directory
+    // Return value is used to break (false) or continue (true) listing
+    auto lambda = [&count, this](const std::string&, const std::string&) -> bool {
+      return ++count < max_dest_files_;
+    };
 
-      utils::file::FileUtils::list_dir(directory, lambda, logger_, false);
+    utils::file::FileUtils::list_dir(directory, lambda, logger_, false);
 
-      if (ct >= max_dest_files_) {
-        logger_->log_warn("Routing to failure because the output directory %s has at least %u files, which exceeds the "
-                          "configured max number of files", directory, max_dest_files_);
-        session->transfer(flowFile, Failure);
-        return;
-      }
+    if (count >= max_dest_files_) {
+      logger_->log_warn("Routing to failure because the output directory %s has at least %u files, which exceeds the "
+                        "configured max number of files", directory, max_dest_files_);
+      session->transfer(flowFile, Failure);
+      return;
     }
   }
 
@@ -306,7 +299,7 @@
 // Clean up resources
 PutFile::ReadCallback::~ReadCallback() {
   // Clean up tmp file, if necessary
-  unlink(tmp_file_.c_str());
+  std::remove(tmp_file_.c_str());
 }
 
 } /* namespace processors */
diff --git a/extensions/standard-processors/tests/integration/TailFileTest.cpp b/extensions/standard-processors/tests/integration/TailFileTest.cpp
index 9229677..fc1e931 100644
--- a/extensions/standard-processors/tests/integration/TailFileTest.cpp
+++ b/extensions/standard-processors/tests/integration/TailFileTest.cpp
@@ -17,10 +17,10 @@
  */
 
 #include <sys/stat.h>
-#include <chrono>
-#include <thread>
+
 #undef NDEBUG
 #include <cassert>
+#include <cstdio>
 #include <utility>
 #include <fstream>
 #include <memory>
@@ -29,6 +29,7 @@
 #include <vector>
 #include <iostream>
 #include <sstream>
+
 #include "utils/StringUtils.h"
 #include "core/Core.h"
 #include "core/logging/Logger.h"
@@ -65,8 +66,8 @@
   }
 
   void cleanup() override {
-    unlink(ss.str().c_str());
-    unlink(statefile.c_str());
+    std::remove(ss.str().c_str());
+    std::remove(statefile.c_str());
   }
 
   void runAssertions() override {
diff --git a/extensions/standard-processors/tests/unit/ControllerServiceTests.cpp b/extensions/standard-processors/tests/unit/ControllerServiceTests.cpp
index 2b468cb..0610431 100644
--- a/extensions/standard-processors/tests/unit/ControllerServiceTests.cpp
+++ b/extensions/standard-processors/tests/unit/ControllerServiceTests.cpp
@@ -59,7 +59,7 @@
 
   try {
     std::shared_ptr<core::controller::StandardControllerServiceNode> testNode = std::make_shared<core::controller::StandardControllerServiceNode>(nullptr, "ID", std::make_shared<minifi::Configure>());
-  } catch (minifi::Exception &ex) {
+  } catch (const minifi::Exception &) {
     return;
   }
 
diff --git a/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp b/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp
index 5245a29..8335909 100644
--- a/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp
@@ -57,7 +57,7 @@
     std::ifstream is(path + utils::file::FileUtils::get_separator() + filename, std::ifstream::binary);
 
     is.seekg(0, is.end);
-    size_t length = is.tellg();
+    size_t length = gsl::narrow<size_t>(is.tellg());
     is.seekg(0, is.beg);
 
     std::vector<char> content(length);
diff --git a/extensions/standard-processors/tests/unit/ProcessorTests.cpp b/extensions/standard-processors/tests/unit/ProcessorTests.cpp
index f7dc551..e56e301 100644
--- a/extensions/standard-processors/tests/unit/ProcessorTests.cpp
+++ b/extensions/standard-processors/tests/unit/ProcessorTests.cpp
@@ -15,6 +15,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <cstdio>
 #include <utility>
 #include <memory>
 #include <string>
@@ -113,7 +114,7 @@
     processor->incrementActiveTasks();
     processor->setScheduledState(core::ScheduledState::RUNNING);
     processor->onTrigger(context, session);
-    unlink(ss.str().c_str());
+    std::remove(ss.str().c_str());
     reporter = session->getProvenanceReporter();
 
     REQUIRE(processor->getName() == "getfileCreate2");
@@ -209,11 +210,7 @@
   processor->incrementActiveTasks();
   processor->setScheduledState(core::ScheduledState::RUNNING);
   processor->onTrigger(context, session);
-#ifndef WIN32
-  unlink(hidden_file_name.c_str());
-#else
-  _unlink(hidden_file_name.c_str());
-#endif /* !WIN32 */
+  std::remove(hidden_file_name.c_str());
   reporter = session->getProvenanceReporter();
 
   REQUIRE(processor->getName() == "getfileCreate2");
@@ -312,7 +309,7 @@
   plan->reset();
   testController.runSession(plan, false);
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 
   records = plan->getProvenanceRecords();
   record = plan->getCurrentFlowFile();
@@ -388,7 +385,7 @@
   testController.runSession(plan, false);
 
   for (const auto &created_file : files) {
-    unlink(created_file.c_str());
+    std::remove(created_file.c_str());
   }
 
   records = plan->getProvenanceRecords();
@@ -614,13 +611,3 @@
 TEST_CASE("TestRPGValid", "[TestRPG6]") {
   testRPGBypass("", "8080", "8080", false);
 }
-
-int fileSize(const char *add) {
-  std::ifstream mySource;
-  mySource.open(add, std::ios_base::binary);
-  mySource.seekg(0, std::ios_base::end);
-  int size = mySource.tellg();
-  mySource.close();
-  return size;
-}
-
diff --git a/extensions/standard-processors/tests/unit/PutFileTests.cpp b/extensions/standard-processors/tests/unit/PutFileTests.cpp
index 680a494..fdf5a30 100644
--- a/extensions/standard-processors/tests/unit/PutFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/PutFileTests.cpp
@@ -15,7 +15,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include <sys/stat.h>
+
+#include <cstdio>
 #include <utility>
 #include <memory>
 #include <string>
@@ -23,7 +26,6 @@
 #include <set>
 #include <fstream>
 
-
 #include "utils/file/FileUtils.h"
 #include "TestBase.h"
 #include "processors/LogAttribute.h"
@@ -91,7 +93,7 @@
   record = plan->getCurrentFlowFile();
   testController.runSession(plan, false);
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 
   REQUIRE(true == LogTestController::getInstance().contains("key:absolute.path value:" + ss.str()));
   REQUIRE(true == LogTestController::getInstance().contains("Size:8 Offset:0"));
@@ -163,7 +165,7 @@
   record = plan->getCurrentFlowFile();
   testController.runSession(plan, false);
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 
   REQUIRE(true == LogTestController::getInstance().contains("key:absolute.path value:" + ss.str()));
   REQUIRE(true == LogTestController::getInstance().contains("Size:8 Offset:0"));
@@ -231,7 +233,7 @@
   record = plan->getCurrentFlowFile();
   testController.runSession(plan, false);
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 
   REQUIRE(true == LogTestController::getInstance().contains("key:absolute.path value:" + ss.str()));
   REQUIRE(true == LogTestController::getInstance().contains("Size:8 Offset:0"));
@@ -299,7 +301,7 @@
   record = plan->getCurrentFlowFile();
   testController.runSession(plan, false);
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 
   REQUIRE(true == LogTestController::getInstance().contains("key:absolute.path value:" + ss.str()));
   REQUIRE(true == LogTestController::getInstance().contains("Size:8 Offset:0"));
diff --git a/extensions/windows-event-log/ConsumeWindowsEventLog.cpp b/extensions/windows-event-log/ConsumeWindowsEventLog.cpp
index 103a7b9..70f4d08 100644
--- a/extensions/windows-event-log/ConsumeWindowsEventLog.cpp
+++ b/extensions/windows-event-log/ConsumeWindowsEventLog.cpp
@@ -461,7 +461,7 @@
         try {
           // Assumption - first character is not '0', otherwise not all digits will be replaced by 'value'.
           number = std::stoul(&nodeText[numberPos]);
-        } catch (std::invalid_argument& e) {
+        } catch (const std::invalid_argument &) {
           continue;
         }
 
@@ -593,7 +593,7 @@
   if (writeXML_) {
     logger_->log_trace("Writing event in XML");
     substituteXMLPercentageItems(doc);
-    logger_->log_trace("Finish substituting \%\% in XML");
+    logger_->log_trace("Finish substituting %% in XML");
 
     if (resolve_as_attributes_) {
       eventRender.matched_fields_ = walker.getFieldValues();
diff --git a/extensions/windows-event-log/wel/WindowsEventLog.cpp b/extensions/windows-event-log/wel/WindowsEventLog.cpp
index 31c1fef..0e48503 100644
--- a/extensions/windows-event-log/wel/WindowsEventLog.cpp
+++ b/extensions/windows-event-log/wel/WindowsEventLog.cpp
@@ -130,7 +130,7 @@
 
   std::string event_data;
 
-  if (metadata_ptr_ == NULL | event_ptr_ == NULL) {
+  if (metadata_ptr_ == NULL || event_ptr_ == NULL) {
     return event_data;
   }
 
diff --git a/libminifi/include/FlowControlProtocol.h b/libminifi/include/FlowControlProtocol.h
index 4a60eca..ac3b060 100644
--- a/libminifi/include/FlowControlProtocol.h
+++ b/libminifi/include/FlowControlProtocol.h
@@ -35,6 +35,7 @@
 #include "core/logging/LoggerConfiguration.h"
 #include "core/Property.h"
 #include "properties/Configure.h"
+#include "utils/file/FileUtils.h"
 
 namespace org {
 namespace apache {
@@ -186,7 +187,7 @@
   // Destructor
   virtual ~FlowControlProtocol() {
     stop();
-    if (_socket) close(_socket);
+    if (_socket) utils::file::FileUtils::close(_socket);
   }
 
  public:
diff --git a/libminifi/include/FlowFileRecord.h b/libminifi/include/FlowFileRecord.h
index 1fa4c5d..7557056 100644
--- a/libminifi/include/FlowFileRecord.h
+++ b/libminifi/include/FlowFileRecord.h
@@ -135,7 +135,7 @@
   bool DeSerialize(const uint8_t *buffer, const int bufferSize);
   //! DeSerialize
   bool DeSerialize(io::DataStream &stream) {
-    return DeSerialize(stream.getBuffer(), stream.getSize());
+    return DeSerialize(stream.getBuffer(), gsl::narrow<int>(stream.getSize()));
   }
   //! DeSerialize
   bool DeSerialize(std::string key);
diff --git a/libminifi/include/c2/C2Agent.h b/libminifi/include/c2/C2Agent.h
index 5943941..273fd43 100644
--- a/libminifi/include/c2/C2Agent.h
+++ b/libminifi/include/c2/C2Agent.h
@@ -190,7 +190,7 @@
   int64_t heart_beat_period_;
 
   // maximum number of queued messages to send to the c2 server
-  int16_t max_c2_responses;
+  size_t max_c2_responses;
 
   // time point the last time we performed a heartbeat.
   std::chrono::steady_clock::time_point last_run_;
diff --git a/libminifi/include/core/ClassLoader.h b/libminifi/include/core/ClassLoader.h
index d8dcece..6e7b332 100644
--- a/libminifi/include/core/ClassLoader.h
+++ b/libminifi/include/core/ClassLoader.h
@@ -436,7 +436,6 @@
 
   void *dlsym(void *handle, const char *name) {
     FARPROC symbol;
-    HMODULE hModule;
 
     symbol = GetProcAddress((HMODULE)handle, name);
 
@@ -470,7 +469,6 @@
   void *dlopen(const char *file, int mode) {
     std::lock_guard<std::mutex> lock(internal_mutex_);
     HMODULE object;
-    char * current_error = NULL;
     uint32_t uMode = SetErrorMode(SEM_FAILCRITICALERRORS);
     if (nullptr == file) {
       HMODULE allModules[1024];
@@ -483,8 +481,6 @@
       if (EnumProcessModules(current_process_id, allModules,
               sizeof(allModules), &cbNeeded) != 0) {
         for (uint32_t i = 0; i < cbNeeded / sizeof(HMODULE); i++) {
-          TCHAR szModName[MAX_PATH];
-
           // Get the full path to the module's file.
           resource_mapping_.insert(std::make_pair(allModules[i], "minifi-system"));
         }
diff --git a/libminifi/include/core/TypedValues.h b/libminifi/include/core/TypedValues.h
index 29c585f..f735d37 100644
--- a/libminifi/include/core/TypedValues.h
+++ b/libminifi/include/core/TypedValues.h
@@ -141,7 +141,7 @@
     auto ival = std::strtoll(cvalue, &pEnd, 0);
 
     if (pEnd[0] == '\0') {
-      output = ival;
+      output = gsl::narrow<T>(ival);
       return true;
     }
 
@@ -152,7 +152,7 @@
 
     char end0 = toupper(pEnd[0]);
     if (end0 == 'B') {
-      output = ival;
+      output = gsl::narrow<T>(ival);
       return true;
     } else if ((end0 == 'K') || (end0 == 'M') || (end0 == 'G') || (end0 == 'T') || (end0 == 'P')) {
       if (pEnd[1] == '\0') {
@@ -170,7 +170,7 @@
             }
           }
         }
-        output = ival * multiplier;
+        output = gsl::narrow<T>(ival * multiplier);
         return true;
 
       } else if ((pEnd[1] == 'b' || pEnd[1] == 'B') && (pEnd[2] == '\0')) {
@@ -188,7 +188,7 @@
             }
           }
         }
-        output = ival * multiplier;
+        output = gsl::narrow<T>(ival * multiplier);
         return true;
       }
     }
diff --git a/libminifi/include/core/repository/AtomicRepoEntries.h b/libminifi/include/core/repository/AtomicRepoEntries.h
index 8c15f79..bcbe320 100644
--- a/libminifi/include/core/repository/AtomicRepoEntries.h
+++ b/libminifi/include/core/repository/AtomicRepoEntries.h
@@ -122,7 +122,7 @@
        * buffer, the size of timestamp, and the general
        * system word size
        */
-      uint64_t size() {
+      size_t size() {
         return buffer_.size();
       }
 
diff --git a/libminifi/include/core/repository/VolatileRepository.h b/libminifi/include/core/repository/VolatileRepository.h
index 67c3f92..31c0f87 100644
--- a/libminifi/include/core/repository/VolatileRepository.h
+++ b/libminifi/include/core/repository/VolatileRepository.h
@@ -65,7 +65,7 @@
         current_size_(0),
         current_index_(0),
         max_count_(10000),
-        max_size_(maxPartitionBytes * 0.75),
+        max_size_(static_cast<size_t>(maxPartitionBytes * 0.75)),
         logger_(logging::LoggerFactory<VolatileRepository>::getLogger()) {
     purge_required_ = false;
   }
@@ -214,7 +214,7 @@
     strstream << Configure::nifi_volatile_repository_options << getName() << "." << volatile_repo_max_count;
     if (configure->get(strstream.str(), value)) {
       if (core::Property::StringToInt(value, max_cnt)) {
-        max_count_ = max_cnt;
+        max_count_ = gsl::narrow<uint32_t>(max_cnt);
       }
     }
 
@@ -227,7 +227,7 @@
         if (max_bytes <= 0) {
           max_size_ = (std::numeric_limits<uint32_t>::max)();
         } else {
-          max_size_ = max_bytes;
+          max_size_ = gsl::narrow<size_t>(max_bytes);
         }
       }
     }
diff --git a/libminifi/include/core/state/nodes/DeviceInformation.h b/libminifi/include/core/state/nodes/DeviceInformation.h
index ddf90d6..e7c9a6c 100644
--- a/libminifi/include/core/state/nodes/DeviceInformation.h
+++ b/libminifi/include/core/state/nodes/DeviceInformation.h
@@ -142,9 +142,6 @@
 
       DWORD dwRetVal = 0;
 
-      std::hash<std::string> hash_fn;
-      std::set<std::string> macs;
-
       ULONG adapterLen = sizeof(IP_ADAPTER_INFO);
       adapterPtr = reinterpret_cast<IP_ADAPTER_INFO*>(malloc(sizeof(IP_ADAPTER_INFO)));
       if (adapterPtr == NULL) {
diff --git a/libminifi/include/io/AtomicEntryStream.h b/libminifi/include/io/AtomicEntryStream.h
index 192d7c4..1884a62 100644
--- a/libminifi/include/io/AtomicEntryStream.h
+++ b/libminifi/include/io/AtomicEntryStream.h
@@ -63,7 +63,7 @@
    */
   void seek(uint64_t offset) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     return length_;
   }
 
@@ -124,7 +124,7 @@
 template<typename T>
 void AtomicEntryStream<T>::seek(uint64_t offset) {
   std::lock_guard<std::recursive_mutex> lock(entry_lock_);
-  offset_ = offset;
+  offset_ = gsl::narrow<size_t>(offset);
 }
 
 template<typename T>
diff --git a/libminifi/include/io/BaseStream.h b/libminifi/include/io/BaseStream.h
index 251637c..6b90cab 100644
--- a/libminifi/include/io/BaseStream.h
+++ b/libminifi/include/io/BaseStream.h
@@ -176,7 +176,7 @@
    **/
   int read(uint64_t &value, bool is_little_endian = EndiannessCheck::IS_LITTLE) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     if (LIKELY(composable_stream_ == this)) {
       return buffer.size();
     } else {
diff --git a/libminifi/include/io/CRCStream.h b/libminifi/include/io/CRCStream.h
index f95ff5e..eeb24d9 100644
--- a/libminifi/include/io/CRCStream.h
+++ b/libminifi/include/io/CRCStream.h
@@ -42,8 +42,6 @@
 namespace minifi {
 namespace io {
 
-#define htonll_r(x) ((((uint64_t)htonl(x)) << 32) + htonl((x) >> 32))
-
 template<typename T>
 class CRCStream : public BaseStream {
  public:
@@ -139,7 +137,7 @@
    */
   int read(uint16_t &value, bool is_little_endian = EndiannessCheck::IS_LITTLE) override;
 
-  const uint64_t getSize() const override { return child_stream_->getSize(); }
+  const size_t getSize() const override { return child_stream_->getSize(); }
 
   void closeStream() override { child_stream_->closeStream(); }
 
@@ -183,7 +181,7 @@
     return readData(reinterpret_cast<uint8_t*>(buf.data()), sizeof(t));
   }
 
-  uint64_t crc_;
+  uLong crc_;
   T *child_stream_;
   bool disable_encoding_;
 };
@@ -197,7 +195,7 @@
 
 template<typename T>
 CRCStream<T>::CRCStream(T *child_stream, uint64_t initial_crc)
-    : crc_(initial_crc),
+    : crc_(gsl::narrow<uLong>(initial_crc)),
       child_stream_(child_stream),
       disable_encoding_(false) {
 }
@@ -261,7 +259,7 @@
 int CRCStream<T>::write(uint64_t base_value, bool is_little_endian) {
   if (disable_encoding_)
     is_little_endian = false;
-  const uint64_t value = is_little_endian == 1 ? htonll_r(base_value) : base_value;
+  const uint64_t value = is_little_endian == 1 ? byteSwap(base_value) : base_value;
   uint8_t bytes[sizeof value];
   std::copy(static_cast<const char*>(static_cast<const void*>(&value)), static_cast<const char*>(static_cast<const void*>(&value)) + sizeof value, bytes);
   return writeData(bytes, sizeof value);
@@ -271,7 +269,7 @@
 int CRCStream<T>::write(uint32_t base_value, bool is_little_endian) {
   if (disable_encoding_)
     is_little_endian = false;
-  const uint32_t value = is_little_endian ? htonl(base_value) : base_value;
+  const uint32_t value = is_little_endian ? byteSwap(base_value) : base_value;
   uint8_t bytes[sizeof value];
   std::copy(static_cast<const char*>(static_cast<const void*>(&value)), static_cast<const char*>(static_cast<const void*>(&value)) + sizeof value, bytes);
   return writeData(bytes, sizeof value);
@@ -281,7 +279,7 @@
 int CRCStream<T>::write(uint16_t base_value, bool is_little_endian) {
   if (disable_encoding_)
     is_little_endian = false;
-  const uint16_t value = is_little_endian == 1 ? htons(base_value) : base_value;
+  const uint16_t value = is_little_endian == 1 ? byteSwap(base_value) : base_value;
   uint8_t bytes[sizeof value];
   std::copy(static_cast<const char*>(static_cast<const void*>(&value)), static_cast<const char*>(static_cast<const void*>(&value)) + sizeof value, bytes);
   return writeData(bytes, sizeof value);
diff --git a/libminifi/include/io/DataStream.h b/libminifi/include/io/DataStream.h
index 3574120..071864e 100644
--- a/libminifi/include/io/DataStream.h
+++ b/libminifi/include/io/DataStream.h
@@ -23,6 +23,8 @@
 #include <cstdint>
 #include <vector>
 #include "EndianCheck.h"
+#include "utils/gsl.h"
+
 namespace org {
 namespace apache {
 namespace nifi {
@@ -42,7 +44,7 @@
   /**
    * Constructor
    **/
-  explicit DataStream(const uint8_t *buf, const uint32_t buflen) {
+  explicit DataStream(const uint8_t *buf, const int buflen) {
     writeData(const_cast<uint8_t*>(buf), buflen);
   }
 
@@ -53,7 +55,7 @@
   }
 
   virtual void seek(uint64_t offset) {
-    readBuffer += offset;
+    readBuffer += gsl::narrow<uint32_t>(offset);
   }
 
   virtual void closeStream() { }
@@ -108,7 +110,7 @@
    * Retrieve size of data stream
    * @return size of data stream
    **/
-  virtual const uint64_t getSize() const {
+  virtual const size_t getSize() const {
     return buffer.size();
   }
 
diff --git a/libminifi/include/io/DescriptorStream.h b/libminifi/include/io/DescriptorStream.h
index b82a628..e4ec855 100644
--- a/libminifi/include/io/DescriptorStream.h
+++ b/libminifi/include/io/DescriptorStream.h
@@ -57,7 +57,7 @@
    */
   void seek(uint64_t offset) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     return -1;
   }
 
diff --git a/libminifi/include/io/FileStream.h b/libminifi/include/io/FileStream.h
index b811edd..49f7a53 100644
--- a/libminifi/include/io/FileStream.h
+++ b/libminifi/include/io/FileStream.h
@@ -65,7 +65,7 @@
    */
   void seek(uint64_t offset) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     return length_;
   }
 
diff --git a/libminifi/include/io/NonConvertingStream.h b/libminifi/include/io/NonConvertingStream.h
index b6e2769..4ad3155 100644
--- a/libminifi/include/io/NonConvertingStream.h
+++ b/libminifi/include/io/NonConvertingStream.h
@@ -171,7 +171,7 @@
    **/
   int read(uint64_t &value, bool is_little_endian = false) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
       if (composable_stream_ == this) {
         return buffer.size();
       } else {
diff --git a/libminifi/include/io/Serializable.h b/libminifi/include/io/Serializable.h
index 8b25a65..8c77015 100644
--- a/libminifi/include/io/Serializable.h
+++ b/libminifi/include/io/Serializable.h
@@ -44,8 +44,9 @@
 #ifdef htonll
   return htonll(i);
 #else
-  #define htonll_r(x) ((((uint64_t)htonl(x)) << 32) + htonl((x) >> 32))
-  return htonll_r(i);
+  uint32_t lower_32_bits = static_cast<uint32_t>(i);
+  uint32_t higher_32_bits = static_cast<uint32_t>(i >> 32);
+  return (static_cast<uint64_t>(byteSwap(lower_32_bits)) << 32) + byteSwap(higher_32_bits);
 #endif
 }
 
diff --git a/libminifi/include/io/tls/SecureDescriptorStream.h b/libminifi/include/io/tls/SecureDescriptorStream.h
index 7777c1a..1fe3ff1 100644
--- a/libminifi/include/io/tls/SecureDescriptorStream.h
+++ b/libminifi/include/io/tls/SecureDescriptorStream.h
@@ -61,7 +61,7 @@
    */
   void seek(uint64_t offset) override;
 
-  const uint64_t getSize() const override {
+  const size_t getSize() const override {
     return -1;
   }
 
diff --git a/libminifi/include/sitetosite/SiteToSite.h b/libminifi/include/sitetosite/SiteToSite.h
index dbd63b0..43dcccd 100644
--- a/libminifi/include/sitetosite/SiteToSite.h
+++ b/libminifi/include/sitetosite/SiteToSite.h
@@ -246,8 +246,6 @@
     total_transfers_ = 0;
     _bytes = 0;
 
-    char uuidStr[37];
-
     // Generate the global UUID for the transaction
     id_generator_->generate(uuid_);
     uuid_str_ = uuid_.to_string();
diff --git a/libminifi/include/sitetosite/SiteToSiteClient.h b/libminifi/include/sitetosite/SiteToSiteClient.h
index 5d874eb..bbf08ec 100644
--- a/libminifi/include/sitetosite/SiteToSiteClient.h
+++ b/libminifi/include/sitetosite/SiteToSiteClient.h
@@ -292,10 +292,10 @@
   // void process(std::ofstream *stream) {
   int64_t process(std::shared_ptr<io::BaseStream> stream) {
     uint8_t buffer[16384];
-    int len = _packet->_size;
-    int total = 0;
+    uint64_t len = _packet->_size;
+    uint64_t total = 0;
     while (len > 0) {
-      int size = len < 16384 ? len : 16384;
+      int size = len < 16384 ? static_cast<int>(len) : 16384;
       int ret = _packet->transaction_->getStream().readData(buffer, size);
       if (ret != size) {
         logging::LOG_ERROR(_packet->logger_reference_) << "Site2Site Receive Flow Size " << size << " Failed " << ret << ", should have received " << len;
@@ -305,7 +305,7 @@
       len -= size;
       total += size;
     }
-    logging::LOG_INFO(_packet->logger_reference_) << "Received " << len << " from stream";
+    logging::LOG_INFO(_packet->logger_reference_) << "Received " << total << " from stream";
     return len;
   }
 };
diff --git a/libminifi/include/utils/ByteArrayCallback.h b/libminifi/include/utils/ByteArrayCallback.h
index fdde3f6..826957b 100644
--- a/libminifi/include/utils/ByteArrayCallback.h
+++ b/libminifi/include/utils/ByteArrayCallback.h
@@ -48,7 +48,7 @@
     if (stream->getSize() > 0) {
       vec.resize(stream->getSize());
 
-      stream->readData(reinterpret_cast<uint8_t*>(vec.data()), stream->getSize());
+      stream->readData(reinterpret_cast<uint8_t*>(vec.data()), gsl::narrow<int>(stream->getSize()));
     }
 
     ptr = reinterpret_cast<char*>(&vec[0]);
diff --git a/libminifi/include/utils/HTTPClient.h b/libminifi/include/utils/HTTPClient.h
index ad5f128..1069546 100644
--- a/libminifi/include/utils/HTTPClient.h
+++ b/libminifi/include/utils/HTTPClient.h
@@ -15,6 +15,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+// Visual Studio 2017 warns when overriding a deprecated function, even if
+// the override is also deprecated.  Note that we need to put this #pragma
+// here, because it doesn't work inside the #ifndef
+#ifdef WIN32
+#pragma warning(push)
+#pragma warning(disable: 4996)
+#endif
+
 #ifndef LIBMINIFI_INCLUDE_UTILS_HTTPCLIENT_H_
 #define LIBMINIFI_INCLUDE_UTILS_HTTPCLIENT_H_
 
@@ -262,12 +271,10 @@
 
 class BaseHTTPClient {
  public:
-  explicit BaseHTTPClient(const std::string &url, const std::shared_ptr<minifi::controllers::SSLContextService> ssl_context_service = nullptr) {
-    response_code = -1;
+  explicit BaseHTTPClient(const std::string &url, const std::shared_ptr<minifi::controllers::SSLContextService> ssl_context_service = nullptr) : response_code(-1) {
   }
 
-  BaseHTTPClient() {
-    response_code = -1;
+  BaseHTTPClient() : response_code(-1) {
   }
 
   virtual ~BaseHTTPClient() = default;
@@ -307,7 +314,7 @@
     return false;
   }
 
-  virtual int64_t &getResponseCode() {
+  virtual int64_t getResponseCode() const {
     return response_code;
   }
 
@@ -375,3 +382,7 @@
 }  // namespace org
 
 #endif  // LIBMINIFI_INCLUDE_UTILS_HTTPCLIENT_H_
+
+#ifdef WIN32
+#pragma warning(pop)
+#endif  // NOLINT
diff --git a/libminifi/include/utils/ThreadPool.h b/libminifi/include/utils/ThreadPool.h
index 1132c7d..93890d7 100644
--- a/libminifi/include/utils/ThreadPool.h
+++ b/libminifi/include/utils/ThreadPool.h
@@ -229,7 +229,7 @@
   bool isTaskRunning(const std::string &identifier) const {
     try {
       return task_status_.at(identifier) == true;
-    } catch (const std::out_of_range &e) {
+    } catch (const std::out_of_range &) {
       return false;
     }
   }
diff --git a/libminifi/include/utils/file/FileManager.h b/libminifi/include/utils/file/FileManager.h
index 701c6a2..79cef44 100644
--- a/libminifi/include/utils/file/FileManager.h
+++ b/libminifi/include/utils/file/FileManager.h
@@ -63,7 +63,7 @@
 
   ~FileManager() {
     for (auto file : unique_files_) {
-      unlink(file.c_str());
+      std::remove(file.c_str());
     }
   }
   std::string unique_file(const std::string &location, bool keep = false) {
diff --git a/libminifi/include/utils/file/FileUtils.h b/libminifi/include/utils/file/FileUtils.h
index ebd2d07..7c90d43 100644
--- a/libminifi/include/utils/file/FileUtils.h
+++ b/libminifi/include/utils/file/FileUtils.h
@@ -710,6 +710,22 @@
     return get_parent_path(executable_path);
   }
 
+  static int close(int file_descriptor) {
+#ifdef WIN32
+    return _close(file_descriptor);
+#else
+    return ::close(file_descriptor);
+#endif
+  }
+
+  static int access(const char *path_name, int mode) {
+#ifdef WIN32
+    return _access(path_name, mode);
+#else
+    return ::access(path_name, mode);
+#endif
+  }
+
 #ifdef WIN32
   static std::error_code hide_file(const char* const file_name) {
     const bool success = SetFileAttributesA(file_name, FILE_ATTRIBUTE_HIDDEN);
diff --git a/libminifi/src/FlowControlProtocol.cpp b/libminifi/src/FlowControlProtocol.cpp
index 2b174a8..4dafd24 100644
--- a/libminifi/src/FlowControlProtocol.cpp
+++ b/libminifi/src/FlowControlProtocol.cpp
@@ -79,7 +79,9 @@
     if (status <= 0) {
       return status;
     }
-#ifndef __MACH__
+#ifdef WIN32
+    status = _read(_socket, buf, buflen);
+#elif !defined(__MACH__)
     status = read(_socket, buf, buflen);
 #else
     status = recv(_socket, buf, buflen, 0);
@@ -194,7 +196,7 @@
   int status = sendData(buffer.data(), size);
   buffer.clear();
   if (status <= 0) {
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     logger_->log_error("Flow Control Protocol Send Register Req failed");
     return -1;
@@ -204,7 +206,7 @@
   status = readHdr(&hdr);
 
   if (status <= 0) {
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     logger_->log_error("Flow Control Protocol Read Register Resp header failed");
     return -1;
@@ -224,7 +226,7 @@
     status = readData(payload.data(), hdr.payloadLen);
     if (status <= 0) {
       logger_->log_warn("Flow Control Protocol Register Read Payload fail");
-      close(_socket);
+      utils::file::FileUtils::close(_socket);
       _socket = 0;
       return -1;
     }
@@ -241,12 +243,12 @@
         break;
       }
     }
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     return 0;
   } else {
     logger_->log_warn("Flow Control Protocol Register fail");
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     return -1;
   }
@@ -288,7 +290,7 @@
   int status = sendData(buffer.data(), size);
   buffer.clear();
   if (status <= 0) {
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     logger_->log_error("Flow Control Protocol Send Report Req failed");
     return -1;
@@ -298,7 +300,7 @@
   status = readHdr(&hdr);
 
   if (status <= 0) {
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     logger_->log_error("Flow Control Protocol Read Report Resp header failed");
     return -1;
@@ -316,7 +318,7 @@
     status = readData(payload.data(), hdr.payloadLen);
     if (status <= 0) {
       logger_->log_warn("Flow Control Protocol Report Resp Read Payload fail");
-      close(_socket);
+      utils::file::FileUtils::close(_socket);
       _socket = 0;
       return -1;
     }
@@ -349,33 +351,33 @@
         break;
       }
     }
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     return 0;
   } else if (hdr.status == RESP_TRIGGER_REGISTER && hdr.seqNumber == this->_seqNumber) {
     logger_->log_trace("Flow Control Protocol trigger reregister");
     this->_registered = false;
     this->_seqNumber++;
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     return 0;
   } else if (hdr.status == RESP_STOP_FLOW_CONTROLLER && hdr.seqNumber == this->_seqNumber) {
     logger_->log_trace("Flow Control Protocol stop flow controller");
     this->_controller->stop(true);
     this->_seqNumber++;
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     return 0;
   } else if (hdr.status == RESP_START_FLOW_CONTROLLER && hdr.seqNumber == this->_seqNumber) {
     logger_->log_trace("Flow Control Protocol start flow controller");
     this->_controller->start();
     this->_seqNumber++;
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     return 0;
   } else {
     logger_->log_trace("Flow Control Protocol Report fail");
-    close(_socket);
+    utils::file::FileUtils::close(_socket);
     _socket = 0;
     return -1;
   }
diff --git a/libminifi/src/RemoteProcessorGroupPort.cpp b/libminifi/src/RemoteProcessorGroupPort.cpp
index b945396..4607a7e 100644
--- a/libminifi/src/RemoteProcessorGroupPort.cpp
+++ b/libminifi/src/RemoteProcessorGroupPort.cpp
@@ -273,7 +273,7 @@
 
     returnProtocol(std::move(protocol_));
     return;
-  } catch (const minifi::Exception &ex2) {
+  } catch (const minifi::Exception &) {
     context->yield();
     session->rollback();
   } catch (...) {
diff --git a/libminifi/src/c2/C2Agent.cpp b/libminifi/src/c2/C2Agent.cpp
index 48617e8..9b46323 100644
--- a/libminifi/src/c2/C2Agent.cpp
+++ b/libminifi/src/c2/C2Agent.cpp
@@ -18,6 +18,7 @@
 
 #include "c2/C2Agent.h"
 
+#include <cstdio>
 #include <csignal>
 #include <utility>
 #include <limits>
@@ -37,6 +38,7 @@
 #include "utils/file/FileManager.h"
 #include "utils/GeneralUtils.h"
 #include "utils/HTTPClient.h"
+#include "utils/Environment.h"
 #include "utils/Monitors.h"
 
 namespace org {
@@ -223,7 +225,7 @@
       } else {
         heart_beat_period_ = std::stoi(heartbeat_period);
       }
-    } catch (const std::invalid_argument &ie) {
+    } catch (const std::invalid_argument &) {
       heart_beat_period_ = 3000;
     }
   } else {
@@ -238,25 +240,20 @@
 
   if (allow_updates_) {
     if (!configure->get("nifi.c2.agent.update.command", "c2.agent.update.command", update_command_)) {
-      char cwd[1024];
-      if (getcwd(cwd, sizeof(cwd)) == nullptr) {
-        logger_->log_error("Could not set update command, reason %s", std::strerror(errno));
-
+      std::string cwd = utils::Environment::getCurrentWorkingDirectory();
+      if (cwd.empty()) {
+        logger_->log_error("Could not set the update command because the working directory could not be determined");
       } else {
-        std::stringstream command;
-        command << cwd << "/minifi.sh update";
-        update_command_ = command.str();
+        update_command_ = cwd + "/minifi.sh update";
       }
     }
 
     if (!configure->get("nifi.c2.agent.update.temp.location", "c2.agent.update.temp.location", update_location_)) {
-      char cwd[1024];
-      if (getcwd(cwd, sizeof(cwd)) == nullptr) {
-        logger_->log_error("Could not set copy path, reason %s", std::strerror(errno));
+      std::string cwd = utils::Environment::getCurrentWorkingDirectory();
+      if (cwd.empty()) {
+        logger_->log_error("Could not set the update location because the working directory could not be determined");
       } else {
-        std::stringstream copy_path;
-        std::stringstream command;
-        copy_path << cwd << "/minifi.update";
+        update_location_ = cwd + "/minifi.update";
       }
     }
 
@@ -679,7 +676,7 @@
 
       std::ifstream new_conf(file_path);
       std::string raw_data_str((std::istreambuf_iterator<char>(new_conf)), std::istreambuf_iterator<char>());
-      unlink(file_path.c_str());
+      std::remove(file_path.c_str());
       // if we can apply the update, we will acknowledge it and then backup the configuration file.
       if (update_sink_->applyUpdate(urlStr, raw_data_str)) {
         C2Payload response(Operation::ACKNOWLEDGE, state::UpdateState::FULLY_APPLIED, resp.ident, false, true);
@@ -832,7 +829,7 @@
         }
         // remove the downloaded file.
         logger_->log_trace("removing file %s", file_path);
-        unlink(file_path.c_str());
+        std::remove(file_path.c_str());
         update_agent();
       } else {
         logger_->log_trace("Update disallowed from file %s", file_path);
@@ -862,15 +859,14 @@
 }
 
 void C2Agent::restart_agent() {
-  char cwd[1024];
-  if (getcwd(cwd, sizeof(cwd)) == nullptr) {
-    logger_->log_error("Could not restart agent, reason %s", std::strerror(errno));
+  std::string cwd = utils::Environment::getCurrentWorkingDirectory();
+  if (cwd.empty()) {
+    logger_->log_error("Could not restart the agent because the working directory could not be determined");
     return;
   }
 
-  std::stringstream command;
-  command << cwd << "/bin/minifi.sh restart";
-  system(command.str().c_str());
+  std::string command = cwd + "/bin/minifi.sh restart";
+  system(command.c_str());
 }
 
 void C2Agent::update_agent() {
diff --git a/libminifi/src/c2/ControllerSocketProtocol.cpp b/libminifi/src/c2/ControllerSocketProtocol.cpp
index 83f77c5..ab8e364 100644
--- a/libminifi/src/c2/ControllerSocketProtocol.cpp
+++ b/libminifi/src/c2/ControllerSocketProtocol.cpp
@@ -183,7 +183,7 @@
           } else if (what == "components") {
             io::BaseStream resp;
             resp.writeData(&head, 1);
-            uint16_t size = update_sink_->getAllComponents().size();
+            uint16_t size = gsl::narrow<uint16_t>(update_sink_->getAllComponents().size());
             resp.write(size);
             for (const auto &component : update_sink_->getAllComponents()) {
               resp.writeUTF(component->getComponentName());
@@ -209,7 +209,7 @@
           } else if (what == "connections") {
             io::BaseStream resp;
             resp.writeData(&head, 1);
-            uint16_t size = queue_full_.size();
+            uint16_t size = gsl::narrow<uint16_t>(queue_full_.size());
             resp.write(size);
             for (const auto &connection : queue_full_) {
               resp.writeUTF(connection.first, false);
@@ -227,7 +227,7 @@
             }
             io::BaseStream resp;
             resp.writeData(&head, 1);
-            uint16_t full_connection_count = full_connections.size();
+            uint16_t full_connection_count = gsl::narrow<uint16_t>(full_connections.size());
             resp.write(full_connection_count);
             for (auto conn : full_connections) {
               resp.writeUTF(conn);
diff --git a/libminifi/src/controllers/NetworkPrioritizerService.cpp b/libminifi/src/controllers/NetworkPrioritizerService.cpp
index 5df8af2..32d23f9 100644
--- a/libminifi/src/controllers/NetworkPrioritizerService.cpp
+++ b/libminifi/src/controllers/NetworkPrioritizerService.cpp
@@ -156,11 +156,11 @@
 
 bool NetworkPrioritizerService::sufficient_tokens(uint32_t size) {
   std::lock_guard<std::mutex> lock(token_mutex_);
-  auto ms = std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
+  auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
   auto diff = ms - timestamp_;
   timestamp_ = ms;
   if (diff > 0) {
-    tokens_ += diff * tokens_per_ms;
+    tokens_ += gsl::narrow<uint32_t>(diff * tokens_per_ms);
   }
   if (bytes_per_token_ > 0 && size > 0) {
     if (tokens_ * bytes_per_token_ >= size) {
@@ -197,9 +197,9 @@
       logger_->log_trace("Max throughput is %d", max_throughput_);
       if (max_throughput_ < 1000) {
         bytes_per_token_ = 1;
-        tokens_ = max_throughput_;
+        tokens_ = gsl::narrow<uint32_t>(max_throughput_);
       } else {
-        bytes_per_token_ = max_throughput_ / 1000;
+        bytes_per_token_ = gsl::narrow<uint32_t>(max_throughput_ / 1000);
       }
     }
 
diff --git a/libminifi/src/core/ConfigurationFactory.cpp b/libminifi/src/core/ConfigurationFactory.cpp
index f82fd16..0f12e92 100644
--- a/libminifi/src/core/ConfigurationFactory.cpp
+++ b/libminifi/src/core/ConfigurationFactory.cpp
@@ -57,7 +57,7 @@
         throw std::runtime_error("Support for the provided configuration class could not be found");
       }
     }
-  } catch (const std::runtime_error &r) {
+  } catch (const std::runtime_error &) {
     if (fail_safe) {
       return std::unique_ptr<core::FlowConfiguration>(new core::FlowConfiguration(repo, flow_file_repo, content_repo, stream_factory, configure, path));
     }
diff --git a/libminifi/src/core/ProcessGroup.cpp b/libminifi/src/core/ProcessGroup.cpp
index 28e6c9a..150a3d6 100644
--- a/libminifi/src/core/ProcessGroup.cpp
+++ b/libminifi/src/core/ProcessGroup.cpp
@@ -431,7 +431,7 @@
 std::size_t ProcessGroup::getTotalFlowFileCount() const {
   std::size_t sum = 0;
   for (auto& conn : connections_) {
-    sum += conn->getQueueSize();
+    sum += gsl::narrow<std::size_t>(conn->getQueueSize());
   }
 
   for (const ProcessGroup* childGroup : child_process_groups_) {
diff --git a/libminifi/src/core/ProcessSession.cpp b/libminifi/src/core/ProcessSession.cpp
index e14d812..5925865 100644
--- a/libminifi/src/core/ProcessSession.cpp
+++ b/libminifi/src/core/ProcessSession.cpp
@@ -434,7 +434,7 @@
             break;
           }
         } else {
-          if (stream->write(reinterpret_cast<uint8_t*>(charBuffer.data()), input.gcount()) < 0) {
+          if (stream->write(reinterpret_cast<uint8_t*>(charBuffer.data()), gsl::narrow<int>(input.gcount())) < 0) {
             invalidWrite = true;
             break;
           }
@@ -584,12 +584,17 @@
 #elif defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(WIN32)
+#pragma warning(push)
+#pragma warning(disable: 4996)
 #endif
   import(source, flows, offset, inputDelimiter);
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #elif defined(__GNUC__)
 #pragma GCC diagnostic pop
+#elif defined(WIN32)
+#pragma warning(pop)
 #endif
   logger_->log_trace("Closed input %s, keeping source ? %i", source, keepSource);
   if (!keepSource) {
diff --git a/libminifi/src/core/ProcessSessionReadCallback.cpp b/libminifi/src/core/ProcessSessionReadCallback.cpp
index 8bff56a..b902009 100644
--- a/libminifi/src/core/ProcessSessionReadCallback.cpp
+++ b/libminifi/src/core/ProcessSessionReadCallback.cpp
@@ -18,6 +18,7 @@
  * limitations under the License.
  */
 #include "core/ProcessSessionReadCallback.h"
+#include <cstdio>
 #include <memory>
 #include <string>
 
@@ -88,7 +89,7 @@
   _tmpFileOs.close();
 
   // Clean up tmp file, if necessary
-  unlink(_tmpFile.c_str());
+  std::remove(_tmpFile.c_str());
 }
 
 }  // namespace core
diff --git a/libminifi/src/core/RepositoryFactory.cpp b/libminifi/src/core/RepositoryFactory.cpp
index 82ed53a..2f82b8e 100644
--- a/libminifi/src/core/RepositoryFactory.cpp
+++ b/libminifi/src/core/RepositoryFactory.cpp
@@ -65,7 +65,7 @@
     } else {
       throw std::runtime_error("Support for the provided configuration class could not be found");
     }
-  } catch (const std::runtime_error &r) {
+  } catch (const std::runtime_error &) {
     if (fail_safe) {
       return std::make_shared<core::Repository>("fail_safe", "fail_safe", 1, 1, 1);
     }
@@ -98,7 +98,7 @@
     } else {
       throw std::runtime_error("Support for the provided configuration class could not be found");
     }
-  } catch (const std::runtime_error &r) {
+  } catch (const std::runtime_error &) {
     if (fail_safe) {
       return std::make_shared<core::repository::VolatileContentRepository>("fail_safe");
     }
diff --git a/libminifi/src/core/logging/LoggerConfiguration.cpp b/libminifi/src/core/logging/LoggerConfiguration.cpp
index 3164d86..ae9c2fa 100644
--- a/libminifi/src/core/logging/LoggerConfiguration.cpp
+++ b/libminifi/src/core/logging/LoggerConfiguration.cpp
@@ -167,8 +167,8 @@
       if (logger_properties->get(appender_key + ".max_files", max_files_str)) {
         try {
           max_files = std::stoi(max_files_str);
-        } catch (const std::invalid_argument &ia) {
-        } catch (const std::out_of_range &oor) {
+        } catch (const std::invalid_argument &) {
+        } catch (const std::out_of_range &) {
         }
       }
 
@@ -177,8 +177,8 @@
       if (logger_properties->get(appender_key + ".max_file_size", max_file_size_str)) {
         try {
           max_file_size = std::stoi(max_file_size_str);
-        } catch (const std::invalid_argument &ia) {
-        } catch (const std::out_of_range &oor) {
+        } catch (const std::invalid_argument &) {
+        } catch (const std::out_of_range &) {
         }
       }
       sink_map[appender_name] = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(file_name, max_file_size, max_files);
@@ -288,7 +288,7 @@
   spdlogger->flush_on(std::max(spdlog::level::info, current_namespace->level));
   try {
     spdlog::register_logger(spdlogger);
-  } catch (const spdlog::spdlog_ex &ex) {
+  } catch (const spdlog::spdlog_ex &) {
     // Ignore as someone else beat us to registration, we should get the one they made below
   }
   return spdlog::get(name);
diff --git a/libminifi/src/core/yaml/YamlConfiguration.cpp b/libminifi/src/core/yaml/YamlConfiguration.cpp
index 95c2271..088c041 100644
--- a/libminifi/src/core/yaml/YamlConfiguration.cpp
+++ b/libminifi/src/core/yaml/YamlConfiguration.cpp
@@ -454,7 +454,7 @@
   reportTask->setPortUUID(port_uuid);
 
   if (core::Property::StringToInt(batchSizeStr, lvalue)) {
-    reportTask->setBatchSize(lvalue);
+    reportTask->setBatchSize(gsl::narrow<int>(lvalue));
   }
 
   reportTask->initialize();
@@ -479,7 +479,7 @@
           try {
             checkRequiredField(&controllerServiceNode, "class", CONFIG_YAML_CONTROLLER_SERVICES_KEY);
             type = controllerServiceNode["class"].as<std::string>();
-          } catch (const std::invalid_argument &e) {
+          } catch (const std::invalid_argument &) {
             checkRequiredField(&controllerServiceNode, "type", CONFIG_YAML_CONTROLLER_SERVICES_KEY);
             type = controllerServiceNode["type"].as<std::string>();
             logger_->log_debug("Using type %s for controller service node", type);
@@ -514,7 +514,7 @@
           }
           controller_services_->put(id, controller_service_node);
           controller_services_->put(name, controller_service_node);
-        } catch (YAML::InvalidNode &in) {
+        } catch (YAML::InvalidNode &) {
           throw Exception(ExceptionType::GENERAL_EXCEPTION, "Name, id, and class must be specified for controller services");
         }
       }
diff --git a/libminifi/src/io/ClientSocket.cpp b/libminifi/src/io/ClientSocket.cpp
index 6c70037..ffdae03 100644
--- a/libminifi/src/io/ClientSocket.cpp
+++ b/libminifi/src/io/ClientSocket.cpp
@@ -39,6 +39,7 @@
 #include <utils/Deleters.h>
 #include "io/validation.h"
 #include "core/logging/LoggerConfiguration.h"
+#include "utils/file/FileUtils.h"
 #include "utils/GeneralUtils.h"
 
 namespace util = org::apache::nifi::minifi::utils;
@@ -226,11 +227,11 @@
     socket_file_descriptor_ = INVALID_SOCKET;
   }
   if (total_written_ > 0) {
-    local_network_interface_.log_write(total_written_);
+    local_network_interface_.log_write(gsl::narrow<uint32_t>(total_written_.load()));
     total_written_ = 0;
   }
   if (total_read_ > 0) {
-    local_network_interface_.log_read(total_read_);
+    local_network_interface_.log_read(gsl::narrow<uint32_t>(total_read_.load()));
     total_read_ = 0;
   }
 }
@@ -512,7 +513,7 @@
     ret = send(fd, reinterpret_cast<const char*>(value) + bytes, size - bytes, 0);
     // check for errors
     if (ret <= 0) {
-      close(fd);
+      utils::file::FileUtils::close(fd);
       logger_->log_error("Could not send to %d, error: %s", fd, get_last_socket_error_message());
       return ret;
     }
@@ -609,7 +610,7 @@
     if (fd < 0) {
       if (listeners_ <= 0) {
         logger_->log_debug("fd %d close %i", fd, buflen);
-        close(socket_file_descriptor_);
+        utils::file::FileUtils::close(socket_file_descriptor_);
       }
       return -1;
     }
diff --git a/libminifi/src/io/DescriptorStream.cpp b/libminifi/src/io/DescriptorStream.cpp
index f77f5a1..549c1b5 100644
--- a/libminifi/src/io/DescriptorStream.cpp
+++ b/libminifi/src/io/DescriptorStream.cpp
@@ -36,7 +36,11 @@
 
 void DescriptorStream::seek(uint64_t offset) {
   std::lock_guard<std::recursive_mutex> lock(file_lock_);
-  lseek(fd_, offset, 0x00);
+#ifdef WIN32
+  _lseeki64(fd_, gsl::narrow<int64_t>(offset), 0x00);
+#else
+  lseek(fd_, gsl::narrow<off_t>(offset), 0x00);
+#endif
 }
 
 int DescriptorStream::writeData(std::vector<uint8_t> &buf, int buflen) {
@@ -55,7 +59,11 @@
 int DescriptorStream::writeData(uint8_t *value, int size) {
   if (!IsNullOrEmpty(value)) {
     std::lock_guard<std::recursive_mutex> lock(file_lock_);
+#ifdef WIN32
+    if (_write(fd_, value, size) != size) {
+#else
     if (::write(fd_, value, size) != size) {
+#endif
       return -1;
     } else {
       return size;
@@ -96,7 +104,11 @@
 
 int DescriptorStream::readData(uint8_t *buf, int buflen) {
   if (!IsNullOrEmpty(buf)) {
+#ifdef WIN32
+    auto size_read = _read(fd_, buf, buflen);
+#else
     auto size_read = ::read(fd_, buf, buflen);
+#endif
 
     if (size_read < 0) {
       return -1;
diff --git a/libminifi/src/io/FileStream.cpp b/libminifi/src/io/FileStream.cpp
index 0fe80aa..1d79469 100644
--- a/libminifi/src/io/FileStream.cpp
+++ b/libminifi/src/io/FileStream.cpp
@@ -40,9 +40,9 @@
     file_stream_->open(path.c_str(), std::fstream::out | std::fstream::binary);
   file_stream_->seekg(0, file_stream_->end);
   file_stream_->seekp(0, file_stream_->end);
-  int len = file_stream_->tellg();
+  std::streamoff len = file_stream_->tellg();
   if (len > 0) {
-    length_ = len;
+    length_ = gsl::narrow<size_t>(len);
   } else {
     length_ = 0;
   }
@@ -61,9 +61,9 @@
   }
   file_stream_->seekg(0, file_stream_->end);
   file_stream_->seekp(0, file_stream_->end);
-  int len = file_stream_->tellg();
+  std::streamoff len = file_stream_->tellg();
   if (len > 0) {
-    length_ = len;
+    length_ = gsl::narrow<size_t>(len);
   } else {
     length_ = 0;
   }
@@ -80,7 +80,7 @@
 
 void FileStream::seek(uint64_t offset) {
   std::lock_guard<std::recursive_mutex> lock(file_lock_);
-  offset_ = offset;
+  offset_ = gsl::narrow<size_t>(offset);
   file_stream_->clear();
   file_stream_->seekg(offset_);
   file_stream_->seekp(offset_);
@@ -158,12 +158,12 @@
       file_stream_->clear();
       file_stream_->seekg(0, file_stream_->end);
       file_stream_->seekp(0, file_stream_->end);
-      int len = file_stream_->tellg();
+      size_t len = gsl::narrow<size_t>(file_stream_->tellg());
       size_t ret = len - offset_;
       offset_ = len;
       length_ = len;
       logging::LOG_DEBUG(logger_) << path_ << " eof bit, ended at " << offset_;
-      return ret;
+      return gsl::narrow<int>(ret);
     } else {
       offset_ += buflen;
       file_stream_->seekp(offset_);
diff --git a/libminifi/src/io/ServerSocket.cpp b/libminifi/src/io/ServerSocket.cpp
index bc24f9a..183a9e0 100644
--- a/libminifi/src/io/ServerSocket.cpp
+++ b/libminifi/src/io/ServerSocket.cpp
@@ -32,6 +32,7 @@
 #include <string>
 #include "io/validation.h"
 #include "core/logging/LoggerConfiguration.h"
+#include "utils/file/FileUtils.h"
 
 namespace org {
 namespace apache {
@@ -71,7 +72,7 @@
 
 void ServerSocket::close_fd(int fd) {
   std::lock_guard<std::recursive_mutex> guard(selection_mutex_);
-  close(fd);
+  utils::file::FileUtils::close(fd);
   FD_CLR(fd, &total_list_);
 }
 
diff --git a/libminifi/src/io/tls/SecureDescriptorStream.cpp b/libminifi/src/io/tls/SecureDescriptorStream.cpp
index 3965d0a..8b1edac 100644
--- a/libminifi/src/io/tls/SecureDescriptorStream.cpp
+++ b/libminifi/src/io/tls/SecureDescriptorStream.cpp
@@ -36,7 +36,11 @@
 
 void SecureDescriptorStream::seek(uint64_t offset) {
   std::lock_guard<std::recursive_mutex> lock(file_lock_);
-  lseek(fd_, offset, 0x00);
+#ifdef WIN32
+  _lseeki64(fd_, gsl::narrow<int64_t>(offset), 0x00);
+#else
+  lseek(fd_, gsl::narrow<off_t>(offset), 0x00);
+#endif
 }
 
 int SecureDescriptorStream::writeData(std::vector<uint8_t> &buf, int buflen) {
diff --git a/libminifi/src/sitetosite/Peer.cpp b/libminifi/src/sitetosite/Peer.cpp
index 5505b0c..9859659 100644
--- a/libminifi/src/sitetosite/Peer.cpp
+++ b/libminifi/src/sitetosite/Peer.cpp
@@ -54,7 +54,7 @@
   if (stream_->initialize() < 0)
     return false;
 
-  uint16_t data_size = sizeof MAGIC_BYTES;
+  int data_size = gsl::narrow<int>(sizeof MAGIC_BYTES);
 
   if (stream_->writeData(reinterpret_cast<uint8_t *>(const_cast<char*>(MAGIC_BYTES)), data_size) != data_size) {
     return false;
diff --git a/libminifi/src/sitetosite/RawSocketProtocol.cpp b/libminifi/src/sitetosite/RawSocketProtocol.cpp
index 355fc42..f17241e 100644
--- a/libminifi/src/sitetosite/RawSocketProtocol.cpp
+++ b/libminifi/src/sitetosite/RawSocketProtocol.cpp
@@ -376,7 +376,7 @@
         tearDown();
         return false;
       }
-      PeerStatus status(std::make_shared<Peer>(port_id_, host, port, secure), count, true);
+      PeerStatus status(std::make_shared<Peer>(port_id_, host, gsl::narrow<uint16_t>(port), secure != 0), count, true);
       peers.push_back(std::move(status));
       logging::LOG_TRACE(logger_) << "Site2Site Peer host " << host << " port " << port << " Secure " << std::to_string(secure);
     }
diff --git a/libminifi/src/sitetosite/SiteToSiteClient.cpp b/libminifi/src/sitetosite/SiteToSiteClient.cpp
index 056fd9e..40af602 100644
--- a/libminifi/src/sitetosite/SiteToSiteClient.cpp
+++ b/libminifi/src/sitetosite/SiteToSiteClient.cpp
@@ -499,8 +499,9 @@
       return -1;
     }
 
-    ret = transaction->getStream().writeData(reinterpret_cast<uint8_t *>(const_cast<char*>(packet->payload_.c_str())), len);
-    if (ret != (int64_t)len) {
+    ret = transaction->getStream().writeData(reinterpret_cast<uint8_t *>(const_cast<char*>(packet->payload_.c_str())),
+                                             gsl::narrow<int>(len));
+    if (ret != gsl::narrow<int64_t>(len)) {
       logger_->log_debug("Failed to write payload size!");
       return -1;
     }
diff --git a/libminifi/src/utils/file/FileUtils.cpp b/libminifi/src/utils/file/FileUtils.cpp
index a010cd7..b02c8e3 100644
--- a/libminifi/src/utils/file/FileUtils.cpp
+++ b/libminifi/src/utils/file/FileUtils.cpp
@@ -35,13 +35,13 @@
 
   std::ifstream stream{file_name, std::ios::in | std::ios::binary};
 
-  uint64_t checksum = 0;
+  uLong checksum = 0;
   uint64_t remaining_bytes_to_be_read = up_to_position;
 
   while (stream && remaining_bytes_to_be_read > 0) {
     // () around std::min are needed because Windows.h defines min (and max) as a macro
     stream.read(buffer.data(), (std::min)(BUFFER_SIZE, remaining_bytes_to_be_read));
-    uint64_t bytes_read = stream.gcount();
+    uInt bytes_read = gsl::narrow<uInt>(stream.gcount());
     checksum = crc32(checksum, reinterpret_cast<unsigned char*>(buffer.data()), bytes_read);
     remaining_bytes_to_be_read -= bytes_read;
   }
diff --git a/libminifi/test/TestBase.cpp b/libminifi/test/TestBase.cpp
index 2dd8a36..6f415eb 100644
--- a/libminifi/test/TestBase.cpp
+++ b/libminifi/test/TestBase.cpp
@@ -219,7 +219,7 @@
 
 bool TestPlan::setProperty(const std::shared_ptr<core::Processor> proc, const std::string &prop, const std::string &value, bool dynamic) {
   std::lock_guard<std::recursive_mutex> guard(mutex);
-  int32_t i = 0;
+  size_t i = 0;
   logger_->log_info("Attempting to set property %s %s for %s", prop, value, proc->getName());
   for (i = 0; i < processor_queue_.size(); i++) {
     if (processor_queue_.at(i) == proc) {
@@ -227,7 +227,7 @@
     }
   }
 
-  if (i >= processor_queue_.size() || i < 0 || i >= processor_contexts_.size()) {
+  if (i >= processor_queue_.size() || i >= processor_contexts_.size()) {
     return false;
   }
 
@@ -289,7 +289,7 @@
     processor->onTrigger(context, current_session);
   }
   current_session->commit();
-  return location + 1 < processor_queue_.size();
+  return gsl::narrow<size_t>(location + 1) < processor_queue_.size();
 }
 
 bool TestPlan::runCurrentProcessor(std::function<void(const std::shared_ptr<core::ProcessContext>, const std::shared_ptr<core::ProcessSession>)> verify) {
@@ -313,7 +313,7 @@
     processor->onTrigger(context, current_session);
   }
   current_session->commit();
-  return location + 1 < processor_queue_.size();
+  return gsl::narrow<size_t>(location + 1) < processor_queue_.size();
 }
 
 std::set<std::shared_ptr<provenance::ProvenanceEventRecord>> TestPlan::getProvenanceRecords() {
diff --git a/libminifi/test/archive-tests/CompressContentTests.cpp b/libminifi/test/archive-tests/CompressContentTests.cpp
index 45b55ca..bb31681 100644
--- a/libminifi/test/archive-tests/CompressContentTests.cpp
+++ b/libminifi/test/archive-tests/CompressContentTests.cpp
@@ -43,7 +43,7 @@
 
 class ReadCallback: public org::apache::nifi::minifi::InputStreamCallback {
  public:
-  explicit ReadCallback(uint64_t size) :
+  explicit ReadCallback(size_t size) :
       read_size_(0) {
     buffer_size_ = size;
     buffer_ = new uint8_t[buffer_size_];
@@ -60,10 +60,10 @@
     int64_t total_read = 0;
     int64_t ret = 0;
     do {
-      ret = stream->read(buffer_ + read_size_, buffer_size_ - read_size_);
+      ret = stream->read(buffer_ + read_size_, gsl::narrow<int>(buffer_size_ - read_size_));
       if (ret == 0) break;
       if (ret < 0) return ret;
-      read_size_ += ret;
+      read_size_ += gsl::narrow<size_t>(ret);
       total_read += ret;
     } while (buffer_size_ != read_size_);
     return total_read;
@@ -77,7 +77,7 @@
     struct archive_entry *ae;
 
     REQUIRE(archive_read_next_header(a, &ae) == ARCHIVE_OK);
-    int size = archive_entry_size(ae);
+    int size = gsl::narrow<int>(archive_entry_size(ae));
     archive_buffer_ = new char[size];
     archive_buffer_size_ = size;
     archive_read_data(a, archive_buffer_, size);
@@ -85,8 +85,8 @@
   }
 
   uint8_t *buffer_;
-  uint64_t buffer_size_;
-  uint64_t read_size_;
+  size_t buffer_size_;
+  size_t read_size_;
   char *archive_buffer_;
   int archive_buffer_size_;
 };
@@ -267,7 +267,7 @@
     std::string mime;
     flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime);
     REQUIRE(mime == "application/gzip");
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     callback.archive_read();
     std::string content(reinterpret_cast<char *> (callback.archive_buffer_), callback.archive_buffer_size_);
@@ -310,7 +310,7 @@
     REQUIRE(flow1->getSize() != flow->getSize());
     std::string mime;
     REQUIRE(flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime) == false);
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::string content(reinterpret_cast<char *> (callback.buffer_), callback.read_size_);
     REQUIRE(testController.getRawContent() == content);
@@ -351,7 +351,7 @@
     std::string mime;
     flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime);
     REQUIRE(mime == "application/bzip2");
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     callback.archive_read();
     std::string contents(reinterpret_cast<char *> (callback.archive_buffer_), callback.archive_buffer_size_);
@@ -395,7 +395,7 @@
     REQUIRE(flow1->getSize() != flow->getSize());
     std::string mime;
     REQUIRE(flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime) == false);
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::string contents(reinterpret_cast<char *> (callback.buffer_), callback.read_size_);
     REQUIRE(testController.getRawContent() == contents);
@@ -442,7 +442,7 @@
     std::string mime;
     flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime);
     REQUIRE(mime == "application/x-lzma");
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     callback.archive_read();
     std::string contents(reinterpret_cast<char *> (callback.archive_buffer_), callback.archive_buffer_size_);
@@ -493,7 +493,7 @@
     REQUIRE(flow1->getSize() != flow->getSize());
     std::string mime;
     REQUIRE(flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime) == false);
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::string contents(reinterpret_cast<char *> (callback.buffer_), callback.read_size_);
     REQUIRE(testController.getRawContent() == contents);
@@ -540,7 +540,7 @@
     std::string mime;
     flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime);
     REQUIRE(mime == "application/x-xz");
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     callback.archive_read();
     std::string contents(reinterpret_cast<char *> (callback.archive_buffer_), callback.archive_buffer_size_);
@@ -591,7 +591,7 @@
     REQUIRE(flow1->getSize() != flow->getSize());
     std::string mime;
     REQUIRE(flow1->getAttribute(FlowAttributeKey(org::apache::nifi::minifi::MIME_TYPE), mime) == false);
-    ReadCallback callback(flow1->getSize());
+    ReadCallback callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::string contents(reinterpret_cast<char *> (callback.buffer_), callback.read_size_);
     REQUIRE(testController.getRawContent() == contents);
diff --git a/libminifi/test/archive-tests/FocusArchiveTests.cpp b/libminifi/test/archive-tests/FocusArchiveTests.cpp
index 898132a..6e15d43 100644
--- a/libminifi/test/archive-tests/FocusArchiveTests.cpp
+++ b/libminifi/test/archive-tests/FocusArchiveTests.cpp
@@ -112,11 +112,10 @@
 
     std::ifstream ifs(utils::file::FileUtils::concat_path(dir2, FOCUSED_FILE), std::ios::in | std::ios::binary | std::ios::ate);
 
-    std::ifstream::pos_type size = ifs.tellg();
-    int64_t bufsize {size};
+    size_t size = gsl::narrow<size_t>(ifs.tellg());
     ifs.seekg(0, std::ios::beg);
-    char *content = new char[bufsize];
-    ifs.read(content, bufsize);
+    char *content = new char[size];
+    ifs.read(content, size);
 
     REQUIRE(size == strlen(FOCUSED_CONTENT));
     REQUIRE(memcmp(content, FOCUSED_CONTENT, size) == 0);
diff --git a/libminifi/test/archive-tests/MergeFileTests.cpp b/libminifi/test/archive-tests/MergeFileTests.cpp
index dd6e204..b9f55f4 100644
--- a/libminifi/test/archive-tests/MergeFileTests.cpp
+++ b/libminifi/test/archive-tests/MergeFileTests.cpp
@@ -122,7 +122,7 @@
   struct archive_entry *ae;
 
   while (archive_read_next_header(a, &ae) == ARCHIVE_OK) {
-    int size = archive_entry_size(ae);
+    int size = gsl::narrow<int>(archive_entry_size(ae));
     FixedBuffer buf(size);
     ArchiveEntryReader reader(a);
     auto ret = buf.write(reader, buf.capacity());
@@ -266,7 +266,7 @@
   std::shared_ptr<core::FlowFile> flow2 = output->poll(expiredFlowRecords);
   REQUIRE(flow1->getSize() == 96);
   {
-    FixedBuffer callback(flow1->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::ifstream file1(EXPECT_MERGE_CONTENT_FIRST, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file1)), std::istreambuf_iterator<char>());
@@ -274,7 +274,7 @@
   }
   REQUIRE(flow2->getSize() == 96);
   {
-    FixedBuffer callback(flow2->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow2->getSize()));
     sessionGenFlowFile.read(flow2, &callback);
     std::ifstream file2(EXPECT_MERGE_CONTENT_SECOND, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file2)), std::istreambuf_iterator<char>());
@@ -372,7 +372,7 @@
   std::shared_ptr<core::FlowFile> flow2 = output->poll(expiredFlowRecords);
   REQUIRE(flow1->getSize() == 128);
   {
-    FixedBuffer callback(flow1->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::ifstream file1(EXPECT_MERGE_CONTENT_FIRST, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file1)), std::istreambuf_iterator<char>());
@@ -380,7 +380,7 @@
   }
   REQUIRE(flow2->getSize() == 128);
   {
-    FixedBuffer callback(flow2->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow2->getSize()));
     sessionGenFlowFile.read(flow2, &callback);
     std::ifstream file2(EXPECT_MERGE_CONTENT_SECOND, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file2)), std::istreambuf_iterator<char>());
@@ -472,7 +472,7 @@
   std::shared_ptr<core::FlowFile> flow2 = output->poll(expiredFlowRecords);
   REQUIRE(flow1->getSize() == 96);
   {
-    FixedBuffer callback(flow1->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::ifstream file1(EXPECT_MERGE_CONTENT_FIRST, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file1)), std::istreambuf_iterator<char>());
@@ -480,7 +480,7 @@
   }
   REQUIRE(flow2->getSize() == 64);
   {
-    FixedBuffer callback(flow2->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow2->getSize()));
     sessionGenFlowFile.read(flow2, &callback);
     std::ifstream file2(EXPECT_MERGE_CONTENT_SECOND, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file2)), std::istreambuf_iterator<char>());
@@ -553,7 +553,7 @@
   std::shared_ptr<core::FlowFile> flow2 = output->poll(expiredFlowRecords);
   REQUIRE(flow1->getSize() == 96);
   {
-    FixedBuffer callback(flow1->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     std::ifstream file1(EXPECT_MERGE_CONTENT_FIRST, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file1)), std::istreambuf_iterator<char>());
@@ -561,7 +561,7 @@
   }
   REQUIRE(flow2->getSize() == 96);
   {
-    FixedBuffer callback(flow2->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow2->getSize()));
     sessionGenFlowFile.read(flow2, &callback);
     std::ifstream file2(EXPECT_MERGE_CONTENT_SECOND, std::ios::binary);
     std::string contents((std::istreambuf_iterator<char>(file2)), std::istreambuf_iterator<char>());
@@ -635,7 +635,7 @@
   std::shared_ptr<core::FlowFile> flow2 = output->poll(expiredFlowRecords);
   REQUIRE(flow1->getSize() > 0);
   {
-    FixedBuffer callback(flow1->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     auto archives = read_archives(callback);
     REQUIRE(archives.size() == 3);
@@ -648,7 +648,7 @@
   }
   REQUIRE(flow2->getSize() > 0);
   {
-    FixedBuffer callback(flow2->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow2->getSize()));
     sessionGenFlowFile.read(flow2, &callback);
     auto archives = read_archives(callback);
     REQUIRE(archives.size() == 3);
@@ -726,7 +726,7 @@
   std::shared_ptr<core::FlowFile> flow2 = output->poll(expiredFlowRecords);
   REQUIRE(flow1->getSize() > 0);
   {
-    FixedBuffer callback(flow1->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow1->getSize()));
     sessionGenFlowFile.read(flow1, &callback);
     auto archives = read_archives(callback);
     REQUIRE(archives.size() == 3);
@@ -739,7 +739,7 @@
   }
   REQUIRE(flow2->getSize() > 0);
   {
-    FixedBuffer callback(flow2->getSize());
+    FixedBuffer callback(gsl::narrow<size_t>(flow2->getSize()));
     sessionGenFlowFile.read(flow2, &callback);
     auto archives = read_archives(callback);
     REQUIRE(archives.size() == 3);
diff --git a/libminifi/test/archive-tests/util/ArchiveTests.cpp b/libminifi/test/archive-tests/util/ArchiveTests.cpp
index d3080c8..5f94cf9 100644
--- a/libminifi/test/archive-tests/util/ArchiveTests.cpp
+++ b/libminifi/test/archive-tests/util/ArchiveTests.cpp
@@ -131,7 +131,7 @@
     } else {
       read_names.push_back(name);
       TestArchiveEntry test_entry = it->second;
-      size_t size = archive_entry_size(entry);
+      size_t size = gsl::narrow<size_t>(archive_entry_size(entry));
 
       std::cout << "Checking archive entry: " << name << std::endl;
 
diff --git a/libminifi/test/keyvalue-tests/PersistableKeyValueStoreServiceTest.cpp b/libminifi/test/keyvalue-tests/PersistableKeyValueStoreServiceTest.cpp
index 6f8cd7b..9a42a3e 100644
--- a/libminifi/test/keyvalue-tests/PersistableKeyValueStoreServiceTest.cpp
+++ b/libminifi/test/keyvalue-tests/PersistableKeyValueStoreServiceTest.cpp
@@ -71,8 +71,11 @@
     char format[] = "/var/tmp/state.XXXXXX";
     state_dir = testController.createTempDirectory(format);
     REQUIRE(false == state_dir.empty());
+#ifdef WIN32
+    REQUIRE(0 == _chdir(state_dir.c_str()));
+#else
     REQUIRE(0 == chdir(state_dir.c_str()));
-
+#endif
     loadYaml();
   }
 
diff --git a/libminifi/test/rocksdb-tests/DBProvenanceRepositoryTests.cpp b/libminifi/test/rocksdb-tests/DBProvenanceRepositoryTests.cpp
index 66b1604..8e29c5e 100644
--- a/libminifi/test/rocksdb-tests/DBProvenanceRepositoryTests.cpp
+++ b/libminifi/test/rocksdb-tests/DBProvenanceRepositoryTests.cpp
@@ -39,7 +39,7 @@
 }
 
 void provisionRepo(minifi::provenance::ProvenanceRepository& repo, size_t number_of_records, size_t record_size) {
-  for (int i = 0; i < number_of_records; ++i) {
+  for (size_t i = 0; i < number_of_records; ++i) {
     std::vector<char> v(record_size);
     generateData(v);
     REQUIRE(repo.Put(std::to_string(i), reinterpret_cast<const uint8_t*>(v.data()), v.size()));
@@ -76,7 +76,7 @@
 
   REQUIRE(provdb.initialize(configuration));
 
-  uint64_t keyCount = 500;
+  size_t keyCount = 500;
 
   provisionRepo(provdb, keyCount, 10240);
 
@@ -99,7 +99,7 @@
 
   REQUIRE(provdb.initialize(configuration));
 
-  uint64_t keyCount = 500;
+  size_t keyCount = 500;
 
   provisionRepo(provdb, keyCount / 2, 102400);
 
diff --git a/libminifi/test/unit/FileStreamTests.cpp b/libminifi/test/unit/FileStreamTests.cpp
index 5c1c2dc..f7c9b2b 100644
--- a/libminifi/test/unit/FileStreamTests.cpp
+++ b/libminifi/test/unit/FileStreamTests.cpp
@@ -15,6 +15,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#include <cstdio>
 #include <iostream>
 #include <string>
 #include <vector>
@@ -57,7 +59,7 @@
 
   REQUIRE(std::string(reinterpret_cast<char*>(data), verifybuffer.size()) == "tempfile");
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 }
 
 TEST_CASE("TestFileBadArgumentNoChange", "[TestLoader]") {
@@ -95,7 +97,7 @@
 
   REQUIRE(std::string(reinterpret_cast<char*>(data), verifybuffer.size()) == "tempFile");
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 }
 
 TEST_CASE("TestFileBadArgumentNoChange2", "[TestLoader]") {
@@ -133,7 +135,7 @@
 
   REQUIRE(std::string(reinterpret_cast<char*>(data), verifybuffer.size()) == "tempFile");
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 }
 
 TEST_CASE("TestFileBadArgumentNoChange3", "[TestLoader]") {
@@ -171,7 +173,7 @@
 
   REQUIRE(std::string(reinterpret_cast<char*>(data), verifybuffer.size()) == "");
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 }
 
 TEST_CASE("TestFileBeyondEnd3", "[TestLoader]") {
@@ -205,7 +207,7 @@
 
   REQUIRE(std::string(reinterpret_cast<char*>(data), verifybuffer.size()) == "tempFile");
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 }
 
 TEST_CASE("TestFileExceedSize", "[TestLoader]") {
@@ -240,5 +242,5 @@
     REQUIRE(stream.readData(verifybuffer, 8192) == 8192);
   REQUIRE(stream.readData(verifybuffer, 8192) == 0);
 
-  unlink(ss.str().c_str());
+  std::remove(ss.str().c_str());
 }
diff --git a/libminifi/test/unit/SerializationTests.cpp b/libminifi/test/unit/SerializationTests.cpp
index 7749087..029cde4 100644
--- a/libminifi/test/unit/SerializationTests.cpp
+++ b/libminifi/test/unit/SerializationTests.cpp
@@ -70,3 +70,19 @@
   REQUIRE(verifyString == stringOne);
 }
 
+TEST_CASE("Serialization test: the byteSwap functions work correctly", "[byteSwap]") {
+    REQUIRE(byteSwap(uint16_t{0}) == uint16_t{0});
+    REQUIRE(byteSwap(uint16_t{0x0001}) == uint16_t{0x0100});
+    REQUIRE(byteSwap(uint16_t{0x0102}) == uint16_t{0x0201});
+    REQUIRE(byteSwap(uint16_t{0xFFEE}) == uint16_t{0xEEFF});
+
+    REQUIRE(byteSwap(uint32_t{0}) == uint32_t{0});
+    REQUIRE(byteSwap(uint32_t{0x00000001}) == uint32_t{0x01000000});
+    REQUIRE(byteSwap(uint32_t{0x01020304}) == uint32_t{0x04030201});
+    REQUIRE(byteSwap(uint32_t{0xFFEEDDCC}) == uint32_t{0xCCDDEEFF});
+
+    REQUIRE(byteSwap(uint64_t{0}) == uint64_t{0});
+    REQUIRE(byteSwap(uint64_t{0x0000000000000001}) == uint64_t{0x0100000000000000});
+    REQUIRE(byteSwap(uint64_t{0x0102030405060708}) == uint64_t{0x0807060504030201});
+    REQUIRE(byteSwap(uint64_t{0xFFEEDDCCBBAA9988}) == uint64_t{0x8899AABBCCDDEEFF});
+}
diff --git a/libminifi/test/unit/Site2SiteTests.cpp b/libminifi/test/unit/Site2SiteTests.cpp
index 4862b33..66e0913 100644
--- a/libminifi/test/unit/Site2SiteTests.cpp
+++ b/libminifi/test/unit/Site2SiteTests.cpp
@@ -156,7 +156,7 @@
 TEST_CASE("TestSiteToSiteVerifyNegotiationFail", "[S2S4]") {
   SiteToSiteResponder *collector = new SiteToSiteResponder();
 
-  char a = 0xFF;
+  char a = '\xFF';
   std::string resp_code;
   resp_code.insert(resp_code.begin(), a);
   collector->push_response(resp_code);
diff --git a/nanofi/include/core/cstream.h b/nanofi/include/core/cstream.h
index 5d2c833..0a46a0e 100644
--- a/nanofi/include/core/cstream.h
+++ b/nanofi/include/core/cstream.h
@@ -40,7 +40,7 @@
 
 int write_buffer(const uint8_t *value, int len, cstream * stream);
 
-int writeUTF(const char * cstr, uint64_t len, enum Bool widen, cstream * stream);
+int writeUTF(const char * cstr, size_t length, enum Bool widen, cstream * stream);
 
 int read_char(char *value, cstream * stream);
 
@@ -56,7 +56,7 @@
 
 int readUTFLen(uint32_t * utflen, cstream * stream);
 
-int readUTF(char * buf, uint64_t buflen, cstream * stream);
+int readUTF(char * buf, uint32_t buflen, cstream * stream);
 
 void close_stream(cstream * stream);
 
diff --git a/nanofi/include/core/string_utils.h b/nanofi/include/core/string_utils.h
index f25adf8..c9c85eb 100644
--- a/nanofi/include/core/string_utils.h
+++ b/nanofi/include/core/string_utils.h
@@ -52,7 +52,7 @@
  * @param begin the beginning of the token
  * @param len the length of the token
  */
-void add_token_to_list(token_list * tks, const char * begin, uint64_t len);
+void add_token_to_list(token_list * tks, const char * begin, size_t len);
 
 /**
  * Deallocate one token node
diff --git a/nanofi/include/sitetosite/CSiteToSite.h b/nanofi/include/sitetosite/CSiteToSite.h
index a35b3c5..7b9cab2 100644
--- a/nanofi/include/sitetosite/CSiteToSite.h
+++ b/nanofi/include/sitetosite/CSiteToSite.h
@@ -27,6 +27,7 @@
 
 #ifdef WIN32
 #include <winsock2.h>
+
 #else
 #include <arpa/inet.h>
 #endif
@@ -40,7 +41,7 @@
 extern "C" {
 #endif
 
-#define htonll_r(x) ((((uint64_t)htonl(x)) << 32) + htonl((x) >> 32))
+#define htonll_r(x) ((((uint64_t)htonl((uint32_t)x)) << 32) + htonl((uint32_t)((x) >> 32)))
 
 // Resource Negotiated Status Code
 #define RESOURCE_OK 20
@@ -269,7 +270,7 @@
   //org::apache::nifi::minifi::io::BaseStream* _stream;
   cstream * _stream;
 
-  uint64_t _crc;
+  uLong _crc;
 
   char _uuid_str[37];
 
@@ -367,7 +368,7 @@
 
   int ret;
   if (!widen) {
-    uint16_t shortlen = len;
+    uint16_t shortlen = (uint16_t)len;
     ret = write_uint16t(transaction, shortlen);
   } else {
     ret = write_uint32t(transaction, len);
@@ -380,7 +381,7 @@
   const uint8_t *underlyingPtr = (const uint8_t *)str;
 
   if (!widen) {
-    uint16_t short_length = len;
+    uint16_t short_length = (uint16_t)len;
     ret = writeData(transaction, underlyingPtr, short_length);
   } else {
     ret = writeData(transaction, underlyingPtr, len);
diff --git a/nanofi/src/api/nanofi.cpp b/nanofi/src/api/nanofi.cpp
index f6e40c8..03a6d26 100644
--- a/nanofi/src/api/nanofi.cpp
+++ b/nanofi/src/api/nanofi.cpp
@@ -50,7 +50,7 @@
   NULL_CHECK(fb, path);
   FILE *fileptr;
   uint8_t *buffer;
-  uint64_t filelen;
+  size_t filelen;
 
   fileptr = fopen(path, "rb");
   NULL_CHECK(fb, fileptr);
@@ -321,7 +321,7 @@
         return NULL;
     }
 
-    int ret = fwrite(buff, 1, count, ffp);
+    size_t ret = fwrite(buff, 1, count, ffp);
     if (ret < count) {
         fclose(ffp);
         free_flowfile(ffr);
@@ -419,7 +419,7 @@
   NULL_CHECK(0, ff, target);
   NULL_CHECK(0, ff->attributes, target->attributes);
   auto attribute_map = static_cast<string_map*>(ff->attributes);
-  int i = 0;
+  size_t i = 0;
   for (const auto& kv : *attribute_map) {
     if (i >= target->size) {
       break;
@@ -429,7 +429,7 @@
     target->attributes[i].value_size = kv.second.size();
     ++i;
   }
-  return i;
+  return gsl::narrow<int>(i);
 }
 
 /**
@@ -442,7 +442,7 @@
   NULL_CHECK(-1, ff, key);
   NULL_CHECK(-1, ff->attributes);
   auto attribute_map = static_cast<string_map*>(ff->attributes);
-  return attribute_map->erase(key) - 1;  // erase by key returns the number of elements removed (0 or 1)
+  return gsl::narrow<int8_t>(attribute_map->erase(key)) - 1;  // erase by key returns the number of elements removed (0 or 1)
 }
 
 int get_content(const flow_file_record* ff, uint8_t* target, int size) {
@@ -455,7 +455,7 @@
     return stream->read(target, size);
   } else {
     file_buffer fb = file_to_buffer(ff->contentLocation);
-    size_t copy_size = size < fb.file_len ? size : fb.file_len;
+    size_t copy_size = size < fb.file_len ? size : gsl::narrow<size_t>(fb.file_len);
     memcpy(target, fb.buffer, copy_size*sizeof(uint8_t));
     free(fb.buffer);
     return copy_size;
@@ -499,7 +499,7 @@
     } else {
       file_buffer fb = file_to_buffer(ff->contentLocation);
       stream = std::make_shared<minifi::io::DataStream>();
-      stream->writeData(fb.buffer, fb.file_len);
+      stream->writeData(fb.buffer, gsl::narrow<int>(fb.file_len));
       free(fb.buffer);
     }
   } else {
@@ -703,7 +703,7 @@
     } else {
       ff_data->content_stream = std::make_shared<minifi::io::DataStream>();
       file_buffer fb = file_to_buffer(input_ff->contentLocation);
-      ff_data->content_stream->writeData(fb.buffer, fb.file_len);
+      ff_data->content_stream->writeData(fb.buffer, gsl::narrow<int>(fb.file_len));
       free(fb.buffer);
     }
 
@@ -730,7 +730,7 @@
 
   auto ff_data = std::make_shared<flowfile_input_params>();
   ff_data->content_stream = std::make_shared<minifi::io::DataStream>();
-  ff_data->content_stream->writeData(buf, size);
+  ff_data->content_stream->writeData(buf, gsl::narrow<int>(size));
 
   plan->runNextProcessor(nullptr, ff_data);
   while (plan->runNextProcessor()) {
diff --git a/nanofi/src/core/cstream.c b/nanofi/src/core/cstream.c
index 5468273..4664f72 100644
--- a/nanofi/src/core/cstream.c
+++ b/nanofi/src/core/cstream.c
@@ -19,6 +19,7 @@
 #ifdef _WIN32
 #define NOMINMAX
 #include <winsock2.h>
+#include <ws2tcpip.h>
 #else
 #include <sys/socket.h>  // socket
 #include <arpa/inet.h> // inet_addr
@@ -90,14 +91,15 @@
   return total_read;
 }
 
-int writeUTF(const char * cstr, uint64_t len, enum Bool widen, cstream * stream) {
-  if (len > 65535) {
+int writeUTF(const char * cstr, size_t length, enum Bool widen, cstream * stream) {
+  if (length > 65535) {
     return -1;
   }
+  int len = (int) length;
 
   int ret;
   if (!widen) {
-    uint16_t shortlen = len;
+    uint16_t shortlen = (uint16_t) len;
     ret = write_uint16_t(shortlen, stream);
   } else {
     ret = write_uint32_t(len, stream);
@@ -108,14 +110,7 @@
   }
 
   const uint8_t *underlyingPtr = (const uint8_t *)cstr;
-
-  if (!widen) {
-    uint16_t short_length = len;
-    ret = write_buffer(underlyingPtr, short_length, stream);
-  } else {
-    ret = write_buffer(underlyingPtr, len, stream);
-  }
-  return ret;
+  return write_buffer(underlyingPtr, len, stream);
 }
 
 int read_uint8_t(uint8_t *value, cstream * stream) {
@@ -153,9 +148,9 @@
   return ret;
 }
 
-int readUTF(char * buf, uint64_t buflen, cstream * stream) {
+int readUTF(char * buf, uint32_t buflen, cstream * stream) {
   //return stream->impl->readData((uint8_t*)buf, buflen);
-  return read_buffer((uint8_t*)buf, buflen, stream);
+  return read_buffer((uint8_t*)buf, (int) buflen, stream);
 }
 
 void close_stream(cstream * stream) {
@@ -212,7 +207,11 @@
       break;
     }
 
+#ifdef WIN32
+    closesocket(sock);
+#else
     close(sock);
+#endif
   }
 
   freeaddrinfo(result);
diff --git a/nanofi/src/core/cuuid.c b/nanofi/src/core/cuuid.c
index fa38966..c58e86c 100644
--- a/nanofi/src/core/cuuid.c
+++ b/nanofi/src/core/cuuid.c
@@ -21,6 +21,7 @@
 #include "uuid.h"
 #endif
 
+#include <stdio.h>
 #include "core/cuuid.h"
 
 #ifdef WIN32
diff --git a/nanofi/src/core/string_utils.c b/nanofi/src/core/string_utils.c
index b513b30..c0e2f61 100644
--- a/nanofi/src/core/string_utils.c
+++ b/nanofi/src/core/string_utils.c
@@ -29,7 +29,7 @@
     return 0;
 }
 
-void add_token_to_list(struct token_list * tk_list, const char * begin, uint64_t len) {
+void add_token_to_list(struct token_list * tk_list, const char * begin, size_t len) {
     struct token_node * new_node = (struct token_node *)malloc(sizeof(struct token_node));
     new_node->data = (char *)malloc((len+1) * sizeof(char));
     strncpy(new_node->data, begin, len);
@@ -137,14 +137,14 @@
             tks.total_bytes++;
             continue;
         }
-        int len = end - begin;
+        size_t len = end - begin;
         add_token_to_list(&tks, begin, len);
         tks.total_bytes++;
         begin = (end+1);
     }
 
     if (begin && *begin != '\0') {
-        int len = strlen(begin);
+        size_t len = strlen(begin);
         if (len < MAX_BYTES_READ) {
             tks.has_non_delimited_token = 1;
         }
diff --git a/nanofi/src/sitetosite/CRawSocketProtocol.c b/nanofi/src/sitetosite/CRawSocketProtocol.c
index 7c50086..4874cc7 100644
--- a/nanofi/src/sitetosite/CRawSocketProtocol.c
+++ b/nanofi/src/sitetosite/CRawSocketProtocol.c
@@ -697,7 +697,7 @@
       return -1;
     }
 
-    int i;
+    size_t i;
     for (i = 0; i < packet->_attributes->size; ++i) {
       const char *key = packet->_attributes->attributes[i].key;
 
@@ -717,25 +717,24 @@
 
     uint64_t len = 0;
 
-    uint64_t content_size = 0;
-
     if(ff != NULL) {
-      content_size = ff->size;
+      int content_size = (int) ff->size;
 
       uint8_t * content_buf = NULL;
 
       if(content_size > 0 && ff->crp != NULL) {
         content_buf = (uint8_t*)malloc(content_size*sizeof(uint8_t));
-        len = get_content(ff, content_buf, content_size);
-        if(len <= 0) {
+        int len_as_int = get_content(ff, content_buf, content_size);
+        if (len_as_int <= 0) {
           return -2;
         }
+        len = len_as_int;
         ret = write_uint64t(transaction, len);
         if (ret != 8) {
           logc(debug, "ret != 8");
           return -1;
         }
-        writeData(transaction, content_buf, len);
+        writeData(transaction, content_buf, len_as_int);
       }
 
     } else if (packet->payload_ != NULL && strlen(packet->payload_) > 0) {
@@ -746,7 +745,7 @@
         return -1;
       }
 
-      ret = writeData(transaction, (uint8_t *)(packet->payload_), len);
+      ret = writeData(transaction, (uint8_t *)(packet->payload_), (int) len);
       if (ret != (int64_t)len) {
         logc(debug, "ret != len");
         return -1;