src/processor/network_source_line_server.cc - fp2-dev/platform/external/google-breakpad - Gitiles

 // 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 <arpa/inet.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>

 #include <algorithm>
 #include <iostream>
 #include <sstream>

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include "google_breakpad/processor/code_module.h"
 #include "google_breakpad/processor/stack_frame.h"
 #include "processor/basic_code_module.h"
 #include "processor/binarystream.h"
 #include "processor/cfi_frame_info.h"
 #include "processor/logging.h"
 #include "processor/network_source_line_protocol.h"
 #include "processor/network_source_line_server.h"
 #include "processor/tokenize.h"
 #include "processor/windows_frame_info.h"

 namespace google_breakpad {

 using std::dec;
 using std::find;
 using std::hex;
 // Style guide forbids "using namespace", so at least shorten it.
 namespace P = source_line_protocol;

 bool NetworkSourceLineServer::Initialize() {
   if (net_->Init(true))
     initialized_ = true;
   return initialized_;
 }

 bool NetworkSourceLineServer::RunForever() {
   if (!initialized_ && !Initialize())
     return false;

   BPLOG(INFO) << "Running forever...";
   while (true) {
     RunOnce(5000);
   }
   // not reached
   return true;
 }

 bool NetworkSourceLineServer::RunOnce(int wait_milliseconds) {
   if (!initialized_ && !Initialize())
     return false;

   if (!net_->WaitToReceive(wait_milliseconds))
     return false;
   //TODO(ted): loop, processing packets until wait_milliseconds
   // is actually exhausted?

   vector<char> buffer(1024);
   ssize_t received_bytes;
   if (!net_->Receive(&buffer[0], buffer.size(), received_bytes))
     return false;
   buffer.resize(received_bytes);

   binarystream request(&buffer[0], buffer.size());
   binarystream response;
   if (!HandleRequest(request, response))
     return false;

   string response_string = response.str();
   if (!net_->Send(response_string.c_str(), response_string.length()))
     return false;
   return true;
 }

 bool NetworkSourceLineServer::HandleRequest(binarystream &request,
                                             binarystream &response) {
   u_int16_t sequence_number;
   u_int8_t  command;
   request >> sequence_number >> command;
   if (request.eof()) {
     BPLOG(ERROR) << "Malformed request, missing sequence number or command";
     return false;
   }

   response.rewind();
   response << sequence_number;
   switch(command) {
   case P::HAS:
     HandleHas(request, response);
     break;
   case P::LOAD:
     HandleLoad(request, response);
     break;
   case P::GET:
     HandleGet(request, response);
     break;
   case P::GETSTACKWIN:
     HandleGetStackWin(request, response);
     break;
   case P::GETSTACKCFI:
     HandleGetStackCFI(request, response);
     break;
   default:
     BPLOG(ERROR) << "Unknown command " << int(command);
     response << P::ERROR;
     break;
   }
   return true;
 }

 void NetworkSourceLineServer::HandleHas(binarystream &message,
                                         binarystream &response) {
   string module_name, debug_file, debug_id;
   message >> module_name >> debug_file >> debug_id;
   if (message.eof()) {
     BPLOG(ERROR) << "HAS message malformed";
     response << P::ERROR;
     return;
   }
   BPLOG(INFO) << "Received message HAS " << module_name
               << " " << debug_file
               << " " << debug_id;
   // Need to lie about the module name here, since BasicSourceLineResolver
   // uses only the module name for unique modules, but we want to allow
   // multiple versions of the same named module in here.
   BasicCodeModule module((u_int64_t)0, (u_int64_t)0,
 			 module_name + "|" + debug_file + "|" + debug_id, "",
 			 debug_file, debug_id, "");
   u_int8_t data;
   if (resolver_) {
     data = resolver_->HasModule(&module)
       ? P::MODULE_LOADED : P::MODULE_NOT_LOADED;
   } else {
     data = P::MODULE_NOT_LOADED;
   }
   response << P::OK << data;
 }

 void NetworkSourceLineServer::HandleLoad(binarystream &message,
                                          binarystream &response) {
   string module_name, debug_file, debug_id;
   message >> module_name >> debug_file >> debug_id;
   if (message.eof()) {
     BPLOG(ERROR) << "LOAD message malformed";
     response << P::ERROR;
     return;
   }
   BPLOG(INFO) << "Received message LOAD " << module_name
               << " " << debug_file
               << " " << debug_id;

   u_int8_t reply;
   // stub out the bare minimum here
   BasicCodeModule module((u_int64_t)0, (u_int64_t)0,
                          module_name + "|" + debug_file + "|" + debug_id, "",
                          debug_file, debug_id, "");
   if (resolver_->HasModule(&module)) {
     // just short-circuit the rest of this, since it's already loaded
     BPLOG(INFO) << "Got LOAD for already loaded " << module_name;
     UsedModule(module);
     reply = P::LOAD_OK;
   } else {
     BPLOG(INFO) << "Looking up symbols for (" << module_name << ", "
                 << debug_file << ", " << debug_id << ")";
     string symbol_data, symbol_file;
     SymbolSupplier::SymbolResult symbol_result;
     if (supplier_) {
       symbol_result = supplier_->GetSymbolFile(&module, NULL,
                                                &symbol_file, &symbol_data);
     } else {
       symbol_result = SymbolSupplier::NOT_FOUND;
     }

     switch (symbol_result) {
     case SymbolSupplier::FOUND: {
       BPLOG(INFO) << "Found symbols for " << module_name;
       reply = P::LOAD_OK;
       // also go ahead and load the symbols while we're here,
       // since the client is just going to ask us to do this right away
       // and we already have |symbol_data| here.
       int numlines = CountNewlines(symbol_data);
       if (!resolver_->LoadModuleUsingMapBuffer(&module,
                                                symbol_data)) {
         BPLOG(INFO) << "Failed to load symbols for " << module_name;
         reply = P::LOAD_FAIL;
       } else {
         // save some info about this module
         symbol_lines_ += numlines;
         UsedModule(module);
         module_symbol_lines_[module.code_file()] = numlines;

         BPLOG(INFO) << "Loaded symbols for " << module_name
                     << " (" << dec << numlines << " lines, "
                     << symbol_lines_ << " total)";

         if (max_symbol_lines_ != 0 && symbol_lines_ > max_symbol_lines_) {
           // try unloading some modules to reclaim memory
           // (but not the one that was just loaded)
           BPLOG(INFO) << "Exceeded limit of " << dec << max_symbol_lines_
                       << " symbol lines loaded, trying to unload modules";
           TryUnloadModules(module);
         }
       }
     }
       break;
     case SymbolSupplier::NOT_FOUND:
       BPLOG(INFO) << "Symbols not found for " << module_name;
       reply = P::LOAD_NOT_FOUND;
       break;
     case SymbolSupplier::INTERRUPT:
       BPLOG(INFO) << "Symbol provider returned interrupt for " << module_name;
       reply = P::LOAD_INTERRUPT;
       break;
     }
   }
   response << P::OK << reply;
 }

 void NetworkSourceLineServer::HandleGet(binarystream &message,
                                         binarystream &response) {
   string module_name, debug_file, debug_id;
   u_int64_t module_base, instruction;
   message >> module_name >> debug_file >> debug_id
           >> module_base >> instruction;
   if (message.eof()) {
     BPLOG(ERROR) << "GET message malformed";
     response << P::ERROR;
     return;
   }

   BPLOG(INFO) << "Received message GET " << module_name << " "
               << debug_file << " " << debug_id << " "
               << hex << module_base << " " << instruction;

   StackFrame frame;
   if (resolver_) {
     BasicCodeModule module(module_base, (u_int64_t)0,
                            module_name + "|" + debug_file + "|" + debug_id, "",
                            debug_file, debug_id, "");
     frame.module = &module;
     frame.instruction = instruction;
     resolver_->FillSourceLineInfo(&frame);
     UsedModule(module);
   }

   response << P::OK << frame.function_name << frame.function_base
            << frame.source_file_name << u_int32_t(frame.source_line)
            << frame.source_line_base;
   BPLOG(INFO) << "Sending GET response: " << frame.function_name << " "
               << hex << frame.function_base << " "
               << frame.source_file_name << " "
               << dec << frame.source_line << " "
               << hex << frame.source_line_base;
 }

 void NetworkSourceLineServer::HandleGetStackWin(binarystream &message,
                                                 binarystream &response) {
   string module_name, debug_file, debug_id;
   u_int64_t module_base, instruction;
   message >> module_name >> debug_file >> debug_id
           >> module_base >> instruction;
   if (message.eof()) {
     BPLOG(ERROR) << "GETSTACKWIN message malformed";
     response << P::ERROR;
     return;
   }

   BPLOG(INFO) << "Received message GETSTACKWIN " << module_name << " "
               << debug_file << " " << debug_id << " "
               << hex << module_base << " " << instruction;


   WindowsFrameInfo *frame_info = NULL;
   if (resolver_) {
     StackFrame frame;
     BasicCodeModule module(module_base, (u_int64_t)0,
                            module_name + "|" + debug_file + "|" + debug_id, "",
                            debug_file, debug_id, "");
     frame.module = &module;
     frame.instruction = instruction;
     frame_info = resolver_->FindWindowsFrameInfo(&frame);
     UsedModule(module);
   }

   response << P::OK << FormatWindowsFrameInfo(frame_info);
   BPLOG(INFO) << "Sending GETSTACKWIN response: "
               << FormatWindowsFrameInfo(frame_info);
   delete frame_info;
 }

 string NetworkSourceLineServer::FormatWindowsFrameInfo(
     WindowsFrameInfo *frame_info) {
   if (frame_info == NULL)
     return "";

   std::ostringstream stream;
   // Put "0" as the type, rva and code size because the client doesn't
   // actually care what these values are, but it's easier to keep the
   // format consistent with the symbol files so the parsing code can be
   // shared.
   stream << "0 0 0 " << hex
 	 << frame_info->prolog_size << " "
 	 << frame_info->epilog_size << " "
 	 << frame_info->parameter_size << " "
 	 << frame_info->saved_register_size << " "
 	 << frame_info->local_size << " "
 	 << frame_info->max_stack_size << " ";
   if (!frame_info->program_string.empty()) {
     stream << 1 << " " << frame_info->program_string;
   } else {
     stream << 0 << " " << frame_info->allocates_base_pointer;
   }
   return stream.str();
 }

 void NetworkSourceLineServer::HandleGetStackCFI(binarystream &message,
                                                 binarystream &response) {
   string module_name, debug_file, debug_id;
   u_int64_t module_base, instruction;
   message >> module_name >> debug_file >> debug_id
           >> module_base >> instruction;
   if (message.eof()) {
     BPLOG(ERROR) << "GETSTACKCFI message malformed";
     response << P::ERROR;
     return;
   }

   BPLOG(INFO) << "Received message GETSTACKCFI " << module_name << " "
               << debug_file << " " << debug_id << " "
               << hex << module_base << " " << instruction;


   CFIFrameInfo *frame_info = NULL;
   if (resolver_) {
     StackFrame frame;
     BasicCodeModule module(module_base, (u_int64_t)0,
                            module_name + "|" + debug_file + "|" + debug_id, "",
                            debug_file, debug_id, "");
     frame.module = &module;
     frame.instruction = instruction;
     frame_info = resolver_->FindCFIFrameInfo(&frame);
     UsedModule(module);
   }

   string frame_info_string;
   if (frame_info != NULL)
     frame_info_string = frame_info->Serialize();
   response << P::OK << frame_info_string;
   BPLOG(INFO) << "Sending GETSTACKCFI response: "
               << frame_info_string;
   delete frame_info;
 }

 int NetworkSourceLineServer::CountNewlines(const string &str) {
   int count = 0;
   string::const_iterator iter = str.begin();
   while (iter != str.end()) {
     if (*iter == '\n')
       count++;
     iter++;
   }
   return count;
 }

 void NetworkSourceLineServer::UsedModule(const CodeModule &module) {
   list<string>::iterator iter = find(modules_used_.begin(),
                                      modules_used_.end(),
                                      module.code_file());
   if (iter == modules_used_.end()) {
     modules_used_.push_front(module.code_file());
   } else {
     modules_used_.splice(modules_used_.begin(),
                          modules_used_,
                          iter);
   }
 }

 void NetworkSourceLineServer::TryUnloadModules(
   const CodeModule &just_loaded_module) {
   if (!resolver_)
     return;

   while (symbol_lines_ > max_symbol_lines_) {
     // never unload just_loaded_module
     if (modules_used_.back() == just_loaded_module.code_file())
       break;

     string module_to_unload = modules_used_.back();
     modules_used_.pop_back();
     BasicCodeModule module(0, 0, module_to_unload, "", "", "", "");
     BPLOG(INFO) << "Unloading module " << module_to_unload;
     resolver_->UnloadModule(&module);

     // reduce the symbol line count
     map<string, int>::iterator iter =
       module_symbol_lines_.find(module_to_unload);
     if (iter != module_symbol_lines_.end()) {
       symbol_lines_ -= iter->second;
       module_symbol_lines_.erase(iter);
     }
   }
 }

 }  // namespace google_breakpad
	// 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 <arpa/inet.h>
	#include <netinet/in.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <sys/types.h>

	#include <algorithm>
	#include <iostream>
	#include <sstream>

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif
	#include "google_breakpad/processor/code_module.h"
	#include "google_breakpad/processor/stack_frame.h"
	#include "processor/basic_code_module.h"
	#include "processor/binarystream.h"
	#include "processor/cfi_frame_info.h"
	#include "processor/logging.h"
	#include "processor/network_source_line_protocol.h"
	#include "processor/network_source_line_server.h"
	#include "processor/tokenize.h"
	#include "processor/windows_frame_info.h"

	namespace google_breakpad {

	using std::dec;
	using std::find;
	using std::hex;
	// Style guide forbids "using namespace", so at least shorten it.
	namespace P = source_line_protocol;

	bool NetworkSourceLineServer::Initialize() {
	if (net_->Init(true))
	initialized_ = true;
	return initialized_;
	}

	bool NetworkSourceLineServer::RunForever() {
	if (!initialized_ && !Initialize())
	return false;

	BPLOG(INFO) << "Running forever...";
	while (true) {
	RunOnce(5000);
	}
	// not reached
	return true;
	}

	bool NetworkSourceLineServer::RunOnce(int wait_milliseconds) {
	if (!initialized_ && !Initialize())
	return false;

	if (!net_->WaitToReceive(wait_milliseconds))
	return false;
	//TODO(ted): loop, processing packets until wait_milliseconds
	// is actually exhausted?

	vector<char> buffer(1024);
	ssize_t received_bytes;
	if (!net_->Receive(&buffer[0], buffer.size(), received_bytes))
	return false;
	buffer.resize(received_bytes);

	binarystream request(&buffer[0], buffer.size());
	binarystream response;
	if (!HandleRequest(request, response))
	return false;

	string response_string = response.str();
	if (!net_->Send(response_string.c_str(), response_string.length()))
	return false;
	return true;
	}

	bool NetworkSourceLineServer::HandleRequest(binarystream &request,
	binarystream &response) {
	u_int16_t sequence_number;
	u_int8_t command;
	request >> sequence_number >> command;
	if (request.eof()) {
	BPLOG(ERROR) << "Malformed request, missing sequence number or command";
	return false;
	}

	response.rewind();
	response << sequence_number;
	switch(command) {
	case P::HAS:
	HandleHas(request, response);
	break;
	case P::LOAD:
	HandleLoad(request, response);
	break;
	case P::GET:
	HandleGet(request, response);
	break;
	case P::GETSTACKWIN:
	HandleGetStackWin(request, response);
	break;
	case P::GETSTACKCFI:
	HandleGetStackCFI(request, response);
	break;
	default:
	BPLOG(ERROR) << "Unknown command " << int(command);
	response << P::ERROR;
	break;
	}
	return true;
	}

	void NetworkSourceLineServer::HandleHas(binarystream &message,
	binarystream &response) {
	string module_name, debug_file, debug_id;
	message >> module_name >> debug_file >> debug_id;
	if (message.eof()) {
	BPLOG(ERROR) << "HAS message malformed";
	response << P::ERROR;
	return;
	}
	BPLOG(INFO) << "Received message HAS " << module_name
	<< " " << debug_file
	<< " " << debug_id;
	// Need to lie about the module name here, since BasicSourceLineResolver
	// uses only the module name for unique modules, but we want to allow
	// multiple versions of the same named module in here.
	BasicCodeModule module((u_int64_t)0, (u_int64_t)0,
	module_name + "\|" + debug_file + "\|" + debug_id, "",
	debug_file, debug_id, "");
	u_int8_t data;
	if (resolver_) {
	data = resolver_->HasModule(&module)
	? P::MODULE_LOADED : P::MODULE_NOT_LOADED;
	} else {
	data = P::MODULE_NOT_LOADED;
	}
	response << P::OK << data;
	}

	void NetworkSourceLineServer::HandleLoad(binarystream &message,
	binarystream &response) {
	string module_name, debug_file, debug_id;
	message >> module_name >> debug_file >> debug_id;
	if (message.eof()) {
	BPLOG(ERROR) << "LOAD message malformed";
	response << P::ERROR;
	return;
	}
	BPLOG(INFO) << "Received message LOAD " << module_name
	<< " " << debug_file
	<< " " << debug_id;

	u_int8_t reply;
	// stub out the bare minimum here
	BasicCodeModule module((u_int64_t)0, (u_int64_t)0,
	module_name + "\|" + debug_file + "\|" + debug_id, "",
	debug_file, debug_id, "");
	if (resolver_->HasModule(&module)) {
	// just short-circuit the rest of this, since it's already loaded
	BPLOG(INFO) << "Got LOAD for already loaded " << module_name;
	UsedModule(module);
	reply = P::LOAD_OK;
	} else {
	BPLOG(INFO) << "Looking up symbols for (" << module_name << ", "
	<< debug_file << ", " << debug_id << ")";
	string symbol_data, symbol_file;
	SymbolSupplier::SymbolResult symbol_result;
	if (supplier_) {
	symbol_result = supplier_->GetSymbolFile(&module, NULL,
	&symbol_file, &symbol_data);
	} else {
	symbol_result = SymbolSupplier::NOT_FOUND;
	}

	switch (symbol_result) {
	case SymbolSupplier::FOUND: {
	BPLOG(INFO) << "Found symbols for " << module_name;
	reply = P::LOAD_OK;
	// also go ahead and load the symbols while we're here,
	// since the client is just going to ask us to do this right away
	// and we already have \|symbol_data\| here.
	int numlines = CountNewlines(symbol_data);
	if (!resolver_->LoadModuleUsingMapBuffer(&module,
	symbol_data)) {
	BPLOG(INFO) << "Failed to load symbols for " << module_name;
	reply = P::LOAD_FAIL;
	} else {
	// save some info about this module
	symbol_lines_ += numlines;
	UsedModule(module);
	module_symbol_lines_[module.code_file()] = numlines;

	BPLOG(INFO) << "Loaded symbols for " << module_name
	<< " (" << dec << numlines << " lines, "
	<< symbol_lines_ << " total)";

	if (max_symbol_lines_ != 0 && symbol_lines_ > max_symbol_lines_) {
	// try unloading some modules to reclaim memory
	// (but not the one that was just loaded)
	BPLOG(INFO) << "Exceeded limit of " << dec << max_symbol_lines_
	<< " symbol lines loaded, trying to unload modules";
	TryUnloadModules(module);
	}
	}
	}
	break;
	case SymbolSupplier::NOT_FOUND:
	BPLOG(INFO) << "Symbols not found for " << module_name;
	reply = P::LOAD_NOT_FOUND;
	break;
	case SymbolSupplier::INTERRUPT:
	BPLOG(INFO) << "Symbol provider returned interrupt for " << module_name;
	reply = P::LOAD_INTERRUPT;
	break;
	}
	}
	response << P::OK << reply;
	}

	void NetworkSourceLineServer::HandleGet(binarystream &message,
	binarystream &response) {
	string module_name, debug_file, debug_id;
	u_int64_t module_base, instruction;
	message >> module_name >> debug_file >> debug_id
	>> module_base >> instruction;
	if (message.eof()) {
	BPLOG(ERROR) << "GET message malformed";
	response << P::ERROR;
	return;
	}

	BPLOG(INFO) << "Received message GET " << module_name << " "
	<< debug_file << " " << debug_id << " "
	<< hex << module_base << " " << instruction;

	StackFrame frame;
	if (resolver_) {
	BasicCodeModule module(module_base, (u_int64_t)0,
	module_name + "\|" + debug_file + "\|" + debug_id, "",
	debug_file, debug_id, "");
	frame.module = &module;
	frame.instruction = instruction;
	resolver_->FillSourceLineInfo(&frame);
	UsedModule(module);
	}

	response << P::OK << frame.function_name << frame.function_base
	<< frame.source_file_name << u_int32_t(frame.source_line)
	<< frame.source_line_base;
	BPLOG(INFO) << "Sending GET response: " << frame.function_name << " "
	<< hex << frame.function_base << " "
	<< frame.source_file_name << " "
	<< dec << frame.source_line << " "
	<< hex << frame.source_line_base;
	}

	void NetworkSourceLineServer::HandleGetStackWin(binarystream &message,
	binarystream &response) {
	string module_name, debug_file, debug_id;
	u_int64_t module_base, instruction;
	message >> module_name >> debug_file >> debug_id
	>> module_base >> instruction;
	if (message.eof()) {
	BPLOG(ERROR) << "GETSTACKWIN message malformed";
	response << P::ERROR;
	return;
	}

	BPLOG(INFO) << "Received message GETSTACKWIN " << module_name << " "
	<< debug_file << " " << debug_id << " "
	<< hex << module_base << " " << instruction;


	WindowsFrameInfo *frame_info = NULL;
	if (resolver_) {
	StackFrame frame;
	BasicCodeModule module(module_base, (u_int64_t)0,
	module_name + "\|" + debug_file + "\|" + debug_id, "",
	debug_file, debug_id, "");
	frame.module = &module;
	frame.instruction = instruction;
	frame_info = resolver_->FindWindowsFrameInfo(&frame);
	UsedModule(module);
	}

	response << P::OK << FormatWindowsFrameInfo(frame_info);
	BPLOG(INFO) << "Sending GETSTACKWIN response: "
	<< FormatWindowsFrameInfo(frame_info);
	delete frame_info;
	}

	string NetworkSourceLineServer::FormatWindowsFrameInfo(
	WindowsFrameInfo *frame_info) {
	if (frame_info == NULL)
	return "";

	std::ostringstream stream;
	// Put "0" as the type, rva and code size because the client doesn't
	// actually care what these values are, but it's easier to keep the
	// format consistent with the symbol files so the parsing code can be
	// shared.
	stream << "0 0 0 " << hex
	<< frame_info->prolog_size << " "
	<< frame_info->epilog_size << " "
	<< frame_info->parameter_size << " "
	<< frame_info->saved_register_size << " "
	<< frame_info->local_size << " "
	<< frame_info->max_stack_size << " ";
	if (!frame_info->program_string.empty()) {
	stream << 1 << " " << frame_info->program_string;
	} else {
	stream << 0 << " " << frame_info->allocates_base_pointer;
	}
	return stream.str();
	}

	void NetworkSourceLineServer::HandleGetStackCFI(binarystream &message,
	binarystream &response) {
	string module_name, debug_file, debug_id;
	u_int64_t module_base, instruction;
	message >> module_name >> debug_file >> debug_id
	>> module_base >> instruction;
	if (message.eof()) {
	BPLOG(ERROR) << "GETSTACKCFI message malformed";
	response << P::ERROR;
	return;
	}

	BPLOG(INFO) << "Received message GETSTACKCFI " << module_name << " "
	<< debug_file << " " << debug_id << " "
	<< hex << module_base << " " << instruction;


	CFIFrameInfo *frame_info = NULL;
	if (resolver_) {
	StackFrame frame;
	BasicCodeModule module(module_base, (u_int64_t)0,
	module_name + "\|" + debug_file + "\|" + debug_id, "",
	debug_file, debug_id, "");
	frame.module = &module;
	frame.instruction = instruction;
	frame_info = resolver_->FindCFIFrameInfo(&frame);
	UsedModule(module);
	}

	string frame_info_string;
	if (frame_info != NULL)
	frame_info_string = frame_info->Serialize();
	response << P::OK << frame_info_string;
	BPLOG(INFO) << "Sending GETSTACKCFI response: "
	<< frame_info_string;
	delete frame_info;
	}

	int NetworkSourceLineServer::CountNewlines(const string &str) {
	int count = 0;
	string::const_iterator iter = str.begin();
	while (iter != str.end()) {
	if (*iter == '\n')
	count++;
	iter++;
	}
	return count;
	}

	void NetworkSourceLineServer::UsedModule(const CodeModule &module) {
	list<string>::iterator iter = find(modules_used_.begin(),
	modules_used_.end(),
	module.code_file());
	if (iter == modules_used_.end()) {
	modules_used_.push_front(module.code_file());
	} else {
	modules_used_.splice(modules_used_.begin(),
	modules_used_,
	iter);
	}
	}

	void NetworkSourceLineServer::TryUnloadModules(
	const CodeModule &just_loaded_module) {
	if (!resolver_)
	return;

	while (symbol_lines_ > max_symbol_lines_) {
	// never unload just_loaded_module
	if (modules_used_.back() == just_loaded_module.code_file())
	break;

	string module_to_unload = modules_used_.back();
	modules_used_.pop_back();
	BasicCodeModule module(0, 0, module_to_unload, "", "", "", "");
	BPLOG(INFO) << "Unloading module " << module_to_unload;
	resolver_->UnloadModule(&module);

	// reduce the symbol line count
	map<string, int>::iterator iter =
	module_symbol_lines_.find(module_to_unload);
	if (iter != module_symbol_lines_.end()) {
	symbol_lines_ -= iter->second;
	module_symbol_lines_.erase(iter);
	}
	}
	}

	} // namespace google_breakpad