← Back to branch summary

~ubuntu-branches/ubuntu/trusty/tomahawk/trusty-proposed

« back to all changes in this revision

Viewing changes to thirdparty/breakpad/common/linux/google_crashdump_uploader.cc

  • Committer: Package Import Robot
  • Author(s): Harald Sitter
  • Date: 2013-03-07 21:50:13 UTC
  • Revision ID: package-import@ubuntu.com-20130307215013-6gdjkdds7i9uenvs
Tags: upstream-0.6.0+dfsg
Import upstream version 0.6.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
thirdparty/breakpad/common/linux/google_crashdump_uploader.cc
 
1
// Copyright (c) 2009, Google Inc.
 
2
// All rights reserved.
 
3
//
 
4
// Redistribution and use in source and binary forms, with or without
 
5
// modification, are permitted provided that the following conditions are
 
6
// met:
 
7
//
 
8
//     * Redistributions of source code must retain the above copyright
 
9
// notice, this list of conditions and the following disclaimer.
 
10
//     * Redistributions in binary form must reproduce the above
 
11
// copyright notice, this list of conditions and the following disclaimer
 
12
// in the documentation and/or other materials provided with the
 
13
// distribution.
 
14
//     * Neither the name of Google Inc. nor the names of its
 
15
// contributors may be used to endorse or promote products derived from
 
16
// this software without specific prior written permission.
 
17
//
 
18
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
19
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
20
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
21
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
22
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
23
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
24
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
25
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
26
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
27
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
28
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
29
 
 
30
 
 
31
#include "common/linux/google_crashdump_uploader.h"
 
32
#include "common/linux/libcurl_wrapper.h"
 
33
 
 
34
#include <sys/types.h>
 
35
#include <sys/stat.h>
 
36
#include <unistd.h>
 
37
 
 
38
#include <iostream>
 
39
 
 
40
using std::string;
 
