Fix Mac Breakpad host tools to build in Linux cross-compile

src/common/mac/macho_id.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // macho_id.cc: Functions to gather identifying information from a macho file
 //
 // See macho_id.h for documentation
 //
 // Author: Dan Waylonis
 
-extern "C" {  // necessary for Leopard
-  #include <fcntl.h>
-  #include <mach-o/loader.h>
-  #include <mach-o/swap.h>
-  #include <stdio.h>
-  #include <stdlib.h>
-  #include <string.h>
-  #include <sys/time.h>
-  #include <sys/types.h>
-  #include <unistd.h>
-}
+
+#include <fcntl.h>
+#include <mach-o/loader.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include "common/mac/macho_id.h"
 #include "common/mac/macho_walker.h"
 #include "common/mac/macho_utilities.h"
 
 namespace MacFileUtilities {
 
 using google_breakpad::MD5Init;
 using google_breakpad::MD5Update;
 using google_breakpad::MD5Final;
 
 MachoID::MachoID(const char *path)
    : memory_(0),
      memory_size_(0),
      crc_(0), 
      md5_context_(), 
      update_function_(NULL) {
-  strlcpy(path_, path, sizeof(path_));
+  snprintf(path_, sizeof(path_), "%s", path);
 }
 
 MachoID::MachoID(const char *path, void *memory, size_t size)
    : memory_(memory),
      memory_size_(size),
      crc_(0), 
      md5_context_(), 
      update_function_(NULL) {
-  strlcpy(path_, path, sizeof(path_));
+  snprintf(path_, sizeof(path_), "%s", path);
 }
 
 MachoID::~MachoID() {
 }
 
 // The CRC info is from http://en.wikipedia.org/wiki/Adler-32
 // With optimizations from http://www.zlib.net/
 
 // The largest prime smaller than 65536
 #define MOD_ADLER 65521
@@ skipping 170 matching lines @@
                        bool swap, void *context) {
   MachoID *macho_id = (MachoID *)context;
 
   if (cmd->cmd == LC_SEGMENT) {
     struct segment_command seg;
 
     if (!walker->ReadBytes(&seg, sizeof(seg), offset))
       return false;
 
     if (swap)
-      swap_segment_command(&seg, NXHostByteOrder());
+      breakpad_swap_segment_command(&seg);
 
     struct mach_header_64 header;
     off_t header_offset;
     
     if (!walker->CurrentHeader(&header, &header_offset))
       return false;
         
     // Process segments that have sections:
     // (e.g., __TEXT, __DATA, __IMPORT, __OBJC)
     offset += sizeof(struct segment_command);
     struct section sec;
     for (unsigned long i = 0; i < seg.nsects; ++i) {
       if (!walker->ReadBytes(&sec, sizeof(sec), offset))
         return false;
 
       if (swap)
-        swap_section(&sec, 1, NXHostByteOrder());
+        breakpad_swap_section(&sec, 1);
 
       // sections of type S_ZEROFILL are "virtual" and contain no data
       // in the file itself
       if ((sec.flags & SECTION_TYPE) != S_ZEROFILL && sec.offset != 0)
         macho_id->Update(walker, header_offset + sec.offset, sec.size);
 
       offset += sizeof(struct section);
     }
   } else if (cmd->cmd == LC_SEGMENT_64) {
     struct segment_command_64 seg64;
 
     if (!walker->ReadBytes(&seg64, sizeof(seg64), offset))
       return false;
 
     if (swap)
-      breakpad_swap_segment_command_64(&seg64, NXHostByteOrder());
+      breakpad_swap_segment_command_64(&seg64);
 
     struct mach_header_64 header;
     off_t header_offset;
     
     if (!walker->CurrentHeader(&header, &header_offset))
       return false;
     
     // Process segments that have sections:
     // (e.g., __TEXT, __DATA, __IMPORT, __OBJC)
     offset += sizeof(struct segment_command_64);
     struct section_64 sec64;
     for (unsigned long i = 0; i < seg64.nsects; ++i) {
       if (!walker->ReadBytes(&sec64, sizeof(sec64), offset))
         return false;
 
       if (swap)
-        breakpad_swap_section_64(&sec64, 1, NXHostByteOrder());
+        breakpad_swap_section_64(&sec64, 1);
 
       // sections of type S_ZEROFILL are "virtual" and contain no data
       // in the file itself
       if ((sec64.flags & SECTION_TYPE) != S_ZEROFILL && sec64.offset != 0)
         macho_id->Update(walker, 
                          header_offset + sec64.offset, 
                          (size_t)sec64.size);
 
       offset += sizeof(struct section_64);
     }
   }
 
   // Continue processing
   return true;
 }
 
 // static
 bool MachoID::UUIDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
                            bool swap, void *context) {
   if (cmd->cmd == LC_UUID) {
     struct breakpad_uuid_command *uuid_cmd =
       (struct breakpad_uuid_command *)context;
 
     if (!walker->ReadBytes(uuid_cmd, sizeof(struct breakpad_uuid_command),
                            offset))
       return false;
 
     if (swap)
-      breakpad_swap_uuid_command(uuid_cmd, NXHostByteOrder());
+      breakpad_swap_uuid_command(uuid_cmd);
 
     return false;
   }
 
   // Continue processing
   return true;
 }
 
 // static
 bool MachoID::IDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
                          bool swap, void *context) {
   if (cmd->cmd == LC_ID_DYLIB) {
     struct dylib_command *dylib_cmd = (struct dylib_command *)context;
 
     if (!walker->ReadBytes(dylib_cmd, sizeof(struct dylib_command), offset))
       return false;
 
     if (swap)
-      swap_dylib_command(dylib_cmd, NXHostByteOrder());
+      breakpad_swap_dylib_command(dylib_cmd);
 
     return false;
   }
 
   // Continue processing
   return true;
 }
 
 }  // namespace MacFileUtilities