]> git.saurik.com Git - wxWidgets.git/blob - src/common/http.cpp
cleanup - reformat
[wxWidgets.git] / src / common / http.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: http.cpp
3 // Purpose: HTTP protocol
4 // Author: Guilhem Lavaux
5 // Modified by:
6 // Created: August 1997
7 // RCS-ID: $Id$
8 // Copyright: (c) 1997, 1998 Guilhem Lavaux
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #if wxUSE_PROTOCOL_HTTP
20
21 #include <stdio.h>
22 #include <stdlib.h>
23
24 #ifndef WX_PRECOMP
25 #include "wx/string.h"
26 #include "wx/app.h"
27 #endif
28
29 #include "wx/tokenzr.h"
30 #include "wx/socket.h"
31 #include "wx/protocol/protocol.h"
32 #include "wx/url.h"
33 #include "wx/protocol/http.h"
34 #include "wx/sckstrm.h"
35
36 IMPLEMENT_DYNAMIC_CLASS(wxHTTP, wxProtocol)
37 IMPLEMENT_PROTOCOL(wxHTTP, wxT("http"), wxT("80"), true)
38
39 wxHTTP::wxHTTP()
40 : wxProtocol()
41 {
42 m_addr = NULL;
43 m_read = false;
44 m_proxy_mode = false;
45 m_post_buf = wxEmptyString;
46 m_http_response = 0;
47
48 SetNotify(wxSOCKET_LOST_FLAG);
49 }
50
51 wxHTTP::~wxHTTP()
52 {
53 ClearHeaders();
54
55 delete m_addr;
56 }
57
58 void wxHTTP::ClearHeaders()
59 {
60 m_headers.clear();
61 }
62
63 wxString wxHTTP::GetContentType()
64 {
65 return GetHeader(wxT("Content-Type"));
66 }
67
68 void wxHTTP::SetProxyMode(bool on)
69 {
70 m_proxy_mode = on;
71 }
72
73 wxHTTP::wxHeaderIterator wxHTTP::FindHeader(const wxString& header)
74 {
75 wxHeaderIterator it = m_headers.begin();
76 for ( wxHeaderIterator en = m_headers.end(); it != en; ++it )
77 {
78 if ( wxStricmp(it->first, header) == 0 )
79 break;
80 }
81
82 return it;
83 }
84
85 wxHTTP::wxHeaderConstIterator wxHTTP::FindHeader(const wxString& header) const
86 {
87 wxHeaderConstIterator it = m_headers.begin();
88 for ( wxHeaderConstIterator en = m_headers.end(); it != en; ++it )
89 {
90 if ( wxStricmp(it->first, header) == 0 )
91 break;
92 }
93
94 return it;
95 }
96
97 void wxHTTP::SetHeader(const wxString& header, const wxString& h_data)
98 {
99 if (m_read) {
100 ClearHeaders();
101 m_read = false;
102 }
103
104 wxHeaderIterator it = FindHeader(header);
105 if (it != m_headers.end())
106 it->second = h_data;
107 else
108 m_headers[header] = h_data;
109 }
110
111 wxString wxHTTP::GetHeader(const wxString& header) const
112 {
113 wxHeaderConstIterator it = FindHeader(header);
114
115 return it == m_headers.end() ? wxGetEmptyString() : it->second;
116 }
117
118 void wxHTTP::SetPostBuffer(const wxString& post_buf)
119 {
120 m_post_buf = post_buf;
121 }
122
123 void wxHTTP::SendHeaders()
124 {
125 typedef wxStringToStringHashMap::iterator iterator;
126 wxString buf;
127
128 for (iterator it = m_headers.begin(), en = m_headers.end(); it != en; ++it )
129 {
130 buf.Printf(wxT("%s: %s\r\n"), it->first.c_str(), it->second.c_str());
131
132 const wxWX2MBbuf cbuf = buf.mb_str();
133 Write(cbuf, strlen(cbuf));
134 }
135 }
136
137 bool wxHTTP::ParseHeaders()
138 {
139 wxString line;
140 wxStringTokenizer tokenzr;
141
142 ClearHeaders();
143 m_read = true;
144
145 for ( ;; )
146 {
147 m_perr = ReadLine(this, line);
148 if (m_perr != wxPROTO_NOERR)
149 return false;
150
151 if (line.Length() == 0)
152 break;
153
154 wxString left_str = line.BeforeFirst(':');
155 m_headers[left_str] = line.AfterFirst(':').Strip(wxString::both);
156 }
157 return true;
158 }
159
160 bool wxHTTP::Connect(const wxString& host, unsigned short port)
161 {
162 wxIPV4address *addr;
163
164 if (m_addr) {
165 delete m_addr;
166 m_addr = NULL;
167 Close();
168 }
169
170 m_addr = addr = new wxIPV4address();
171
172 if (!addr->Hostname(host)) {
173 delete m_addr;
174 m_addr = NULL;
175 m_perr = wxPROTO_NETERR;
176 return false;
177 }
178
179 if ( port )
180 addr->Service(port);
181 else if (!addr->Service(wxT("http")))
182 addr->Service(80);
183
184 SetHeader(wxT("Host"), host);
185
186 return true;
187 }
188
189 bool wxHTTP::Connect(wxSockAddress& addr, bool WXUNUSED(wait))
190 {
191 if (m_addr) {
192 delete m_addr;
193 Close();
194 }
195
196 m_addr = addr.Clone();
197
198 wxIPV4address *ipv4addr = wxDynamicCast(&addr, wxIPV4address);
199 if (ipv4addr)
200 SetHeader(wxT("Host"), ipv4addr->OrigHostname());
201
202 return true;
203 }
204
205 bool wxHTTP::BuildRequest(const wxString& path, wxHTTP_Req req)
206 {
207 const wxChar *request;
208
209 switch (req)
210 {
211 case wxHTTP_GET:
212 request = wxT("GET");
213 break;
214
215 case wxHTTP_POST:
216 request = wxT("POST");
217 if ( GetHeader( wxT("Content-Length") ).IsNull() )
218 SetHeader( wxT("Content-Length"), wxString::Format( wxT("%lu"), (unsigned long)m_post_buf.Len() ) );
219 break;
220
221 default:
222 return false;
223 }
224
225 m_http_response = 0;
226
227 // If there is no User-Agent defined, define it.
228 if (GetHeader(wxT("User-Agent")).IsNull())
229 SetHeader(wxT("User-Agent"), wxT("wxWidgets 2.x"));
230
231 SaveState();
232
233 // we may use non blocking sockets only if we can dispatch events from them
234 SetFlags( wxIsMainThread() && wxApp::IsMainLoopRunning() ? wxSOCKET_NONE
235 : wxSOCKET_BLOCK );
236 Notify(false);
237
238 wxString buf;
239 buf.Printf(wxT("%s %s HTTP/1.0\r\n"), request, path.c_str());
240 const wxWX2MBbuf pathbuf = wxConvLocal.cWX2MB(buf);
241 Write(pathbuf, strlen(wxMBSTRINGCAST pathbuf));
242 SendHeaders();
243 Write("\r\n", 2);
244
245 if ( req == wxHTTP_POST ) {
246 Write(m_post_buf.mbc_str(), m_post_buf.Len());
247 m_post_buf = wxEmptyString;
248 }
249
250 wxString tmp_str;
251 m_perr = ReadLine(this, tmp_str);
252 if (m_perr != wxPROTO_NOERR) {
253 RestoreState();
254 return false;
255 }
256
257 if (!tmp_str.Contains(wxT("HTTP/"))) {
258 // TODO: support HTTP v0.9 which can have no header.
259 // FIXME: tmp_str is not put back in the in-queue of the socket.
260 SetHeader(wxT("Content-Length"), wxT("-1"));
261 SetHeader(wxT("Content-Type"), wxT("none/none"));
262 RestoreState();
263 return true;
264 }
265
266 wxStringTokenizer token(tmp_str,wxT(' '));
267 wxString tmp_str2;
268 bool ret_value;
269
270 token.NextToken();
271 tmp_str2 = token.NextToken();
272
273 m_http_response = wxAtoi(tmp_str2);
274
275 switch (tmp_str2[0u])
276 {
277 case wxT('1'):
278 /* INFORMATION / SUCCESS */
279 break;
280
281 case wxT('2'):
282 /* SUCCESS */
283 break;
284
285 case wxT('3'):
286 /* REDIRECTION */
287 break;
288
289 default:
290 m_perr = wxPROTO_NOFILE;
291 RestoreState();
292 return false;
293 }
294
295 ret_value = ParseHeaders();
296 RestoreState();
297 return ret_value;
298 }
299
300 class wxHTTPStream : public wxSocketInputStream
301 {
302 public:
303 wxHTTP *m_http;
304 size_t m_httpsize;
305 unsigned long m_read_bytes;
306
307 wxHTTPStream(wxHTTP *http) : wxSocketInputStream(*http), m_http(http) {}
308 size_t GetSize() const { return m_httpsize; }
309 virtual ~wxHTTPStream(void) { m_http->Abort(); }
310
311 protected:
312 size_t OnSysRead(void *buffer, size_t bufsize);
313
314 DECLARE_NO_COPY_CLASS(wxHTTPStream)
315 };
316
317 size_t wxHTTPStream::OnSysRead(void *buffer, size_t bufsize)
318 {
319 if (m_httpsize > 0 && m_read_bytes >= m_httpsize)
320 {
321 m_lasterror = wxSTREAM_EOF;
322 return 0;
323 }
324
325 size_t ret = wxSocketInputStream::OnSysRead(buffer, bufsize);
326 m_read_bytes += ret;
327
328 if (m_httpsize==(size_t)-1 && m_lasterror == wxSTREAM_READ_ERROR )
329 {
330 // if m_httpsize is (size_t) -1 this means read until connection closed
331 // which is equivalent to getting a READ_ERROR, for clients however this
332 // must be translated into EOF, as it is the expected way of signalling
333 // end end of the content
334 m_lasterror = wxSTREAM_EOF ;
335 }
336
337 return ret;
338 }
339
340 bool wxHTTP::Abort(void)
341 {
342 return wxSocketClient::Close();
343 }
344
345 wxInputStream *wxHTTP::GetInputStream(const wxString& path)
346 {
347 wxHTTPStream *inp_stream;
348
349 wxString new_path;
350
351 m_perr = wxPROTO_CONNERR;
352 if (!m_addr)
353 return NULL;
354
355 // We set m_connected back to false so wxSocketBase will know what to do.
356 #ifdef __WXMAC__
357 wxSocketClient::Connect(*m_addr , false );
358 wxSocketClient::WaitOnConnect(10);
359
360 if (!wxSocketClient::IsConnected())
361 return NULL;
362 #else
363 if (!wxProtocol::Connect(*m_addr))
364 return NULL;
365 #endif
366
367 if (!BuildRequest(path, m_post_buf.empty() ? wxHTTP_GET : wxHTTP_POST))
368 return NULL;
369
370 inp_stream = new wxHTTPStream(this);
371
372 if (!GetHeader(wxT("Content-Length")).empty())
373 inp_stream->m_httpsize = wxAtoi(WXSTRINGCAST GetHeader(wxT("Content-Length")));
374 else
375 inp_stream->m_httpsize = (size_t)-1;
376
377 inp_stream->m_read_bytes = 0;
378
379 Notify(false);
380 SetFlags(wxSOCKET_BLOCK | wxSOCKET_WAITALL);
381
382 return inp_stream;
383 }
384
385 #endif // wxUSE_PROTOCOL_HTTP
386