41
 
 
42
namespace google_breakpad {
 
43
 
 
44
GoogleCrashdumpUploader::GoogleCrashdumpUploader(const std::string& product,
 
45
                                                 const std::string& version,
 
46
                                                 const std::string& guid,
 
47
                                                 const std::string& ptime,
 
48
                                                 const std::string& ctime,
 
49
                                                 const std::string& email,
 
50
                                                 const std::string& comments,
 
51
                                                 const std::string& minidump_pathname,
 
52
                                                 const std::string& crash_server,
 
53
                                                 const std::string& proxy_host,
 
54
                                                 const std::string& proxy_userpassword) {
 
55
  LibcurlWrapper* http_layer = new LibcurlWrapper();
 
56
  Init(product,
 
57
       version,
 
58
       guid,
 
59
       ptime,
 
60
       ctime,
 
61
       email,
 
62
       comments,
 
63
       minidump_pathname,
 
64
       crash_server,
 
65
       proxy_host,
 
66
       proxy_userpassword,
 
67
       http_layer);
 
68
}
 
69
 
 
70
GoogleCrashdumpUploader::GoogleCrashdumpUploader(const std::string& product,
 
71
                                                 const std::string& version,
 
72
                                                 const std::string& guid,
 
73
                                                 const std::string& ptime,
 
74
                                                 const std::string& ctime,
 
75
                                                 const std::string& email,
 
76
                                                 const std::string& comments,
 
77
                                                 const std::string& minidump_pathname,
 
78
                                                 const std::string& crash_server,
 
79
                                                 const std::string& proxy_host,
 
80
                                                 const std::string& proxy_userpassword,
 
81
                                                 LibcurlWrapper* http_layer) {
 
82
  Init(product,
 
83
       version,
 
84
       guid,
 
85
       ptime,
 
86
       ctime,
 
87
       email,
 
88
       comments,
 
89
       minidump_pathname,
 
90
       crash_server,
 
91
       proxy_host,
 
92
       proxy_userpassword,
 
93
       http_layer);
 
94
}
 
95
 
 
96
void GoogleCrashdumpUploader::Init(const std::string& product,
 
97
                                   const std::string& version,
 
98
                                   const std::string& guid,
 
99
                                   const std::string& ptime,
 
100
                                   const std::string& ctime,
 
101
                                   const std::string& email,
 
102
                                   const std::string& comments,
 
103
                                   const std::string& minidump_pathname,
 
104
                                   const std::string& crash_server,
 
105
                                   const std::string& proxy_host,
 
106
                                   const std::string& proxy_userpassword,
 
107
                                   LibcurlWrapper* http_layer) {
 
108
  product_ = product;
 
109
  version_ = version;
 
110
  guid_ = guid;
 
111
  ptime_ = ptime;
 
112
  ctime_ = ctime;
 
113
  email_ = email;
 
114
  comments_ = comments;
 
115
  http_layer_ = http_layer;
 
116
 
 
117
  crash_server_ = crash_server;
 
118
  proxy_host_ = proxy_host;
 
119
  proxy_userpassword_ = proxy_userpassword;
 
120
  minidump_pathname_ = minidump_pathname;
 
121
  std::cout << "Uploader initializing";
 
122
  std::cout << "\tProduct: " << product_;
 
123
  std::cout << "\tVersion: " << version_;
 
124
  std::cout << "\tGUID: " << guid_;
 
125
  if (!ptime_.empty()) {
 
126
    std::cout << "\tProcess uptime: " << ptime_;
 
127
  }
 
128
  if (!ctime_.empty()) {
 
129
    std::cout << "\tCumulative Process uptime: " << ctime_;
 
130
  }
 
131
  if (!email_.empty()) {
 
132
    std::cout << "\tEmail: " << email_;
 
133
  }
 
134
  if (!comments_.empty()) {
 
135
    std::cout << "\tComments: " << comments_;
 
136
  }
 
137
}
 
138
 
 
139
bool GoogleCrashdumpUploader::CheckRequiredParametersArePresent() {
 
140
  std::string error_text;
 
141
  if (product_.empty()) {
 
142
    error_text.append("\nProduct name must be specified.");
 
143
  }
 
144
 
 
145
  if (version_.empty()) {
 
146
    error_text.append("\nProduct version must be specified.");
 
147
  }
 
148
 
 
149
  if (guid_.empty()) {
 
150
    error_text.append("\nClient ID must be specified.");
 
151
  }
 
152
 
 
153
  if (minidump_pathname_.empty()) {
 
154
    error_text.append("\nMinidump pathname must be specified.");
 
155
  }
 
156
 
 
157
  if (!error_text.empty()) {
 
158
    std::cout << error_text;
 
159
    return false;
 
160
  }
 
161
  return true;
 
162
 
 
163
}
 
164
 
 
165
bool GoogleCrashdumpUploader::Upload() {
 
166
  bool ok = http_layer_->Init();
 
167
  if (!ok) {
 
168
    std::cout << "http layer init failed";
 
169
    return ok;
 
170
  }
 
171
 
 
172
  if (!CheckRequiredParametersArePresent()) {
 
173
    return false;
 
174
  }
 
175
 
 
176
  struct stat st;
 
177
  int err = stat(minidump_pathname_.c_str(), &st);
 
178
  if (err) {
 
179
    std::cout << minidump_pathname_ << " could not be found";
 
180
    return false;
 
181
  }
 
182
 
 
183
  parameters_["prod"] = product_;
 
184
  parameters_["ver"] = version_;
 
185
  parameters_["guid"] = guid_;
 
186
  parameters_["ptime"] = ptime_;
 
187
  parameters_["ctime"] = ctime_;
 
188
  parameters_["email"] = email_;
 
189
  parameters_["comments_"] = comments_;
 
190
  if (!http_layer_->AddFile(minidump_pathname_,
 
191
                            "upload_file_minidump")) {
 
192
    return false;
 
193
  }
 
194
  std::cout << "Sending request to " << crash_server_;
 
195
  return http_layer_->SendRequest(crash_server_,
 
196
                                  parameters_,
 
197
                                  NULL);
 
198
}
 
199
}