Implement a network daemon + networked implementation of SymbolSupplier and SourceLineResolver

src/processor/network_source_line_resolver.cc

+// Copyright (c) 2010, 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
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <cassert>
+#include <sstream>
+#include <vector>
+
+#include "google_breakpad/processor/network_source_line_resolver.h"
+#include "google_breakpad/processor/stack_frame.h"
+#include "processor/binarystream.h"
+#include "processor/network_interface.h"
+#include "processor/network_source_line_protocol.h"
+#include "processor/logging.h"
+#include "processor/tokenize.h"
+#include "processor/udp_network.h"
+#include "processor/windows_frame_info.h"
+
+namespace google_breakpad {
+
+using std::string;
+using std::vector;
+using std::dec;
+using std::hex;
+using namespace source_line_protocol;
+
+NetworkSourceLineResolver::NetworkSourceLineResolver(const string &server,
+                                                     unsigned short port,
+                                                     int wait_time)
+  : wait_time_(wait_time),
+    initialized_(false),
+    sequence_(0),
+    net_(new UDPNetwork(server, port))
+{

[Mark Mentovai, 2010/03/02 20:05:55]

curly belongs on previous (also at 73 and 79)

+  if (net_->Init(false))
+    initialized_ = true;
+}
+
+NetworkSourceLineResolver::NetworkSourceLineResolver(NetworkInterface *net,
+                                                     int wait_time)
+  : wait_time_(wait_time),
+    initialized_(false),
+    sequence_(0),
+    net_(net)
+{
+  if (net_ && net->Init(false))
+    initialized_ = true;
+}
+
+NetworkSourceLineResolver::~NetworkSourceLineResolver()
+{
+  initialized_ = false;
+}
+
+bool NetworkSourceLineResolver::LoadModule(const CodeModule *module,
+                                           const string &map_file) {
+  // Just lie here and say it was loaded. The server always loads
+  // symbols immediately when they're found, since clients always
+  // will want to load them after finding them anyway. Since this class
+  // acts as both the symbol supplier and source line resolver,
+  // it's just a little optimization.
+  return true;
+}
+
+bool NetworkSourceLineResolver::LoadModuleUsingMapBuffer(
+    const CodeModule *module,
+    const string &map_buffer) {
+  // see above
+  return true;
+}
+
+void NetworkSourceLineResolver::UnloadModule(const CodeModule *module)
+{
+  // no-op
+}
+
+bool NetworkSourceLineResolver::HasModule(const CodeModule *module) {
+  if (!initialized_ || !module)
+    return false;
+
+  // cache seen modules so the network round trip can be skipped
+  if (module_cache_.find(module->code_file()) != module_cache_.end())
+    return true;
+
+  // also cache modules for which symbols aren't found
+  if (no_symbols_cache_.find(module->debug_file() + module->debug_identifier())
+      != no_symbols_cache_.end())
+    return false;
+
+  binarystream message;
+  message << HAS

[Mark Mentovai, 2010/03/02 20:05:55]

This comes out pretty nicely.

+          << module->code_file()
+          << module->debug_file()
+          << module->debug_identifier();
+  binarystream response;
+  bool got_response = SendMessageGetResponse(message, response);
+  u_int8_t response_data;
+  response >> response_data;
+  if (got_response && !response.eof() && response_data == MODULE_LOADED) {
+    module_cache_.insert(module->code_file());
+    return true;
+  }
+  return false;
+}
+
+void NetworkSourceLineResolver::FillSourceLineInfo(
+    StackFrame *frame) {
+  if (!initialized_)
+    return;
+
+  // if don't this module isn't loaded, can't fill source line info
+  if (!frame->module ||
+      module_cache_.find(frame->module->code_file()) == module_cache_.end())
+    return;
+
+  // if this frame has already been seen, return the cached copy
+  if (FindCachedSourceLineInfo(frame)) {
+    BPLOG(INFO) << "Using cached source line info";
+    return;
+  }
+
+  binarystream message;
+  message << GET
+          << frame->module->code_file()
+          << frame->module->debug_file()
+          << frame->module->debug_identifier()
+          << frame->module->base_address()
+          << frame->instruction;
+  binarystream response;
+  bool got_response = SendMessageGetResponse(message, response);
+  if (!got_response)
+    return;
+
+  string function_name, source_file;
+  u_int32_t source_line;
+  u_int64_t function_base, source_line_base;
+  response >> function_name >> function_base
+           >> source_file >> source_line >> source_line_base;
+  
+  if (response.eof()) {
+    BPLOG(ERROR) << "GET response malformed";
+    return;
+  } else {
+    BPLOG(INFO) << "GET response: " << function_name << " "
+                << hex << function_base << " " << source_file << " "
+                << dec << source_line << " " << hex
+                << source_line_base;
+  }
+
+  frame->function_name = function_name;
+  frame->function_base = function_base;
+  frame->source_file_name = source_file;
+  frame->source_line = source_line;
+  frame->source_line_base = source_line_base;
+
+  CacheSourceLineInfo(frame);
+  return;
+}
+
+WindowsFrameInfo*
+NetworkSourceLineResolver::FindWindowsFrameInfo(const StackFrame *frame)
+{
+  if (!initialized_)
+    return NULL;
+
+  // if this module isn't loaded, can't get frame info
+  if (!frame->module ||
+      module_cache_.find(frame->module->code_file()) == module_cache_.end())
+    return NULL;
+
+  // check the cache first
+  WindowsFrameInfo *info = NULL;
+  if (FindCachedWindowsFrameInfo(frame, &info)) {
+    BPLOG(INFO) << "Using cached windows frame info";
+    return info;
+  }
+
+  binarystream message;
+  message << GETSTACKWIN
+          << frame->module->code_file()
+          << frame->module->debug_file()
+          << frame->module->debug_identifier()
+          << frame->module->base_address()
+          << frame->instruction;
+  binarystream response;
+  bool got_response = SendMessageGetResponse(message, response);
+  if (!got_response)
+    return NULL;
+
+  string stack_info;
+  response >> stack_info;
+
+  if (!stack_info.empty()) {
+    int type;
+    u_int64_t rva, code_size;
+    info = WindowsFrameInfo::ParseFromString(stack_info,
+                                             type,
+                                             rva,
+                                             code_size);
+  }
+  CacheWindowsFrameInfo(frame, info);
+
+  return info;
+}
+
+SymbolSupplier::SymbolResult
+NetworkSourceLineResolver::GetSymbolFile(const CodeModule *module,
+                                         const SystemInfo *system_info,
+                                         string *symbol_file)
+{
+  BPLOG_IF(ERROR, !symbol_file) << "NetworkSourceLineResolver::GetSymbolFile "
+                                   "requires |symbol_file|";
+  assert(symbol_file);
+
+  if (!initialized_)
+    return NOT_FOUND;
+
+  if (no_symbols_cache_.find(module->debug_file() + module->debug_identifier())
+      != no_symbols_cache_.end())
+    return NOT_FOUND;
+
+  binarystream message;
+  message << LOAD
+          << module->code_file()
+          << module->debug_file()
+          << module->debug_identifier();
+  binarystream response;
+  bool got_response = SendMessageGetResponse(message, response);
+  if (!got_response) {
+    // Didn't get a response, which is the same as not having symbols.
+    // Don't cache this, though, to force a retry if the client asks for
+    // symbols for the same file again.
+    return NOT_FOUND;
+  }
+  u_int8_t response_data;
+  response >> response_data;
+
+  if (response.eof()) {
+    BPLOG(ERROR) << "Malformed LOAD response";
+    return NOT_FOUND;
+  }
+
+  if (response_data == LOAD_NOT_FOUND || response_data == LOAD_FAIL) {
+    // Received NOT or FAIL, symbols not present or failed to load them.
+    // Same problem to the client any way you look at it.
+    // Cache this module to avoid pointless retry.
+    no_symbols_cache_.insert(module->debug_file() + module->debug_identifier());
+    return NOT_FOUND;
+  } else if (response_data == LOAD_INTERRUPT) {
+    return INTERRUPT;
+  }
+
+  // otherwise, OK
+  module_cache_.insert(module->code_file());
+  *symbol_file = "<loaded on server>";
+  return FOUND;
+}
+
+SymbolSupplier::SymbolResult
+NetworkSourceLineResolver::GetSymbolFile(const CodeModule *module,
+                                         const SystemInfo *system_info,
+                                         string *symbol_file,
+                                         string *symbol_data)
+{
+  if(symbol_data)
+    symbol_data->clear();
+  return GetSymbolFile(module, system_info, symbol_file);
+}
+
+bool NetworkSourceLineResolver::SendMessageGetResponse(
+    const binarystream &message,
+    binarystream &response)
+{
+  binarystream sequence_stream;
+  u_int16_t sent_sequence = sequence_;
+  sequence_stream << sequence_;
+  ++sequence_;
+  string message_string = sequence_stream.str();
+  message_string.append(message.str());
+  BPLOG(INFO) << "Sending " << message_string.length() << " bytes";
+  if (!net_->Send(message_string.c_str(), message_string.length()))
+    return false;
+
+  bool done = false;
+  while (!done) {
+    if (!net_->WaitToReceive(wait_time_))
+      return false;
+
+    vector<char> buffer(1024);
+    ssize_t received_bytes;
+    if (!net_->Receive(&buffer[0], buffer.size(), received_bytes))
+      return false;
+
+    BPLOG(INFO) << "received " << received_bytes << " bytes";
+    buffer.resize(received_bytes);
+
+    response.str(string(&buffer[0], buffer.size()));
+    response.rewind();
+    u_int16_t read_sequence;
+    u_int8_t  status;
+    response >> read_sequence >> status;
+    if (response.eof()) {
+      BPLOG(ERROR) << "malformed response, missing sequence number or status";
+      return false;
+    }
+    if (read_sequence < sent_sequence) // old packet
+      continue;
+
+    if (read_sequence != sent_sequence) {
+      // not expecting this packet, just error
+      BPLOG(ERROR) << "error, got sequence number " << read_sequence
+                   << ", expected " << sent_sequence;
+      return false;
+    }
+
+    // This is the expected packet, so even if it's an error this loop is done
+    done = true;
+
+    if (status != OK) {
+      BPLOG(ERROR) << "received an ER response packet";
+      return false;
+    }
+    // the caller will process the rest of response
+  }
+  return true;
+}
+
+bool NetworkSourceLineResolver::FindCachedSourceLineInfo(StackFrame *frame)
+  const
+{
+  SourceCache::const_iterator iter =
+    source_line_info_cache_.find(frame->instruction);
+  if (iter == source_line_info_cache_.end())
+    return false;
+
+  const StackFrame &f = iter->second;
+  frame->function_name = f.function_name;
+  frame->function_base = f.function_base;
+  frame->source_file_name = f.source_file_name;
+  frame->source_line = f.source_line;
+  frame->source_line_base = f.source_line_base;
+  return true;
+}
+
+bool NetworkSourceLineResolver::FindCachedWindowsFrameInfo(
+  const StackFrame *frame,
+  WindowsFrameInfo **info) const
+{
+  WindowsFrameCache::const_iterator iter =
+    windows_frame_cache_.find(frame->instruction);
+  if (iter == windows_frame_cache_.end())
+    return false;
+
+  *info = NULL;
+  // have to give the caller a new pointer
+  if (iter->second.get()) {
+    *info = new WindowsFrameInfo();
+    (*info)->CopyFrom(*(iter->second.get()));
+  }
+  return true;
+}
+
+void NetworkSourceLineResolver::CacheSourceLineInfo(const StackFrame *frame)
+{
+  StackFrame f(*frame);
+  // can't hang onto this pointer, the caller owns it
+  f.module = NULL;
+  source_line_info_cache_[frame->instruction] = f;
+}
+
+void NetworkSourceLineResolver::CacheWindowsFrameInfo(
+  const StackFrame *frame,
+  const WindowsFrameInfo *info)
+{
+  WindowsFrameInfo *new_info = NULL;
+  if (info) {
+    // the caller owns info, so make a copy
+    new_info = new WindowsFrameInfo();
+    new_info->CopyFrom(*info);
+  }
+  windows_frame_cache_[frame->instruction] = make_linked_ptr(new_info);
+}
+
+} // namespace google_breakpad