netwerk/test/TestUDPSocketProvider.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is UDP Socket Provider unit test.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Mook <mook.moz+cvs.mozilla.org@gmail.com>.
  18  * Portions created by the Initial Developer are Copyright (C) 2007
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 #include "stdio.h"
  38 #include "TestCommon.h"
  39 #include "nsCOMPtr.h"
  40 #include "nsIServiceManager.h"
  41 #include "nsIComponentRegistrar.h"
  42 #include "nspr.h"
  43 #include "nsServiceManagerUtils.h"
  44 #include "nsISocketTransportService.h"
  45 #include "nsISocketTransport.h"
  46 #include "nsIOutputStream.h"
  47 #include "nsIInputStream.h"
  48
  49 #define UDP_PORT 9050
  50
  51 #define UDP_ASSERT(condition, message) \
  52     PR_BEGIN_MACRO                     \
  53     NS_ASSERTION(condition, message);  \
  54     if (!(condition)) {                \
  55         returnCode = -1;               \
  56         break;                         \
  57     }                                  \
  58     PR_END_MACRO
  59
  60 #define UDP_ASSERT_PRSTATUS(message) \
  61     PR_BEGIN_MACRO \
  62     NS_ASSERTION(status == PR_SUCCESS, message); \
  63     if (status != PR_SUCCESS) { \
  64         PRErrorCode err = PR_GetError(); \
  65         fprintf(stderr, \
  66                 "FAIL nspr: %s: (%08x) %s\n", \
  67                 message, \
  68                 err, \
  69                 PR_ErrorToString(err, PR_LANGUAGE_I_DEFAULT)); \
  70         returnCode = -1; \
  71         break; \
  72     } \
  73     PR_END_MACRO
  74
  75 #define UDP_ASSERT_NSRESULT(message) \
  76     PR_BEGIN_MACRO \
  77     NS_ASSERTION(NS_SUCCEEDED(rv), message); \
  78     if (NS_FAILED(rv)) { \
  79         fprintf(stderr, "FAIL UDPSocket: %s: %08x\n", \
  80                 message, rv); \
  81         returnCode = -1; \
  82         break; \
  83     } \
  84     PR_END_MACRO
  85
  86 int
  87 main(int argc, char* argv[])
  88 {
  89     if (test_common_init(&argc, &argv) != 0)
  90         return -1;
  91
  92     int returnCode = 0;
  93     nsresult rv = NS_OK;
  94     PRFileDesc *serverFD = nsnull;
  95
  96     do { // act both as a scope for nsCOMPtrs to be released before XPCOM
  97          // shutdown, as well as a easy way to abort the test
  98         PRStatus status = PR_SUCCESS;
  99
 100         nsCOMPtr<nsIServiceManager> servMan;
 101         NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull);
 102         nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
 103         UDP_ASSERT(registrar, "Null nsIComponentRegistrar");
 104         if (registrar)
 105             registrar->AutoRegister(nsnull);
 106
 107         // listen for a incoming UDP connection on localhost
 108         serverFD = PR_OpenUDPSocket(PR_AF_INET);
 109         UDP_ASSERT(serverFD, "Cannot open UDP socket for listening");
 110
 111         PRSocketOptionData socketOptions;
 112         socketOptions.option = PR_SockOpt_Nonblocking;
 113         socketOptions.value.non_blocking = PR_FALSE;
 114         status = PR_SetSocketOption(serverFD, &socketOptions);
 115         UDP_ASSERT_PRSTATUS("Failed to set server socket as blocking");
 116
 117         PRNetAddr addr;
 118         status = PR_InitializeNetAddr(PR_IpAddrLoopback, UDP_PORT, &addr);
 119         UDP_ASSERT_PRSTATUS("Failed to initialize loopback address");
 120
 121         status = PR_Bind(serverFD, &addr);
 122         UDP_ASSERT_PRSTATUS("Failed to bind server socket");
 123
 124         // dummy IOService to get around bug 379890
 125         nsCOMPtr<nsISupports> ios =
 126             do_GetService("@mozilla.org/network/io-service;1");
 127
 128         // and have a matching UDP connection for the client
 129         nsCOMPtr<nsISocketTransportService> sts =
 130             do_GetService("@mozilla.org/network/socket-transport-service;1", &rv);
 131         UDP_ASSERT_NSRESULT("Cannot get socket transport service");
 132
 133         nsCOMPtr<nsISocketTransport> transport;
 134         const char *protocol = "udp";
 135         rv = sts->CreateTransport(&protocol, 1, NS_LITERAL_CSTRING("localhost"),
 136                                   UDP_PORT, nsnull, getter_AddRefs(transport));
 137         UDP_ASSERT_NSRESULT("Cannot create transport");
 138
 139         PRUint32 count, read;
 140         const PRUint32 data = 0xFF0056A9;
 141
 142         // write to the output stream
 143         nsCOMPtr<nsIOutputStream> outstream;
 144         rv = transport->OpenOutputStream(nsITransport::OPEN_BLOCKING,
 145                                          0, 0, getter_AddRefs(outstream));
 146         UDP_ASSERT_NSRESULT("Cannot open output stream");
 147
 148         rv = outstream->Write((const char*)&data, sizeof(PRUint32), &count);
 149         UDP_ASSERT_NSRESULT("Cannot write to output stream");
 150         UDP_ASSERT(count == sizeof(PRUint32),
 151                    "Did not write enough bytes to output stream");
 152
 153         // read from NSPR to check it's the same
 154         count = PR_RecvFrom(serverFD, &read, sizeof(PRUint32), 0, &addr, 1);
 155         UDP_ASSERT(count == sizeof(PRUint32),
 156                    "Did not read enough bytes from NSPR");
 157         status = (read == data ? PR_SUCCESS : PR_FAILURE);
 158         UDP_ASSERT_PRSTATUS("Did not read expected data from NSPR");
 159
 160         // write to NSPR
 161         count = PR_SendTo(serverFD, &data, sizeof(PRUint32), 0, &addr, 1);
 162         status = (count == sizeof(PRUint32) ? PR_SUCCESS : PR_FAILURE);
 163         UDP_ASSERT_PRSTATUS("Did not write enough bytes to NSPR");
 164
 165         // read from stream
 166         nsCOMPtr<nsIInputStream> instream;
 167         rv = transport->OpenInputStream(nsITransport::OPEN_BLOCKING,
 168                                         0, 0, getter_AddRefs(instream));
 169         UDP_ASSERT_NSRESULT("Cannot open input stream");
 170
 171         rv = instream->Read((char*)&read, sizeof(PRUint32), &count);
 172         UDP_ASSERT_NSRESULT("Cannot read from input stream");
 173         UDP_ASSERT(count == sizeof(PRUint32),
 174                    "Did not read enough bytes from input stream");
 175         UDP_ASSERT(read == data, "Did not read expected data from stream");
 176
 177     } while (false); // release all XPCOM things
 178     if (serverFD) {
 179         PRStatus status = PR_Close(serverFD);
 180         if (status != PR_SUCCESS) {
 181             PRErrorCode err = PR_GetError();
 182             fprintf(stderr, "FAIL: Cannot close server: (%08x) %s\n",
 183                     err, PR_ErrorToString(err, PR_LANGUAGE_I_DEFAULT));
 184         }
 185     }
 186     rv = NS_ShutdownXPCOM(nsnull);
 187     NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
 188
 189     return returnCode;
 190 }
 191