diff --git a/include/tins/crypto.h b/include/tins/crypto.h
index 94d703d..f047ac0 100644
--- a/include/tins/crypto.h
+++ b/include/tins/crypto.h
@@ -387,8 +387,9 @@ namespace Crypto {
     
     template<typename ForwardIterator>
     RC4Key::RC4Key(ForwardIterator start, ForwardIterator end) {
-        for(size_t i = 0; i < data_size; ++i)
-            data[i] = i;
+        for(size_t i = 0; i < data_size; ++i) {
+            data[i] = static_cast<uint8_t>(i);
+        }
         size_t j = 0;
         ForwardIterator iter = start;
         for(size_t i = 0; i < data_size; ++i) {
diff --git a/include/tins/dhcpv6.h b/include/tins/dhcpv6.h
index b7c8ee0..027b9b6 100644
--- a/include/tins/dhcpv6.h
+++ b/include/tins/dhcpv6.h
@@ -891,7 +891,7 @@ void class_option_data2option(InputIterator start, InputIterator end,
     uint16_t uint16_t_buffer;
     while(start != end) {
         buffer.resize(buffer.size() + sizeof(uint16_t) + start->size());
-        uint16_t_buffer = Endian::host_to_be<uint16_t>(start->size());
+        uint16_t_buffer = Endian::host_to_be(static_cast<uint16_t>(start->size()));
         std::memcpy(&buffer[index], &uint16_t_buffer, sizeof(uint16_t));
         index += sizeof(uint16_t);
         std::copy(start->begin(), start->end(), buffer.begin() + index);
diff --git a/include/tins/dot11/dot11_control.h b/include/tins/dot11/dot11_control.h
index b8ac050..5e11068 100644
--- a/include/tins/dot11/dot11_control.h
+++ b/include/tins/dot11/dot11_control.h
@@ -144,7 +144,9 @@ protected:
     /**
      * \brief Getter for the control ta additional fields size.
      */
-    uint32_t controlta_size() const { return _taddr.size() + sizeof(ieee80211_header); }
+    uint32_t controlta_size() const { 
+        return static_cast<uint32_t>(_taddr.size() + sizeof(ieee80211_header)); 
+    }
 
     uint32_t write_ext_header(uint8_t *buffer, uint32_t total_sz);
 private:
diff --git a/include/tins/dot11/dot11_data.h b/include/tins/dot11/dot11_data.h
index ef5f013..68ad45c 100644
--- a/include/tins/dot11/dot11_data.h
+++ b/include/tins/dot11/dot11_data.h
@@ -246,8 +246,10 @@ protected:
     uint32_t write_ext_header(uint8_t *buffer, uint32_t total_sz);
 
     uint32_t data_frame_size() { 
-        return Dot11::header_size() + sizeof(_ext_header) + 
-            ((from_ds() && to_ds()) ? _addr4.size() : 0); 
+        return static_cast<uint32_t>(
+            Dot11::header_size() + sizeof(_ext_header) + 
+                ((from_ds() && to_ds()) ? _addr4.size() : 0)
+        ); 
     }
 private:
     ExtendedHeader _ext_header;
diff --git a/include/tins/exceptions.h b/include/tins/exceptions.h
index 163e056..46230ce 100644
--- a/include/tins/exceptions.h
+++ b/include/tins/exceptions.h
@@ -180,6 +180,17 @@ public:
     }
 };
 
+/**
+ * \brief Exception thrown when a payload is too large to fit
+ * into a PDUOption.
+ */
+class option_payload_too_large : public std::exception {
+public:
+    const char *what() const throw() {
+        return "Option payload too large";
+    }
+};
+
 } // Tins
 
 #endif // TINS_EXCEPTIONS_H
diff --git a/include/tins/pdu_option.h b/include/tins/pdu_option.h
index 752da27..b71a479 100644
--- a/include/tins/pdu_option.h
+++ b/include/tins/pdu_option.h
@@ -312,7 +312,7 @@ public:
      * \param data The option's data(if any).
      */
     PDUOption(option_type opt = option_type(), size_t length = 0, const data_type *data = 0) 
-    : option_(opt), size_(length) {
+    : option_(opt), size_(static_cast<uint16_t>(length)) {
         set_payload_contents(data, data + (data ? length : 0));
     }
     
@@ -397,7 +397,7 @@ public:
      */
     template<typename ForwardIterator>
     PDUOption(option_type opt, ForwardIterator start, ForwardIterator end) 
-    : option_(opt), size_(std::distance(start, end)) {
+    : option_(opt), size_(static_cast<uint16_t>(std::distance(start, end))) {
         set_payload_contents(start, end);
     }
     
@@ -417,7 +417,7 @@ public:
      * \param end The end of the option data.
      */
     template<typename ForwardIterator>
-    PDUOption(option_type opt, size_t length, ForwardIterator start, ForwardIterator end) 
+    PDUOption(option_type opt, uint16_t length, ForwardIterator start, ForwardIterator end) 
     : option_(opt), size_(length) {
         set_payload_contents(start, end);
     }
@@ -492,7 +492,11 @@ public:
 private:
     template<typename ForwardIterator>
     void set_payload_contents(ForwardIterator start, ForwardIterator end) {
-        real_size_ = std::distance(start, end);
+        size_t total_size = std::distance(start, end);
+        if (total_size > std::numeric_limits<uint16_t>::max()) {
+            throw option_payload_too_large();
+        }
+        real_size_ = static_cast<uint16_t>(total_size);
         if(real_size_ <= small_buffer_size) {
             std::copy(
                 start,
diff --git a/include/tins/pppoe.h b/include/tins/pppoe.h
index 296bcd8..9cad0d6 100644
--- a/include/tins/pppoe.h
+++ b/include/tins/pppoe.h
@@ -240,7 +240,7 @@ public:
          * \param option The option to be added.
          */
         void add_tag(tag &&option) {
-            _tags_size += option.data_size() + sizeof(uint16_t) * 2;
+            _tags_size += static_cast<uint16_t>(option.data_size() + sizeof(uint16_t) * 2);
             _tags.push_back(std::move(option));
         }
     #endif
diff --git a/include/tins/rawpdu.h b/include/tins/rawpdu.h
index 3404b64..77a05a9 100644
--- a/include/tins/rawpdu.h
+++ b/include/tins/rawpdu.h
@@ -157,7 +157,7 @@ namespace Tins {
          * \return uint32_t containing the payload size.
          */
         uint32_t payload_size() const {
-            return _payload.size();
+            return static_cast<uint32_t>(_payload.size());
         }
 
         /**
@@ -184,7 +184,7 @@ namespace Tins {
          */
         template<typename T>
         T to() const {
-            return T(&_payload[0], _payload.size());
+            return T(&_payload[0], static_cast<uint32_t>(_payload.size()));
         }
         
         /**
diff --git a/src/bootp.cpp b/src/bootp.cpp
index c814953..6b5510d 100644
--- a/src/bootp.cpp
+++ b/src/bootp.cpp
@@ -52,7 +52,7 @@ BootP::BootP(const uint8_t *buffer, uint32_t total_sz, uint32_t vend_field_size)
 }
 
 uint32_t BootP::header_size() const {
-    return sizeof(bootphdr) + _vend.size();
+    return static_cast<uint32_t>(sizeof(bootphdr) + _vend.size());
 }
 
 void BootP::opcode(uint8_t new_opcode) {
diff --git a/src/crypto.cpp b/src/crypto.cpp
index 459bfc2..86e024d 100644
--- a/src/crypto.cpp
+++ b/src/crypto.cpp
@@ -96,7 +96,8 @@ PDU *WEPDecrypter::decrypt(RawPDU &raw, const std::string &password) {
     // Generate the key
     RC4Key key(key_buffer.begin(), key_buffer.begin() + password.size() + 3);
     rc4(pload.begin() + 4, pload.end(), key, pload.begin());
-    uint32_t crc = Utils::crc32(&pload[0], pload.size() - 8);
+    uint32_t payload_size = static_cast<uint32_t>(pload.size() - 8);
+    uint32_t crc = Utils::crc32(&pload[0], payload_size);
     if(pload[pload.size() - 8] != (crc & 0xff) ||
         pload[pload.size() - 7] != ((crc >> 8) & 0xff) ||
         pload[pload.size() - 6] != ((crc >> 16) & 0xff) ||
@@ -104,7 +105,7 @@ PDU *WEPDecrypter::decrypt(RawPDU &raw, const std::string &password) {
         return 0;
     
     try {
-        return new SNAP(&pload[0], pload.size() - 8);
+        return new SNAP(&pload[0], payload_size);
     }
     catch(std::runtime_error&) {
         return 0;
diff --git a/src/dhcp.cpp b/src/dhcp.cpp
index 2914143..9fc0dd6 100644
--- a/src/dhcp.cpp
+++ b/src/dhcp.cpp
@@ -51,7 +51,7 @@ DHCP::DHCP(const uint8_t *buffer, uint32_t total_sz)
 : BootP(buffer, total_sz, 0), _size(sizeof(uint32_t))
 {
     buffer += BootP::header_size() - vend().size();
-    total_sz -= BootP::header_size() - vend().size();
+    total_sz -= static_cast<uint32_t>(BootP::header_size() - vend().size());
     uint8_t args[2] = {0};
     uint32_t uint32_t_buffer;
     std::memcpy(&uint32_t_buffer, buffer, sizeof(uint32_t));
@@ -86,7 +86,7 @@ void DHCP::add_option(const option &opt) {
 }
 
 void DHCP::internal_add_option(const option &opt) {
-    _size += opt.data_size() + (sizeof(uint8_t) << 1);
+    _size += static_cast<uint32_t>(opt.data_size() + (sizeof(uint8_t) << 1));
 }
 
 const DHCP::option *DHCP::search_option(OptionTypes opt) const {
@@ -216,7 +216,7 @@ PDU::serialization_type DHCP::serialize_list(const std::vector<ipaddress_type> &
 }
 
 uint32_t DHCP::header_size() const {
-    return BootP::header_size() - vend().size() + _size;
+    return static_cast<uint32_t>(BootP::header_size() - vend().size() + _size);
 }
 
 void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
@@ -231,7 +231,7 @@ void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
         *((uint32_t*)&result[0]) = Endian::host_to_be<uint32_t>(0x63825363);
         for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
             *(ptr++) = it->option();
-            *(ptr++) = it->length_field();
+            *(ptr++) = static_cast<uint8_t>(it->length_field());
             std::copy(it->data_ptr(), it->data_ptr() + it->data_size(), ptr);
             ptr += it->data_size();
         }
diff --git a/src/dhcpv6.cpp b/src/dhcpv6.cpp
index e45d7ac..eb947b5 100644
--- a/src/dhcpv6.cpp
+++ b/src/dhcpv6.cpp
@@ -95,7 +95,7 @@ const DHCPv6::option *DHCPv6::search_option(OptionTypes id) const {
 uint8_t* DHCPv6::write_option(const option &opt, uint8_t* buffer) const {
     uint16_t uint16_t_buffer = Endian::host_to_be(opt.option());
     std::memcpy(buffer, &uint16_t_buffer, sizeof(uint16_t));
-    uint16_t_buffer = Endian::host_to_be<uint16_t>(opt.length_field());
+    uint16_t_buffer = Endian::host_to_be(static_cast<uint16_t>(opt.length_field()));
     std::memcpy(&buffer[sizeof(uint16_t)], &uint16_t_buffer, sizeof(uint16_t));
     return std::copy(
         opt.data_ptr(), 
@@ -632,7 +632,7 @@ DHCPv6::vendor_class_type DHCPv6::vendor_class_type::from_option(const option &o
     output.enterprise_number = Endian::be_to_host(output.enterprise_number);
     output.vendor_class_data = Internals::option2class_option_data<data_type>(
         opt.data_ptr() + sizeof(uint32_t),
-        opt.data_size() - sizeof(uint32_t)
+        static_cast<uint32_t>(opt.data_size() - sizeof(uint32_t))
     );
     
     return output;
@@ -660,7 +660,7 @@ DHCPv6::user_class_type DHCPv6::user_class_type::from_option(const option &opt)
         throw malformed_option();
     user_class_type output;
     output.data = Internals::option2class_option_data<data_type>(
-        opt.data_ptr(), opt.data_size()
+        opt.data_ptr(), static_cast<uint32_t>(opt.data_size())
     );
     return output;
 }
diff --git a/src/dns.cpp b/src/dns.cpp
index 3c830da..849ed84 100644
--- a/src/dns.cpp
+++ b/src/dns.cpp
@@ -72,9 +72,13 @@ DNS::DNS(const uint8_t *buffer, uint32_t total_sz)
                 throw malformed_packet();
             buffer += sizeof(uint16_t) * 2;
         }
-        answers_idx = buffer - prev_start;
-        authority_idx = find_section_end(&records_data[0] + answers_idx, answers_count()) - &records_data[0];
-        additional_idx = find_section_end(&records_data[0] + authority_idx, authority_count()) - &records_data[0];
+        answers_idx = static_cast<uint32_t>(buffer - prev_start);
+        authority_idx = static_cast<uint32_t>(
+            find_section_end(&records_data[0] + answers_idx, answers_count()) - &records_data[0]
+        );
+        additional_idx = static_cast<uint32_t>(
+            find_section_end(&records_data[0] + authority_idx, authority_count()) - &records_data[0]
+        );
     }
 }
 
@@ -118,7 +122,7 @@ const uint8_t *DNS::find_section_end(const uint8_t *ptr, const uint32_t num_reco
 }
 
 uint32_t DNS::header_size() const {
-    return sizeof(dns) + records_data.size();
+    return static_cast<uint32_t>(sizeof(dns) + records_data.size());
 }
 
 void DNS::id(uint16_t new_id) {
@@ -180,7 +184,7 @@ void DNS::add_query(const Query &query) {
     uint16_t_buffer = Endian::host_to_be<uint16_t>(query.query_class());
     std::memcpy(&new_str[new_str.size() - 2], &uint16_t_buffer, sizeof(uint16_t));
 
-    uint32_t offset = new_str.size(), threshold = answers_idx;
+    uint32_t offset = static_cast<uint32_t>(new_str.size()), threshold = answers_idx;
     update_records(answers_idx, answers_count(), threshold, offset);
     update_records(authority_idx, authority_count(), threshold, offset);
     update_records(additional_idx, additional_count(), threshold, offset);
@@ -189,9 +193,7 @@ void DNS::add_query(const Query &query) {
         new_str.begin(),
         new_str.end()
     );
-    dns.questions = Endian::host_to_be<uint16_t>(
-        questions_count() + 1
-    );
+    dns.questions = Endian::host_to_be(static_cast<uint16_t>(questions_count() + 1));
 }
 
 void DNS::add_answer(const Resource &resource) {
@@ -211,7 +213,7 @@ void DNS::add_record(const Resource &resource, const sections_type &sections) {
     IPv6Address v6_addr;
     std::string buffer = encode_domain_name(resource.dname()), encoded_data;
     // By default the data size is the length of the data field.
-    uint32_t data_size = resource.data().size();
+    size_t data_size = resource.data().size();
     if(resource.type() == A) {
         v4_addr = resource.data();
         data_size = 4;
@@ -224,14 +226,15 @@ void DNS::add_record(const Resource &resource, const sections_type &sections) {
         encoded_data = encode_domain_name(resource.data());
         data_size = encoded_data.size();
     }
-    uint32_t offset = buffer.size() + sizeof(uint16_t) * 3 + sizeof(uint32_t) + data_size, 
+    size_t offset = buffer.size() + sizeof(uint16_t) * 3 + sizeof(uint32_t) + data_size, 
             threshold = sections.empty() ? records_data.size() : *sections.front().first;
     // Skip the preference field
     if(resource.type() == MX) {
         offset += sizeof(uint16_t);
     }
     for(size_t i = 0; i < sections.size(); ++i) {
-        update_records(*sections[i].first, sections[i].second, threshold, offset);
+        update_records(*sections[i].first, sections[i].second, 
+            static_cast<uint32_t>(threshold), static_cast<uint32_t>(offset));
     }
     
     records_data.insert(
@@ -257,8 +260,8 @@ void DNS::add_record(const Resource &resource, const sections_type &sections) {
     uint32_t_buffer = Endian::host_to_be(resource.ttl());
     std::memcpy(ptr, &uint32_t_buffer, sizeof(uint32_t));
     ptr += sizeof(uint32_t);
-    uint16_t_buffer = Endian::host_to_be<uint16_t>(
-        data_size + (resource.type() == MX ? 2 : 0)
+    uint16_t_buffer = Endian::host_to_be(
+        static_cast<uint16_t>(data_size + (resource.type() == MX ? 2 : 0))
     );
     std::memcpy(ptr, &uint16_t_buffer, sizeof(uint16_t));
     ptr += sizeof(uint16_t);
@@ -301,11 +304,11 @@ std::string DNS::encode_domain_name(const std::string &dn) {
     size_t last_index(0), index;
     if(!dn.empty()) {
         while((index = dn.find('.', last_index+1)) != string::npos) {
-            output.push_back(index - last_index);
+            output.push_back(static_cast<char>(index - last_index));
             output.append(dn.begin() + last_index, dn.begin() + index);
             last_index = index + 1; //skip dot
         }
-        output.push_back(dn.size() - last_index);
+        output.push_back(static_cast<char>(dn.size() - last_index));
         output.append(dn.begin() + last_index, dn.end());
     }
     output.push_back('\0');
diff --git a/src/dot11/dot11_base.cpp b/src/dot11/dot11_base.cpp
index 3de49de..e5f11af 100644
--- a/src/dot11/dot11_base.cpp
+++ b/src/dot11/dot11_base.cpp
@@ -103,7 +103,7 @@ void Dot11::add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t *val)
 }
 
 void Dot11::internal_add_option(const option &opt) {
-    _options_size += opt.data_size() + sizeof(uint8_t) * 2;
+    _options_size += static_cast<uint32_t>(opt.data_size() + sizeof(uint8_t) * 2);
 }
 
 void Dot11::add_option(const option &opt) {
@@ -212,7 +212,7 @@ void Dot11::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *p
     #endif
     for(std::list<option>::const_iterator it = _options.begin(); it != _options.end(); ++it) {
         *(buffer++) = it->option();
-        *(buffer++) = it->length_field();
+        *(buffer++) = static_cast<uint8_t>(it->length_field());
         std::copy(it->data_ptr(), it->data_ptr() + it->data_size(), buffer);
         buffer += it->data_size();
     }
diff --git a/src/dot11/dot11_data.cpp b/src/dot11/dot11_data.cpp
index 7be7981..e18138b 100644
--- a/src/dot11/dot11_data.cpp
+++ b/src/dot11/dot11_data.cpp
@@ -74,9 +74,9 @@ uint32_t Dot11Data::init(const uint8_t *buffer, uint32_t total_sz) {
             throw malformed_packet();
         _addr4 = buffer;
         buffer += _addr4.size();
-        total_sz -= _addr4.size();
+        total_sz -= static_cast<uint32_t>(_addr4.size());
     }
-    return buffer - start_ptr;
+    return static_cast<uint32_t>(buffer - start_ptr);
 }
 
 Dot11Data::Dot11Data(const address_type &dst_hw_addr, 
@@ -128,7 +128,7 @@ uint32_t Dot11Data::write_ext_header(uint8_t *buffer, uint32_t total_sz) {
     memcpy(buffer, &_ext_header, sizeof(_ext_header));
     buffer += sizeof(_ext_header);
     if (from_ds() && to_ds()) {
-        written += _addr4.size();
+        written += static_cast<uint32_t>(_addr4.size());
         _addr4.copy(buffer);
     }
     return written;
diff --git a/src/dot11/dot11_mgmt.cpp b/src/dot11/dot11_mgmt.cpp
index 8a34e26..9ebf1b8 100644
--- a/src/dot11/dot11_mgmt.cpp
+++ b/src/dot11/dot11_mgmt.cpp
@@ -109,12 +109,12 @@ uint32_t Dot11ManagementFrame::write_ext_header(uint8_t *buffer, uint32_t total_
 }
 
 void Dot11ManagementFrame::ssid(const std::string &new_ssid) {
-    add_tagged_option(Dot11::SSID, new_ssid.size(), (const uint8_t*)new_ssid.c_str());
+    add_tagged_option(Dot11::SSID, static_cast<uint8_t>(new_ssid.size()), (const uint8_t*)new_ssid.c_str());
 }
 
 void Dot11ManagementFrame::rsn_information(const RSNInformation& info) {
     RSNInformation::serialization_type buffer = info.serialize();
-    add_tagged_option(RSN, buffer.size(), &buffer[0]);
+    add_tagged_option(RSN, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
 uint8_t *Dot11ManagementFrame::serialize_rates(const rates_type &rates) {
@@ -139,13 +139,13 @@ Dot11ManagementFrame::rates_type Dot11ManagementFrame::deserialize_rates(const o
 
 void Dot11ManagementFrame::supported_rates(const rates_type &new_rates) {
     uint8_t *buffer = serialize_rates(new_rates);
-    add_tagged_option(SUPPORTED_RATES, new_rates.size(), buffer);
+    add_tagged_option(SUPPORTED_RATES, static_cast<uint8_t>(new_rates.size()), buffer);
     delete[] buffer;
 }
 
 void Dot11ManagementFrame::extended_supported_rates(const rates_type &new_rates) {
     uint8_t *buffer = serialize_rates(new_rates);
-    add_tagged_option(EXT_SUPPORTED_RATES, new_rates.size(), buffer);
+    add_tagged_option(EXT_SUPPORTED_RATES, static_cast<uint8_t>(new_rates.size()), buffer);
     delete[] buffer;
 }
 
@@ -167,7 +167,7 @@ void Dot11ManagementFrame::supported_channels(const channels_type &new_channels)
         *(ptr++) = it->first;
         *(ptr++) = it->second;
     }
-    add_tagged_option(SUPPORTED_CHANNELS, buffer.size(), &buffer[0]);
+    add_tagged_option(SUPPORTED_CHANNELS, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
 void Dot11ManagementFrame::edca_parameter_set(uint32_t ac_be, uint32_t ac_bk, uint32_t ac_vi, uint32_t ac_vo) {
@@ -183,7 +183,7 @@ void Dot11ManagementFrame::edca_parameter_set(uint32_t ac_be, uint32_t ac_bk, ui
 }
 
 void Dot11ManagementFrame::request_information(const request_info_type elements) {
-    add_tagged_option(REQUEST_INFORMATION, elements.size(), &elements[0]);
+    add_tagged_option(REQUEST_INFORMATION, static_cast<uint8_t>(elements.size()), &elements[0]);
 }
 
 void Dot11ManagementFrame::fh_parameter_set(const fh_params_set &fh_params) {
@@ -218,9 +218,10 @@ void Dot11ManagementFrame::ibss_parameter_set(uint16_t atim_window) {
 }
 
 void Dot11ManagementFrame::ibss_dfs(const ibss_dfs_params &params) {
-    uint8_t sz = address_type::address_size + sizeof(uint8_t) + sizeof(uint8_t) * 2 * params.channel_map.size();
-    uint8_t* buffer = new uint8_t[sz];
-    uint8_t* ptr_buffer = buffer;
+    const size_t sz = address_type::address_size + sizeof(uint8_t) + 
+                        sizeof(uint8_t) * 2 * params.channel_map.size();
+    std::vector<uint8_t> buffer(sz);
+    uint8_t* ptr_buffer = &buffer[0];
 
     ptr_buffer = params.dfs_owner.copy(ptr_buffer);
     *(ptr_buffer++) = params.recovery_interval;
@@ -229,9 +230,7 @@ void Dot11ManagementFrame::ibss_dfs(const ibss_dfs_params &params) {
         *(ptr_buffer++) = it->second;
     }
 
-    add_tagged_option(IBSS_DFS, sz, buffer);
-
-    delete[] buffer;
+    add_tagged_option(IBSS_DFS, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
 void Dot11ManagementFrame::country(const country_params &params) {
@@ -251,7 +250,7 @@ void Dot11ManagementFrame::country(const country_params &params) {
         *(ptr++) = params.number_channels[i];
         *(ptr++) = params.max_transmit_power[i];
     }
-    add_tagged_option(COUNTRY, sz, &buffer[0]);
+    add_tagged_option(COUNTRY, static_cast<uint8_t>(sz), &buffer[0]);
 }
 
 void Dot11ManagementFrame::fh_parameters(uint8_t prime_radix, uint8_t number_channels) {
@@ -271,7 +270,7 @@ void Dot11ManagementFrame::fh_pattern_table(const fh_pattern_type &params) {
     byte_array::const_iterator it(params.random_table.begin());
     for(; it != params.random_table.end(); ++it)
         *(ptr++) = *it;
-    add_tagged_option(HOPPING_PATTERN_TABLE, data.size(), &data[0]);
+    add_tagged_option(HOPPING_PATTERN_TABLE, static_cast<uint8_t>(data.size()), &data[0]);
 }
 
 void Dot11ManagementFrame::power_constraint(uint8_t local_power_constraint) {
@@ -296,7 +295,6 @@ void Dot11ManagementFrame::quiet(const quiet_type &data) {
     ptr_buffer[0] = Endian::host_to_le(data.quiet_duration);
     ptr_buffer[1] = Endian::host_to_le(data.quiet_offset);
     add_tagged_option(QUIET, sizeof(buffer), buffer);
-
 }
 
 void Dot11ManagementFrame::tpc_report(uint8_t transmit_power, uint8_t link_margin) {
@@ -346,13 +344,13 @@ void Dot11ManagementFrame::tim(const tim_type &data) {
         data.partial_virtual_bitmap.end(),
         &buffer[3]
     );
-    add_tagged_option(TIM, buffer.size(), &buffer[0]);
+    add_tagged_option(TIM, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
 void Dot11ManagementFrame::challenge_text(const std::string &text) {
     add_tagged_option(
         CHALLENGE_TEXT, 
-        text.size(),
+        static_cast<uint8_t>(text.size()),
         (const uint8_t*)text.c_str()
     );
 }
@@ -364,7 +362,7 @@ void Dot11ManagementFrame::vendor_specific(const vendor_specific_type &data) {
         data.data.end(),
         data.oui.copy(buffer.begin())
     );
-    add_tagged_option(VENDOR_SPECIFIC, buffer.size(), &buffer[0]);
+    add_tagged_option(VENDOR_SPECIFIC, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
 // Getters
@@ -475,7 +473,8 @@ Dot11ManagementFrame::vendor_specific_type Dot11ManagementFrame::vendor_specific
     const Dot11::option *option = search_option(VENDOR_SPECIFIC);
     if(!option || option->data_size() < 3)
         throw option_not_found();
-    return vendor_specific_type::from_bytes(option->data_ptr(), option->data_size());
+    return vendor_specific_type::from_bytes(option->data_ptr(), 
+        static_cast<uint32_t>(option->data_size()));
 }
 
 Dot11ManagementFrame::vendor_specific_type 
diff --git a/src/dot3.cpp b/src/dot3.cpp
index 36f54e5..07a3ca4 100644
--- a/src/dot3.cpp
+++ b/src/dot3.cpp
@@ -130,7 +130,7 @@ void Dot3::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
     #ifdef TINS_DEBUG
     assert(total_sz >= header_size());
     #endif
-    _eth.length = Endian::host_to_be<uint16_t>(size() - sizeof(_eth));
+    _eth.length = Endian::host_to_be(static_cast<uint16_t>(size() - sizeof(_eth)));
 
     memcpy(buffer, &_eth, sizeof(ethhdr));
 }
diff --git a/src/eapol.cpp b/src/eapol.cpp
index 7c4b7a0..340989a 100644
--- a/src/eapol.cpp
+++ b/src/eapol.cpp
@@ -150,15 +150,16 @@ void RC4EAPOL::key(const key_type &new_key) {
 }
 
 uint32_t RC4EAPOL::header_size() const {
-    return sizeof(eapolhdr) + sizeof(_header) + _key.size();
+    return static_cast<uint32_t>(sizeof(eapolhdr) + sizeof(_header) + _key.size());
 }
 
 void RC4EAPOL::write_body(uint8_t *buffer, uint32_t total_sz) {
     #ifdef TINS_DEBUG
     assert(total_sz >= sizeof(_header) + _key.size());
     #endif
-    if(_key.size())
-        _header.key_length = Endian::host_to_be(_key.size());
+    if(_key.size()) {
+        _header.key_length = Endian::host_to_be(static_cast<uint16_t>(_key.size()));
+    }
     std::memcpy(buffer, &_header, sizeof(_header));
     buffer += sizeof(_header);
     std::copy(_key.begin(), _key.end(), buffer);
@@ -265,7 +266,7 @@ void RSNEAPOL::key_ack(small_uint<1> new_key_ack) {
 }
 
 uint32_t RSNEAPOL::header_size() const {
-    return sizeof(eapolhdr) + sizeof(_header) + _key.size();
+    return static_cast<uint32_t>(sizeof(eapolhdr) + sizeof(_header) + _key.size());
 }
 
 void RSNEAPOL::write_body(uint8_t *buffer, uint32_t total_sz) {
@@ -275,10 +276,10 @@ void RSNEAPOL::write_body(uint8_t *buffer, uint32_t total_sz) {
     if(_key.size()) {
         if(!_header.key_t) {
             _header.key_length = Endian::host_to_be<uint16_t>(32);
-            wpa_length(_key.size());
+            wpa_length(static_cast<uint16_t>(_key.size()));
         }
         else if(_key.size()) {
-            wpa_length(_key.size());
+            wpa_length(static_cast<uint16_t>(_key.size()));
         }
     }
     std::memcpy(buffer, &_header, sizeof(_header));
diff --git a/src/icmpv6.cpp b/src/icmpv6.cpp
index 149ffe2..beacc7b 100644
--- a/src/icmpv6.cpp
+++ b/src/icmpv6.cpp
@@ -260,12 +260,12 @@ void ICMPv6::add_option(const option &option) {
 }
 
 void ICMPv6::internal_add_option(const option &option) {
-    _options_size += option.data_size() + sizeof(uint8_t) * 2;
+    _options_size += static_cast<uint32_t>(option.data_size() + sizeof(uint8_t) * 2);
 }
 
 uint8_t *ICMPv6::write_option(const option &opt, uint8_t *buffer) {
     *buffer++ = opt.option();
-    *buffer++ = (opt.length_field() + sizeof(uint8_t) * 2) / 8;
+    *buffer++ = static_cast<uint8_t>((opt.length_field() + sizeof(uint8_t) * 2) / 8);
     return std::copy(opt.data_ptr(), opt.data_ptr() + opt.data_size(), buffer);
 }
 
@@ -379,7 +379,7 @@ void ICMPv6::add_addr_list(uint8_t type, const addr_list_type &value) {
 }
 
 void ICMPv6::rsa_signature(const rsa_sign_type &value) {
-    uint32_t total_sz =  4 + sizeof(value.key_hash) + value.signature.size();
+    uint32_t total_sz = static_cast<uint32_t>(4 + sizeof(value.key_hash) + value.signature.size());
     uint8_t padding = 8 - total_sz % 8;
     if(padding == 8)
         padding = 0;
@@ -492,7 +492,7 @@ void ICMPv6::handover_key_request(const handover_key_req_type &value) {
 }
 
 void ICMPv6::handover_key_reply(const handover_key_reply_type &value) {
-    const uint32_t data_size = value.key.size() + 2 + sizeof(uint16_t);
+    const uint32_t data_size = static_cast<uint32_t>(value.key.size() + 2 + sizeof(uint16_t));
     uint8_t padding = 8 - (data_size+2) % 8;
     if(padding == 8)
         padding = 0;
@@ -511,7 +511,7 @@ void ICMPv6::handover_key_reply(const handover_key_reply_type &value) {
 }
 
 void ICMPv6::handover_assist_info(const handover_assist_info_type &value) {
-    const uint32_t data_size = value.hai.size() + 2;
+    const uint32_t data_size = static_cast<uint32_t>(value.hai.size() + 2);
     uint8_t padding = 8 - (data_size+2) % 8;
     if(padding == 8)
         padding = 0;
@@ -528,7 +528,7 @@ void ICMPv6::handover_assist_info(const handover_assist_info_type &value) {
 }
 
 void ICMPv6::mobile_node_identifier(const mobile_node_id_type &value) {
-    const uint32_t data_size = value.mn.size() + 2;
+    const uint32_t data_size = static_cast<uint32_t>(value.mn.size() + 2);
     uint8_t padding = 8 - (data_size+2) % 8;
     if(padding == 8)
         padding = 0;
@@ -555,7 +555,7 @@ void ICMPv6::dns_search_list(const dns_search_list_type &value) {
         do {
             index = it->find('.', prev);
             std::string::const_iterator end = (index == std::string::npos) ? it->end() : (it->begin() + index);
-            buffer.push_back(end - (it->begin() + prev));
+            buffer.push_back(static_cast<uint8_t>(end - (it->begin() + prev)));
             buffer.insert(buffer.end(), it->begin() + prev, end);
             prev = index + 1;
         } while(index != std::string::npos);
diff --git a/src/ip.cpp b/src/ip.cpp
index dc377b9..aa4369e 100644
--- a/src/ip.cpp
+++ b/src/ip.cpp
@@ -101,7 +101,7 @@ IP::IP(const uint8_t *buffer, uint32_t total_sz)
                 _ip_options.push_back(option(opt_type));
             
             ptr_buffer += _ip_options.back().data_size() + 1;
-            _options_size += _ip_options.back().data_size() + 2;
+            _options_size += static_cast<uint16_t>(_ip_options.back().data_size() + 2);
         }
         else {
             _ip_options.push_back(option(opt_type));
@@ -298,7 +298,7 @@ void IP::add_option(const option &opt) {
 }
 
 void IP::internal_add_option(const option &opt) {
-    _options_size += 1 + opt.data_size();
+    _options_size += static_cast<uint16_t>(1 + opt.data_size());
     uint8_t padding = _options_size % 4;
     _padded_options_size = padding ? (_options_size - padding + 4) : _options_size;
 }
@@ -317,7 +317,7 @@ uint8_t* IP::write_option(const option &opt, uint8_t* buffer) {
     if(*buffer <= 1)
         return ++buffer;
     buffer++;
-    *buffer = opt.length_field();
+    *buffer = static_cast<uint8_t>(opt.length_field());
     if(opt.data_size() == opt.length_field())
         *buffer += 2;
     buffer++;
@@ -394,7 +394,7 @@ void IP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU* pare
             total_sz = Endian::host_to_be<uint16_t>(total_sz);
     #endif
     tot_len(total_sz);
-    head_len(my_sz / sizeof(uint32_t));
+    head_len(static_cast<uint8_t>(my_sz / sizeof(uint32_t)));
 
     memcpy(buffer, &_ip, sizeof(_ip));
 
diff --git a/src/ip_reassembler.cpp b/src/ip_reassembler.cpp
index dc0c663..ec481a8 100644
--- a/src/ip_reassembler.cpp
+++ b/src/ip_reassembler.cpp
@@ -72,13 +72,13 @@ PDU *IPv4Stream::allocate_pdu() const {
     for(fragments_type::const_iterator it = fragments.begin(); it != fragments.end(); ++it) {
         if(expected != it->offset())
             return 0;
-        expected = it->offset() + it->payload().size();
+        expected = static_cast<uint16_t>(it->offset() + it->payload().size());
         buffer.insert(buffer.end(), it->payload().begin(), it->payload().end());
     }
     return Internals::pdu_from_flag(
         static_cast<Constants::IP::e>(transport_proto),
         buffer.empty() ? 0 : &buffer[0],
-        buffer.size()
+        static_cast<uint32_t>(buffer.size())
     );
 }
 
diff --git a/src/ipsec.cpp b/src/ipsec.cpp
index 1747e70..f0ff1ac 100644
--- a/src/ipsec.cpp
+++ b/src/ipsec.cpp
@@ -83,7 +83,7 @@ void IPSecAH::icv(const byte_array &new_icv) {
 }
 
 uint32_t IPSecAH::header_size() const {
-    return sizeof(_header) + _icv.size();
+    return static_cast<uint32_t>(sizeof(_header) + _icv.size());
 }
 
 void IPSecAH::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
diff --git a/src/ipv6.cpp b/src/ipv6.cpp
index bcf02a5..6ff1dbc 100644
--- a/src/ipv6.cpp
+++ b/src/ipv6.cpp
@@ -203,7 +203,7 @@ void IPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
         }
         set_last_next_header(new_flag);
     }
-    payload_length(total_sz - sizeof(_header));
+    payload_length(static_cast<uint16_t>(total_sz - sizeof(_header)));
     std::memcpy(buffer, &_header, sizeof(_header));
     buffer += sizeof(_header);
     for(headers_type::const_iterator it = ext_headers.begin(); it != ext_headers.end(); ++it) {
@@ -227,7 +227,7 @@ void IPv6::send(PacketSender &sender, const NetworkInterface &) {
 
 void IPv6::add_ext_header(const ext_header &header) {
     ext_headers.push_back(header);
-    headers_size += header.data_size() + sizeof(uint8_t) * 2;
+    headers_size += static_cast<uint32_t>(header.data_size() + sizeof(uint8_t) * 2);
 }
 
 const IPv6::ext_header *IPv6::search_header(ExtensionHeader id) const {
@@ -251,7 +251,7 @@ void IPv6::set_last_next_header(uint8_t value) {
 
 uint8_t *IPv6::write_header(const ext_header &header, uint8_t *buffer) {
     *buffer++ = header.option();
-    *buffer++ = (header.length_field() > 8) ? (header.length_field() - 8) : 0;
+    *buffer++ = static_cast<uint8_t>((header.length_field() > 8) ? (header.length_field() - 8) : 0);
     return std::copy(header.data_ptr(), header.data_ptr() + header.data_size(), buffer);
 }
 
diff --git a/src/llc.cpp b/src/llc.cpp
index 1f07abd..fc1efbf 100644
--- a/src/llc.cpp
+++ b/src/llc.cpp
@@ -190,7 +190,7 @@ void LLC::add_xid_information(uint8_t xid_id, uint8_t llc_type_class, uint8_t re
     xid[0] = xid_id;
     xid[1] = llc_type_class;
     xid[2] = receive_window;
-	information_field_length += xid.size();
+	information_field_length += static_cast<uint8_t>(xid.size());
     information_fields.push_back(xid);
 }
 
diff --git a/src/offline_packet_filter.cpp b/src/offline_packet_filter.cpp
index bcf689f..3681d54 100644
--- a/src/offline_packet_filter.cpp
+++ b/src/offline_packet_filter.cpp
@@ -76,7 +76,7 @@ bool OfflinePacketFilter::matches_filter(const uint8_t* buffer,
 bool OfflinePacketFilter::matches_filter(PDU& pdu) const
 {
     PDU::serialization_type buffer = pdu.serialize();
-    return matches_filter(&buffer[0], buffer.size());
+    return matches_filter(&buffer[0], static_cast<uint32_t>(buffer.size()));
 }
 
 } // Tins
diff --git a/src/packet_sender.cpp b/src/packet_sender.cpp
index 4704f2b..c1f53af 100644
--- a/src/packet_sender.cpp
+++ b/src/packet_sender.cpp
@@ -74,10 +74,14 @@ const int PacketSender::INVALID_RAW_SOCKET = -1;
 const uint32_t PacketSender::DEFAULT_TIMEOUT = 2;
 
 #ifndef _WIN32
+    typedef int socket_type;
+    
     const char *make_error_string() {
         return strerror(errno);
     }
 #else
+    typedef SOCKET socket_type;
+
     // fixme
     const char *make_error_string() {
         return "error";
@@ -226,7 +230,7 @@ void PacketSender::open_l3_socket(SocketType type) {
     if(socktype == -1)
         throw invalid_socket_type();
     if(_sockets[type] == INVALID_RAW_SOCKET) {
-        int sockfd;
+        socket_type sockfd;
         sockfd = socket((type == IPV6_SOCKET) ? AF_INET6 : AF_INET, SOCK_RAW, socktype);
         if (sockfd < 0)
             throw socket_open_error(make_error_string());
@@ -239,7 +243,7 @@ void PacketSender::open_l3_socket(SocketType type) {
         #endif
         setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL,(option_ptr)&on,sizeof(on));
 
-        _sockets[type] = sockfd;
+        _sockets[type] = static_cast<int>(sockfd);
     }
 }
 
@@ -314,7 +318,7 @@ void PacketSender::send_l2(PDU &pdu, struct sockaddr* link_addr,
     #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
         open_l2_socket(iface);
         pcap_t* handle = pcap_handles[iface];
-        if (pcap_sendpacket(handle, (u_char*)&buffer[0], buffer.size()) != 0) {
+        if (pcap_sendpacket(handle, (u_char*)&buffer[0], static_cast<int>(buffer.size())) != 0) {
             throw runtime_error("Failed to send packet: " + string(pcap_geterr(handle)));
         }
     #else // HAVE_PACKET_SENDER_PCAP_SENDPACKET
@@ -359,7 +363,7 @@ void PacketSender::send_l3(PDU &pdu, struct sockaddr* link_addr, uint32_t len_ad
     open_l3_socket(type);
     int sock = _sockets[type];
     PDU::serialization_type buffer = pdu.serialize();
-    if(sendto(sock, (const char*)&buffer[0], buffer.size(), 0, link_addr, len_addr) == -1)
+    if(sendto(sock, (const char*)&buffer[0], static_cast<int>(buffer.size()), 0, link_addr, len_addr) == -1)
         throw socket_write_error(make_error_string());
 }
 
diff --git a/src/pdu.cpp b/src/pdu.cpp
index 46eba49..338393e 100644
--- a/src/pdu.cpp
+++ b/src/pdu.cpp
@@ -95,7 +95,7 @@ PDU *PDU::release_inner_pdu() {
 
 PDU::serialization_type PDU::serialize() {
     std::vector<uint8_t> buffer(size());
-    serialize(&buffer[0], buffer.size(), 0);
+    serialize(&buffer[0], static_cast<uint32_t>(buffer.size()), 0);
     
     // Copy elision, do your magic
     return buffer;
diff --git a/src/ppi.cpp b/src/ppi.cpp
index 6ead03a..e752e0c 100644
--- a/src/ppi.cpp
+++ b/src/ppi.cpp
@@ -57,7 +57,7 @@ PPI::PPI(const uint8_t *buffer, uint32_t total_sz) {
     if(options_length > 0) {
         _data.assign(buffer, buffer + options_length);
         buffer += options_length;
-        total_sz -= options_length;
+        total_sz -= static_cast<uint32_t>(options_length);
     }
     if(total_sz > 0) {
         switch(dlt()) {
@@ -92,7 +92,7 @@ PPI::PPI(const uint8_t *buffer, uint32_t total_sz) {
 }
 
 uint32_t PPI::header_size() const {
-    return sizeof(_header) + _data.size();
+    return static_cast<uint32_t>(sizeof(_header) + _data.size());
 }
 
 void PPI::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
diff --git a/src/pppoe.cpp b/src/pppoe.cpp
index 7733c5b..563134e 100644
--- a/src/pppoe.cpp
+++ b/src/pppoe.cpp
@@ -132,7 +132,7 @@ void PPPoE::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *)
     for(tags_type::const_iterator it = _tags.begin(); it != _tags.end(); ++it) {
         uint16_t_buffer = it->option();
         std::memcpy(buffer, &uint16_t_buffer, sizeof(uint16_t));
-        uint16_t_buffer = Endian::host_to_be<uint16_t>(it->length_field());
+        uint16_t_buffer = Endian::host_to_be(static_cast<uint16_t>(it->length_field()));
         std::memcpy(buffer + sizeof(uint16_t), &uint16_t_buffer, sizeof(uint16_t));
         std::copy(
             it->data_ptr(), 
@@ -144,7 +144,7 @@ void PPPoE::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *)
 }
 
 void PPPoE::add_tag(const tag &option) {
-    _tags_size += option.data_size() + sizeof(uint16_t) * 2;
+    _tags_size += static_cast<uint16_t>(option.data_size() + sizeof(uint16_t) * 2);
     _tags.push_back(option);
 }
 
diff --git a/src/radiotap.cpp b/src/radiotap.cpp
index 800c605..c402527 100644
--- a/src/radiotap.cpp
+++ b/src/radiotap.cpp
@@ -194,7 +194,7 @@ uint32_t RadioTap::find_extra_flag_fields_size(const uint8_t* buffer, uint32_t t
         ++ptr;
     }
 
-    return (const uint8_t*)ptr - buffer;
+    return static_cast<uint32_t>((const uint8_t*)ptr - buffer);
 }
 
 // Setter for RadioTap fields
diff --git a/src/rawpdu.cpp b/src/rawpdu.cpp
index 3d4e85b..e24bc44 100644
--- a/src/rawpdu.cpp
+++ b/src/rawpdu.cpp
@@ -47,7 +47,7 @@ RawPDU::RawPDU(const std::string &data)
 }
 
 uint32_t RawPDU::header_size() const {
-    return _payload.size();
+    return static_cast<uint32_t>(_payload.size());
 }
 
 void RawPDU::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
diff --git a/src/rsn_information.cpp b/src/rsn_information.cpp
index 80c0770..6e86a3e 100644
--- a/src/rsn_information.cpp
+++ b/src/rsn_information.cpp
@@ -48,7 +48,7 @@ RSNInformation::RSNInformation() : _version(1), _capabilities(0) {
 }
 
 RSNInformation::RSNInformation(const serialization_type &buffer) {
-    init(&buffer[0], buffer.size());
+    init(&buffer[0], static_cast<uint32_t>(buffer.size()));
 }
 
 RSNInformation::RSNInformation(const uint8_t *buffer, uint32_t total_sz) {
@@ -124,12 +124,12 @@ void RSNInformation::capabilities(uint16_t cap) {
 }
 
 RSNInformation::serialization_type RSNInformation::serialize() const {
-    uint32_t size = sizeof(_version) + sizeof(_capabilities) + sizeof(uint32_t);
+    size_t size = sizeof(_version) + sizeof(_capabilities) + sizeof(uint32_t);
     size += (sizeof(uint16_t) << 1); // 2 lists count.
     size += sizeof(uint32_t) * (_akm_cyphers.size() + _pairwise_cyphers.size());
 
-    uint16_t pairwise_cyphers_size = _pairwise_cyphers.size();
-    uint16_t akm_cyphers_size = _akm_cyphers.size();
+    const size_t pairwise_cyphers_size = _pairwise_cyphers.size();
+    const size_t akm_cyphers_size = _akm_cyphers.size();
     uint16_t capabilities = Endian::host_to_le(_capabilities);
     uint16_t version = Endian::host_to_le(_version);
     
@@ -167,7 +167,7 @@ RSNInformation RSNInformation::wpa2_psk() {
 RSNInformation RSNInformation::from_option(const PDUOption<uint8_t, Dot11> &opt) {
     if(opt.data_size() < sizeof(uint16_t) * 2 + sizeof(uint32_t))
         throw malformed_option();
-    return RSNInformation(opt.data_ptr(), opt.data_size());
+    return RSNInformation(opt.data_ptr(), static_cast<uint32_t>(opt.data_size()));
 }
 }
 
diff --git a/src/tcp.cpp b/src/tcp.cpp
index d3a50a9..ab0fa92 100644
--- a/src/tcp.cpp
+++ b/src/tcp.cpp
@@ -59,7 +59,7 @@ TCP::TCP(const uint8_t *buffer, uint32_t total_sz)
     if(data_offset() * sizeof(uint32_t) > total_sz || data_offset() * sizeof(uint32_t) < sizeof(tcphdr)) 
         throw malformed_packet();
     const uint8_t *header_end = buffer + (data_offset() * sizeof(uint32_t));
-    total_sz = total_sz - (header_end - buffer);
+    total_sz = static_cast<uint32_t>(total_sz - (header_end - buffer));
     buffer += sizeof(tcphdr);
     
     _total_options_size = 0;
@@ -338,7 +338,7 @@ uint8_t *TCP::write_option(const option &opt, uint8_t *buffer) {
     }
     else {
         buffer[0] = opt.option();
-        buffer[1] = opt.length_field();
+        buffer[1] = static_cast<uint8_t>(opt.length_field());
         // only add the identifier and size field sizes if the length
         // field hasn't been spoofed.
         if(opt.length_field() == opt.data_size())
@@ -355,7 +355,7 @@ void TCP::internal_add_option(const option &opt) {
     if(opt.data_size() || opt.option() == SACK_OK)
         _options_size += sizeof(uint8_t);
         
-    _options_size += opt.data_size();
+    _options_size += static_cast<uint16_t>(opt.data_size());
     
     padding = _options_size & 3;
     _total_options_size = (padding) ? _options_size - padding + 4 : _options_size;
diff --git a/src/udp.cpp b/src/udp.cpp
index e77ba3d..9cd505a 100644
--- a/src/udp.cpp
+++ b/src/udp.cpp
@@ -80,10 +80,12 @@ void UDP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *par
     assert(total_sz >= sizeof(udphdr));
     #endif
     _udp.check = 0;
-    if(inner_pdu())
-        length(sizeof(udphdr) + inner_pdu()->size());
-    else
-        length(sizeof(udphdr));
+    if(inner_pdu()) {
+        length(static_cast<uint16_t>(sizeof(udphdr) + inner_pdu()->size()));
+    }
+    else {
+        length(static_cast<uint16_t>(sizeof(udphdr)));
+    }
     std::memcpy(buffer, &_udp, sizeof(udphdr));
     const Tins::IP *ip_packet = tins_cast<const Tins::IP*>(parent);
     if(ip_packet) {
diff --git a/tests/src/allocators.cpp b/tests/src/allocators.cpp
index 24f3484..18ba6d7 100644
--- a/tests/src/allocators.cpp
+++ b/tests/src/allocators.cpp
@@ -50,7 +50,7 @@ public:
 
     DummyPDU(const uint8_t* data, uint32_t sz) : buffer(data, data + sz) { }
     DummyPDU *clone() const { return new DummyPDU<n>(*this); }
-    uint32_t header_size() const { return buffer.size(); }
+    uint32_t header_size() const { return (uint32_t)buffer.size(); }
     PDUType pdu_type() const { return pdu_flag; }
     void write_serialization(uint8_t *data, uint32_t, const PDU *) 
     { 
@@ -75,22 +75,22 @@ TEST_F(AllocatorsTest, LinkLayerPDUs) {
         link_layer_data_buffer + sizeof(link_layer_data_buffer)
     );
     {
-        EthernetII pkt(&link_layer_data[0], link_layer_data.size());
+        EthernetII pkt(&link_layer_data[0], (uint32_t)link_layer_data.size());
         EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >() != NULL);
         EXPECT_EQ(pkt.serialize(), link_layer_data);
     }
     {
-        SNAP pkt(&link_layer_data[0], link_layer_data.size());
+        SNAP pkt(&link_layer_data[0], (uint32_t)link_layer_data.size());
         EXPECT_TRUE(pkt.find_pdu<DummyPDU<1> >() != NULL);
         EXPECT_EQ(pkt.serialize(), link_layer_data);
     }
     {
-        Dot1Q pkt(&link_layer_data[0], link_layer_data.size());
+        Dot1Q pkt(&link_layer_data[0], (uint32_t)link_layer_data.size());
         EXPECT_TRUE(pkt.find_pdu<DummyPDU<2> >() != NULL);
         EXPECT_EQ(pkt.serialize(), link_layer_data);
     }
     {
-        SLL pkt(&link_layer_data[0], link_layer_data.size());
+        SLL pkt(&link_layer_data[0], (uint32_t)link_layer_data.size());
         EXPECT_TRUE(pkt.find_pdu<DummyPDU<3> >() != NULL);
         EXPECT_EQ(pkt.serialize(), link_layer_data);
     }
@@ -102,7 +102,7 @@ TEST_F(AllocatorsTest, IP) {
         ipv4_data_buffer + sizeof(ipv4_data_buffer)
     );
     Allocators::register_allocator<IP, DummyPDU<0> >(255);
-    EthernetII pkt(&ipv4_data[0], ipv4_data.size());
+    EthernetII pkt(&ipv4_data[0], (uint32_t)ipv4_data.size());
     EXPECT_TRUE(pkt.find_pdu<IP>() != NULL);
     EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >() != NULL);
     EXPECT_EQ(pkt.serialize(), ipv4_data);
@@ -115,7 +115,7 @@ TEST_F(AllocatorsTest, IPv6) {
     );
     Allocators::register_allocator<IPv6, DummyPDU<0> >(250);
     {
-        EthernetII pkt(&ipv6_data[0], ipv6_data.size());
+        EthernetII pkt(&ipv6_data[0], (uint32_t)ipv6_data.size());
         EXPECT_TRUE(pkt.find_pdu<IPv6>() != NULL);
         EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >() != NULL);
         EXPECT_EQ(pkt.serialize(), ipv6_data);
diff --git a/tests/src/arp.cpp b/tests/src/arp.cpp
index d289d1d..6d0f55a 100644
--- a/tests/src/arp.cpp
+++ b/tests/src/arp.cpp
@@ -152,7 +152,7 @@ TEST_F(ARPTest, ConstructorFromBuffer) {
     ARP arp1(expected_packet, sizeof(expected_packet));
     PDU::serialization_type buffer = arp1.serialize();
     
-    ARP arp2(&buffer[0], buffer.size());
+    ARP arp2(&buffer[0], (uint32_t)buffer.size());
     EXPECT_EQ(arp1.opcode(), arp2.opcode());
     ASSERT_EQ(arp1.hw_addr_length(), arp2.hw_addr_length());
     EXPECT_EQ(arp1.hw_addr_format(), arp2.hw_addr_format());
diff --git a/tests/src/dhcp.cpp b/tests/src/dhcp.cpp
index 9043ac0..02a6274 100644
--- a/tests/src/dhcp.cpp
+++ b/tests/src/dhcp.cpp
@@ -301,7 +301,7 @@ TEST_F(DHCPTest, Serialize) {
     ASSERT_EQ(buffer.size(), sizeof(expected_packet));
     EXPECT_TRUE(std::equal(buffer.begin(), buffer.end(), expected_packet));
 
-    DHCP dhcp2(&buffer[0], buffer.size());
+    DHCP dhcp2(&buffer[0], (uint32_t)buffer.size());
     test_equals(dhcp1, dhcp2);
 }
 
diff --git a/tests/src/dhcpv6.cpp b/tests/src/dhcpv6.cpp
index 9984b25..82757d7 100644
--- a/tests/src/dhcpv6.cpp
+++ b/tests/src/dhcpv6.cpp
@@ -283,7 +283,7 @@ TEST_F(DHCPv6Test, Client_Server_ID_DUIDLL) {
     data.lladdress.push_back(209);
     dhcp.client_id(data);
     tmp = dhcp.client_id();
-    output = DHCPv6::duid_ll::from_bytes(&tmp.data[0], tmp.data.size());
+    output = DHCPv6::duid_ll::from_bytes(&tmp.data[0], (uint32_t)tmp.data.size());
     EXPECT_EQ(data.hw_type, output.hw_type);
     EXPECT_EQ(data.lladdress, output.lladdress);
     
@@ -304,7 +304,7 @@ TEST_F(DHCPv6Test, Client_Server_ID_DUIDLLT) {
     data.lladdress.push_back(209);
     dhcp.client_id(data);
     tmp = dhcp.client_id();
-    output = DHCPv6::duid_llt::from_bytes(&tmp.data[0], tmp.data.size());
+    output = DHCPv6::duid_llt::from_bytes(&tmp.data[0], (uint32_t)tmp.data.size());
     EXPECT_EQ(data.hw_type, output.hw_type);
     EXPECT_EQ(data.time, output.time);
     EXPECT_EQ(data.lladdress, output.lladdress);
@@ -325,7 +325,7 @@ TEST_F(DHCPv6Test, Client_Server_ID_DUIDEN) {
     data.identifier.push_back(209);
     dhcp.client_id(data);
     tmp = dhcp.client_id();
-    output = DHCPv6::duid_en::from_bytes(&tmp.data[0], tmp.data.size());
+    output = DHCPv6::duid_en::from_bytes(&tmp.data[0], (uint32_t)tmp.data.size());
     EXPECT_EQ(data.enterprise_number, output.enterprise_number);
     EXPECT_EQ(data.identifier, output.identifier);
     
diff --git a/tests/src/icmp.cpp b/tests/src/icmp.cpp
index e2e5013..1cdacd4 100644
--- a/tests/src/icmp.cpp
+++ b/tests/src/icmp.cpp
@@ -282,7 +282,7 @@ TEST_F(ICMPTest, ConstructorFromBuffer) {
                 break;
         }
         
-        ICMP icmp2(&buffer[0], buffer.size());
+        ICMP icmp2(&buffer[0], (uint32_t)buffer.size());
         test_equals(icmp1, icmp2);
     }
 }
diff --git a/tests/src/ip.cpp b/tests/src/ip.cpp
index 729dba8..8be2243 100644
--- a/tests/src/ip.cpp
+++ b/tests/src/ip.cpp
@@ -662,15 +662,15 @@ TEST_F(IPTest, ConstructorFromBuffer) {
 TEST_F(IPTest, StackedProtocols) {
     IP ip = IP() / TCP();
     IP::serialization_type buffer = ip.serialize();
-    EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<TCP>() != NULL);
+    EXPECT_TRUE(IP(&buffer[0], (uint32_t)buffer.size()).find_pdu<TCP>() != NULL);
     
     ip = IP() / UDP();
     buffer = ip.serialize();
-    EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<UDP>() != NULL);
+    EXPECT_TRUE(IP(&buffer[0], (uint32_t)buffer.size()).find_pdu<UDP>() != NULL);
     
     ip = IP() / ICMP();
     buffer = ip.serialize();
-    EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<ICMP>() != NULL);
+    EXPECT_TRUE(IP(&buffer[0], (uint32_t)buffer.size()).find_pdu<ICMP>() != NULL);
 }
 
 TEST_F(IPTest, SpoofedOptions) {
diff --git a/tests/src/ip_reassembler.cpp b/tests/src/ip_reassembler.cpp
index 61486be..9b41e00 100644
--- a/tests/src/ip_reassembler.cpp
+++ b/tests/src/ip_reassembler.cpp
@@ -45,7 +45,7 @@ const size_t IPv4ReassemblerTest::orderings[][11] = {
 void IPv4ReassemblerTest::test_packets(const std::vector<std::pair<const uint8_t*, size_t> > &vt) {
     IPv4Reassembler reassembler;
     for(size_t i = 0; i < vt.size(); ++i) {
-        EthernetII eth(vt[i].first, vt[i].second);
+        EthernetII eth(vt[i].first, (uint32_t)vt[i].second);
         IPv4Reassembler::packet_status status = reassembler.process(eth);
         EXPECT_NE(IPv4Reassembler::NOT_FRAGMENTED, status);
         if(status == IPv4Reassembler::REASSEMBLED) {
diff --git a/tests/src/ipv6.cpp b/tests/src/ipv6.cpp
index f0ff910..c117d78 100644
--- a/tests/src/ipv6.cpp
+++ b/tests/src/ipv6.cpp
@@ -123,7 +123,7 @@ TEST_F(IPv6Test, Serialize) {
         IPv6::serialization_type(expected_packet1, expected_packet1 + sizeof(expected_packet1)),
         buffer
     );
-    IPv6 ip2(&buffer[0], buffer.size());
+    IPv6 ip2(&buffer[0], (uint32_t)buffer.size());
     test_equals(ip1, ip2);
 }
 
diff --git a/tests/src/pppoe.cpp b/tests/src/pppoe.cpp
index b14e151..a2679cb 100644
--- a/tests/src/pppoe.cpp
+++ b/tests/src/pppoe.cpp
@@ -87,7 +87,7 @@ TEST_F(PPPoETest, ConstructorFromBuffer) {
 TEST_F(PPPoETest, StackedOnEthernet) {
     EthernetII eth = EthernetII() / PPPoE();
     PDU::serialization_type buffer = eth.serialize();
-    EthernetII eth2(&buffer[0], buffer.size());
+    EthernetII eth2(&buffer[0], (uint32_t)buffer.size());
     ASSERT_TRUE(eth2.find_pdu<PPPoE>() != NULL);
 }
 
@@ -95,7 +95,7 @@ TEST_F(PPPoETest, StackedOnEthernetSerializationWithTags) {
     PPPoE pdu(expected_packet, sizeof(expected_packet));
     EthernetII eth = EthernetII() / pdu;
     PDU::serialization_type buffer = eth.serialize();
-    EthernetII eth2(&buffer[0], buffer.size());
+    EthernetII eth2(&buffer[0], (uint32_t)buffer.size());
     PPPoE* unserialized = eth2.find_pdu<PPPoE>();
     ASSERT_TRUE(unserialized != NULL);
     EXPECT_EQ(
diff --git a/tests/src/rsn_eapol.cpp b/tests/src/rsn_eapol.cpp
index 966d4c6..5468fc1 100644
--- a/tests/src/rsn_eapol.cpp
+++ b/tests/src/rsn_eapol.cpp
@@ -168,7 +168,7 @@ TEST_F(RSNEAPOLTest, ConstructionTest) {
     RSNEAPOL::serialization_type buffer = eapol.serialize();
     ASSERT_EQ(sizeof(expected_packet), buffer.size());
     
-    RSNEAPOL eapol2(&buffer[0], buffer.size());
+    RSNEAPOL eapol2(&buffer[0], (uint32_t)buffer.size());
     test_equals(eapol, eapol2);
     
     EXPECT_TRUE(std::equal(buffer.begin(), buffer.end(), expected_packet));
diff --git a/tests/src/snap.cpp b/tests/src/snap.cpp
index 896fd85..2de1e03 100644
--- a/tests/src/snap.cpp
+++ b/tests/src/snap.cpp
@@ -104,7 +104,7 @@ TEST_F(SNAPTest, ConstructorFromBuffer) {
     EXPECT_EQ(0x0800, snap1.eth_type()); 
     EXPECT_EQ(1U, snap1.org_code()); 
     
-    SNAP snap2(&buffer[0], buffer.size());
+    SNAP snap2(&buffer[0], (uint32_t)buffer.size());
     test_equals(snap1, snap2);
 }
 
diff --git a/tests/src/tcp.cpp b/tests/src/tcp.cpp
index f2cf578..3d7d2f0 100644
--- a/tests/src/tcp.cpp
+++ b/tests/src/tcp.cpp
@@ -51,7 +51,7 @@ TEST_F(TCPTest, ChecksumCheck) {
     uint16_t checksum = tcp1.checksum();
     
     PDU::serialization_type buffer = pkt1.serialize();
-    EthernetII pkt2(&buffer[0], buffer.size());
+    EthernetII pkt2(&buffer[0], (uint32_t)buffer.size());
     const TCP &tcp2 = pkt2.rfind_pdu<TCP>();
     EXPECT_EQ(checksum, tcp2.checksum());
     EXPECT_EQ(tcp1.checksum(), tcp2.checksum());
@@ -231,7 +231,7 @@ TEST_F(TCPTest, ConstructorFromBuffer) {
     
     PDU::serialization_type buffer = tcp1.serialize();
     
-    TCP tcp2(&buffer[0], buffer.size());
+    TCP tcp2(&buffer[0], (uint32_t)buffer.size());
     test_equals(tcp1, tcp2);
 }
 
diff --git a/tests/src/udp.cpp b/tests/src/udp.cpp
index 0bdb1d2..649141c 100644
--- a/tests/src/udp.cpp
+++ b/tests/src/udp.cpp
@@ -51,7 +51,7 @@ TEST_F(UDPTest, ChecksumCheck) {
     uint16_t checksum = udp1.checksum();
     
     PDU::serialization_type buffer = pkt1.serialize();
-    EthernetII pkt2(&buffer[0], buffer.size());
+    EthernetII pkt2(&buffer[0], (uint32_t)buffer.size());
     const UDP &udp2 = pkt2.rfind_pdu<UDP>();
     EXPECT_EQ(checksum, udp2.checksum());
     EXPECT_EQ(udp1.checksum(), udp2.checksum());
@@ -141,7 +141,7 @@ TEST_F(UDPTest, ConstructorFromBuffer) {
     EXPECT_EQ(udp1.sport(), 0xf51a);
     EXPECT_EQ(udp1.length(), 8);
     
-    UDP udp2(&buffer[0], buffer.size());
+    UDP udp2(&buffer[0], (uint32_t)buffer.size());
     EXPECT_EQ(udp1.dport(), udp2.dport());
     EXPECT_EQ(udp1.sport(), udp2.sport());
     EXPECT_EQ(udp1.length(), udp2.length());