The Tor Browser / file comparison
comparison: netwerk/test/TestSocketIO.cpp
netwerk/test/TestSocketIO.cpp
- changeset 1
- ca08bd8f51b2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:245709e7ee63 |
|---|---|
| 1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
| 2 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 3 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 5 #include <stdio.h> | |
| 6 #include <signal.h> | |
| 7 | |
| 8 #ifdef WIN32 | |
| 9 #include <windows.h> | |
| 10 #endif | |
| 11 | |
| 12 #include "nspr.h" | |
| 13 #include "nscore.h" | |
| 14 #include "nsISocketTransportService.h" | |
| 15 #include "nsIEventQueueService.h" | |
| 16 #include "nsIServiceManager.h" | |
| 17 #include "nsITransport.h" | |
| 18 #include "nsIRequest.h" | |
| 19 #include "nsIStreamProvider.h" | |
| 20 #include "nsIStreamListener.h" | |
| 21 #include "nsIPipe.h" | |
| 22 #include "nsIOutputStream.h" | |
| 23 #include "nsIInputStream.h" | |
| 24 #include "nsCRT.h" | |
| 25 #include "nsCOMPtr.h" | |
| 26 #include "nsIByteArrayInputStream.h" | |
| 27 | |
| 28 #if defined(PR_LOGGING) | |
| 29 static PRLogModuleInfo *gTestSocketIOLog; | |
| 30 #define LOG(args) PR_LOG(gTestSocketIOLog, PR_LOG_DEBUG, args) | |
| 31 #else | |
| 32 #define LOG(args) | |
| 33 #endif | |
| 34 | |
| 35 static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID); | |
| 36 static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID); | |
| 37 | |
| 38 static PRTime gElapsedTime; | |
| 39 static int gKeepRunning = 1; | |
| 40 static nsIEventQueue* gEventQ = nullptr; | |
| 41 | |
| 42 // | |
| 43 //---------------------------------------------------------------------------- | |
| 44 // Test Listener | |
| 45 //---------------------------------------------------------------------------- | |
| 46 // | |
| 47 | |
| 48 class TestListener : public nsIStreamListener | |
| 49 { | |
| 50 public: | |
| 51 TestListener() {} | |
| 52 virtual ~TestListener() {} | |
| 53 | |
| 54 NS_DECL_ISUPPORTS | |
| 55 NS_DECL_NSIREQUESTOBSERVER | |
| 56 NS_DECL_NSISTREAMLISTENER | |
| 57 }; | |
| 58 | |
| 59 NS_IMPL_ISUPPORTS(TestListener, | |
| 60 nsIRequestObserver, | |
| 61 nsIStreamListener); | |
| 62 | |
| 63 NS_IMETHODIMP | |
| 64 TestListener::OnStartRequest(nsIRequest* request, nsISupports* context) | |
| 65 { | |
| 66 LOG(("TestListener::OnStartRequest\n")); | |
| 67 return NS_OK; | |
| 68 } | |
| 69 | |
| 70 NS_IMETHODIMP | |
| 71 TestListener::OnDataAvailable(nsIRequest* request, | |
| 72 nsISupports* context, | |
| 73 nsIInputStream *aIStream, | |
| 74 uint32_t aSourceOffset, | |
| 75 uint32_t aLength) | |
| 76 { | |
| 77 LOG(("TestListener::OnDataAvailable [offset=%u length=%u]\n", | |
| 78 aSourceOffset, aLength)); | |
| 79 char buf[1025]; | |
| 80 uint32_t amt; | |
| 81 while (1) { | |
| 82 aIStream->Read(buf, 1024, &amt); | |
| 83 if (amt == 0) | |
| 84 break; | |
| 85 buf[amt] = '\0'; | |
| 86 puts(buf); | |
| 87 } | |
| 88 return NS_OK; | |
| 89 } | |
| 90 | |
| 91 NS_IMETHODIMP | |
| 92 TestListener::OnStopRequest(nsIRequest* request, nsISupports* context, | |
| 93 nsresult aStatus) | |
| 94 { | |
| 95 LOG(("TestListener::OnStopRequest [aStatus=%x]\n", aStatus)); | |
| 96 gKeepRunning = 0; | |
| 97 return NS_OK; | |
| 98 } | |
| 99 | |
| 100 // | |
| 101 //---------------------------------------------------------------------------- | |
| 102 // Test Provider | |
| 103 //---------------------------------------------------------------------------- | |
| 104 // | |
| 105 | |
| 106 class TestProvider : public nsIStreamProvider | |
| 107 { | |
| 108 public: | |
| 109 TestProvider(char *data); | |
| 110 virtual ~TestProvider(); | |
| 111 | |
| 112 NS_DECL_ISUPPORTS | |
| 113 NS_DECL_NSIREQUESTOBSERVER | |
| 114 NS_DECL_NSISTREAMPROVIDER | |
| 115 | |
| 116 protected: | |
| 117 nsCOMPtr<nsIByteArrayInputStream> mData; | |
| 118 }; | |
| 119 | |
| 120 NS_IMPL_ISUPPORTS(TestProvider, | |
| 121 nsIStreamProvider, | |
| 122 nsIRequestObserver) | |
| 123 | |
| 124 TestProvider::TestProvider(char *data) | |
| 125 { | |
| 126 NS_NewByteArrayInputStream(getter_AddRefs(mData), data, strlen(data)); | |
| 127 LOG(("Constructing TestProvider [this=%p]\n", this)); | |
| 128 } | |
| 129 | |
| 130 TestProvider::~TestProvider() | |
| 131 { | |
| 132 LOG(("Destroying TestProvider [this=%p]\n", this)); | |
| 133 } | |
| 134 | |
| 135 NS_IMETHODIMP | |
| 136 TestProvider::OnStartRequest(nsIRequest* request, nsISupports* context) | |
| 137 { | |
| 138 LOG(("TestProvider::OnStartRequest [this=%p]\n", this)); | |
| 139 return NS_OK; | |
| 140 } | |
| 141 | |
| 142 NS_IMETHODIMP | |
| 143 TestProvider::OnStopRequest(nsIRequest* request, nsISupports* context, | |
| 144 nsresult aStatus) | |
| 145 { | |
| 146 LOG(("TestProvider::OnStopRequest [status=%x]\n", aStatus)); | |
| 147 | |
| 148 nsCOMPtr<nsIStreamListener> listener = do_QueryInterface(new TestListener()); | |
| 149 | |
| 150 if (NS_SUCCEEDED(aStatus)) { | |
| 151 nsCOMPtr<nsITransportRequest> treq = do_QueryInterface(request); | |
| 152 nsCOMPtr<nsITransport> transport; | |
| 153 treq->GetTransport(getter_AddRefs(transport)); | |
| 154 if (transport) { | |
| 155 nsCOMPtr<nsIRequest> readRequest; | |
| 156 transport->AsyncRead(listener, nullptr, 0, 0, 0, getter_AddRefs(readRequest)); | |
| 157 } | |
| 158 } else | |
| 159 gKeepRunning = 0; | |
| 160 | |
| 161 return NS_OK; | |
| 162 } | |
| 163 | |
| 164 NS_IMETHODIMP | |
| 165 TestProvider::OnDataWritable(nsIRequest *request, nsISupports *context, | |
| 166 nsIOutputStream *output, uint32_t offset, uint32_t count) | |
| 167 { | |
| 168 LOG(("TestProvider::OnDataWritable [offset=%u, count=%u]\n", offset, count)); | |
| 169 uint32_t writeCount; | |
| 170 nsresult rv = output->WriteFrom(mData, count, &writeCount); | |
| 171 // Zero bytes written on success indicates EOF | |
| 172 if (NS_SUCCEEDED(rv) && (writeCount == 0)) | |
| 173 return NS_BASE_STREAM_CLOSED; | |
| 174 return rv; | |
| 175 } | |
| 176 | |
| 177 // | |
| 178 //---------------------------------------------------------------------------- | |
| 179 // Synchronous IO | |
| 180 //---------------------------------------------------------------------------- | |
| 181 // | |
| 182 nsresult | |
| 183 WriteRequest(nsIOutputStream *os, const char *request) | |
| 184 { | |
| 185 LOG(("WriteRequest [request=%s]\n", request)); | |
| 186 uint32_t n; | |
| 187 return os->Write(request, strlen(request), &n); | |
| 188 } | |
| 189 | |
| 190 nsresult | |
| 191 ReadResponse(nsIInputStream *is) | |
| 192 { | |
| 193 uint32_t bytesRead; | |
| 194 char buf[2048]; | |
| 195 do { | |
| 196 is->Read(buf, sizeof(buf), &bytesRead); | |
| 197 if (bytesRead > 0) | |
| 198 fwrite(buf, 1, bytesRead, stdout); | |
| 199 } while (bytesRead > 0); | |
| 200 return NS_OK; | |
| 201 } | |
| 202 | |
| 203 // | |
| 204 //---------------------------------------------------------------------------- | |
| 205 // Startup... | |
| 206 //---------------------------------------------------------------------------- | |
| 207 // | |
| 208 | |
| 209 void | |
| 210 sighandler(int sig) | |
| 211 { | |
| 212 LOG(("got signal: %d\n", sig)); | |
| 213 NS_BREAK(); | |
| 214 } | |
| 215 | |
| 216 void | |
| 217 usage(char **argv) | |
| 218 { | |
| 219 printf("usage: %s [-sync] <host> <path>\n", argv[0]); | |
| 220 exit(1); | |
| 221 } | |
| 222 | |
| 223 int | |
| 224 main(int argc, char* argv[]) | |
| 225 { | |
| 226 nsresult rv; | |
| 227 | |
| 228 signal(SIGSEGV, sighandler); | |
| 229 | |
| 230 #if defined(PR_LOGGING) | |
| 231 gTestSocketIOLog = PR_NewLogModule("TestSocketIO"); | |
| 232 #endif | |
| 233 | |
| 234 if (argc < 3) | |
| 235 usage(argv); | |
| 236 | |
| 237 int i=0; | |
| 238 bool sync = false; | |
| 239 if (nsCRT::strcasecmp(argv[1], "-sync") == 0) { | |
| 240 if (argc < 4) | |
| 241 usage(argv); | |
| 242 sync = true; | |
| 243 i = 1; | |
| 244 } | |
| 245 | |
| 246 char *hostName = argv[1+i]; | |
| 247 char *fileName = argv[2+i]; | |
| 248 int port = 80; | |
| 249 | |
| 250 // Create the Event Queue for this thread... | |
| 251 nsCOMPtr<nsIEventQueueService> eventQService = | |
| 252 do_GetService(kEventQueueServiceCID, &rv); | |
| 253 if (NS_FAILED(rv)) { | |
| 254 NS_WARNING("failed to create: event queue service!"); | |
| 255 return rv; | |
| 256 } | |
| 257 | |
| 258 rv = eventQService->CreateMonitoredThreadEventQueue(); | |
| 259 if (NS_FAILED(rv)) { | |
| 260 NS_WARNING("failed to create: thread event queue!"); | |
| 261 return rv; | |
| 262 } | |
| 263 | |
| 264 eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, &gEventQ); | |
| 265 | |
| 266 // Create the Socket transport service... | |
| 267 nsCOMPtr<nsISocketTransportService> sts = | |
| 268 do_GetService(kSocketTransportServiceCID, &rv); | |
| 269 if (NS_FAILED(rv)) { | |
| 270 NS_WARNING("failed to create: socket transport service!"); | |
| 271 return rv; | |
| 272 } | |
| 273 | |
| 274 char *buffer = PR_smprintf("GET %s HTTP/1.1" CRLF | |
| 275 "host: %s" CRLF | |
| 276 "user-agent: Mozilla/5.0 (X11; N; Linux 2.2.16-22smp i686; en-US; m18) Gecko/20001220" CRLF | |
| 277 "accept: */*" CRLF | |
| 278 "accept-language: en" CRLF | |
| 279 "accept-encoding: gzip,deflate,compress,identity" CRLF | |
| 280 "keep-alive: 300" CRLF | |
| 281 "connection: keep-alive" CRLF | |
| 282 CRLF, | |
| 283 fileName, hostName); | |
| 284 LOG(("Request [\n%s]\n", buffer)); | |
| 285 | |
| 286 // Create the socket transport... | |
| 287 nsCOMPtr<nsITransport> transport; | |
| 288 rv = sts->CreateTransport(hostName, port, nullptr, 0, 0, getter_AddRefs(transport)); | |
| 289 if (NS_FAILED(rv)) { | |
| 290 NS_WARNING("failed to create: socket transport!"); | |
| 291 return rv; | |
| 292 } | |
| 293 | |
| 294 gElapsedTime = PR_Now(); | |
| 295 | |
| 296 if (!sync) { | |
| 297 nsCOMPtr<nsIRequest> request; | |
| 298 rv = transport->AsyncWrite(new TestProvider(buffer), nullptr, 0, 0, 0, getter_AddRefs(request)); | |
| 299 if (NS_FAILED(rv)) { | |
| 300 NS_WARNING("failed calling: AsyncWrite!"); | |
| 301 return rv; | |
| 302 } | |
| 303 | |
| 304 // Enter the message pump to allow the URL load to proceed. | |
| 305 while ( gKeepRunning ) { | |
| 306 PLEvent *gEvent; | |
| 307 gEventQ->WaitForEvent(&gEvent); | |
| 308 gEventQ->HandleEvent(gEvent); | |
| 309 } | |
| 310 } | |
| 311 else { | |
| 312 // synchronous write | |
| 313 { | |
| 314 nsCOMPtr<nsIOutputStream> os; | |
| 315 rv = transport->OpenOutputStream(0, 0, 0, getter_AddRefs(os)); | |
| 316 if (NS_FAILED(rv)) { | |
| 317 LOG(("OpenOutputStream failed [rv=%x]\n", rv)); | |
| 318 return rv; | |
| 319 } | |
| 320 rv = WriteRequest(os, buffer); | |
| 321 if (NS_FAILED(rv)) { | |
| 322 LOG(("WriteRequest failed [rv=%x]\n", rv)); | |
| 323 return rv; | |
| 324 } | |
| 325 } | |
| 326 // synchronous read | |
| 327 { | |
| 328 nsCOMPtr<nsIInputStream> is; | |
| 329 rv = transport->OpenInputStream(0, 0, 0, getter_AddRefs(is)); | |
| 330 if (NS_FAILED(rv)) { | |
| 331 LOG(("OpenInputStream failed [rv=%x]\n", rv)); | |
| 332 return rv; | |
| 333 } | |
| 334 rv = ReadResponse(is); | |
| 335 if (NS_FAILED(rv)) { | |
| 336 LOG(("ReadResponse failed [rv=%x]\n", rv)); | |
| 337 return rv; | |
| 338 } | |
| 339 } | |
| 340 } | |
| 341 | |
| 342 PRTime endTime; | |
| 343 endTime = PR_Now(); | |
| 344 LOG(("Elapsed time: %d\n", (int32_t)(endTime/1000UL - gElapsedTime/1000UL))); | |
| 345 | |
| 346 sts->Shutdown(); | |
| 347 return 0; | |
| 348 } | |
| 349 |
