netwerk/test/TestSocketIO.cpp

   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