mozilla
/
pjs
зеркало из https://github.com/mozilla/pjs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

fixes bug 92928 "Server socket support in Necko" r=dougt sr=bzbarsky

This commit is contained in:
darin%meer.net 2003-11-15 00:13:59 +00:00
Родитель 82a585b053
Коммит 8b29fff90c
11 изменённых файлов: 951 добавлений и 0 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
netwerk/base/public/Makefile.in
Просмотреть файл

@ -66,6 +66,7 @@ XPIDLSRCS = \
nsITransport.idl \
nsISocketTransport.idl \
nsISocketTransportService.idl \
nsIServerSocket.idl \
nsIResumableChannel.idl \
nsIResumableEntityID.idl \
nsIRequestObserverProxy.idl \

167
netwerk/base/public/nsIServerSocket.idl Normal file
Просмотреть файл

@ -0,0 +1,167 @@
/* vim:set ts=4 sw=4 et cindent: */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla.
*
* The Initial Developer of the Original Code is IBM Corporation.
* Portions created by IBM Corporation are Copyright (C) 2003
* IBM Corporation. All Rights Reserved.
*
* Contributor(s):
* Darin Fisher <darin@meer.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsISupports.idl"
interface nsIServerSocketListener;
interface nsISocketTransport;
native PRNetAddr(union PRNetAddr);
[ptr] native PRNetAddrPtr(union PRNetAddr);
/**
* nsIServerSocket
*
* An interface to a server socket that can accept incoming connections.
*/
[scriptable, uuid(a5b64be0-d563-46bb-ae95-132e46fcd42f)]
interface nsIServerSocket : nsISupports
{
/**
* init
*
* This method initializes a server socket.
*
* @param aPort
* The port of the server socket. Pass -1 to indicate no preference,
* and a port will be selected automatically.
* @param aLoopbackOnly
* If true, the server socket will only respond to connections on the
* local loopback interface. Otherwise, it will accept connections
* from any interface. To specify a particular network interface,
* use initWithAddress.
* @param aBackLog
* The maximum length the queue of pending connections may grow to.
* This parameter may be silently limited by the operating system.
* Pass -1 to use the default value.
*/
void init(in long aPort, in boolean aLoopbackOnly, in long aBackLog);
/**
* initWithAddress
*
* This method initializes a server socket, and binds it to a particular
* local address (and hence a particular local network interface).
*
* @param aAddr
* The address to which this server socket should be bound.
* @param aBackLog
* The maximum length the queue of pending connections may grow to.
* This parameter may be silently limited by the operating system.
* Pass -1 to use the default value.
*/
[noscript] void initWithAddress([const] in PRNetAddrPtr aAddr, in long aBackLog);
/**
* close
*
* This method closes a server socket. This does not affect already
* connected client sockets (i.e., the nsISocketTransport instances
* created from this server socket). This will cause the onStopListening
* event to asynchronously fire with a status of NS_BINDING_ABORTED.
*/
void close();
/**
* asyncListen
*
* This method puts the server socket in the listening state. It will
* asynchronously listen for and accept client connections. The listener
* will be notified once for each client connection that is accepted. The
* listener's onSocketAccepted method will be called on the same thread
* that called asyncListen (the calling thread must have a nsIEventTarget).
*
* The listener will be passed a reference to an already connected socket
* transport (nsISocketTransport). See below for more details.
*
* @param aListener
* The listener to be notified when client connections are accepted.
*/
void asyncListen(in nsIServerSocketListener aListener);
/**
* Returns the port of this server socket.
*/
readonly attribute long port;
/**
* Returns the address of this server socket.
*/
[noscript] PRNetAddr getAddress();
};
/**
* nsIServerSocketListener
*
* This interface is notified whenever a server socket accepts a new connection.
* The transport is in the connected state, and read/write streams can be opened
* using the normal nsITransport API. The address of the client can be found by
* calling the nsISocketTransport::GetAddress method or by inspecting
* nsISocketTransport::GetHost, which returns a string representation of the
* client's IP address (NOTE: this may be an IPv4 or IPv6 string literal).
*/
[scriptable, uuid(836d98ec-fee2-4bde-b609-abd5e966eabd)]
interface nsIServerSocketListener : nsISupports
{
/**
* onSocketAccepted
*
* This method is called when a client connection is accepted.
*
* @param aServ
* The server socket.
* @param aTransport
* The connected socket transport.
*/
void onSocketAccepted(in nsIServerSocket aServ,
in nsISocketTransport aTransport);
/**
* onStopListening
*
* This method is called when the listening socket stops for some reason.
* The server socket is effectively dead after this notification.
*
* @param aServ
* The server socket.
* @param aStatus
* The reason why the server socket stopped listening. If the
* server socket was manually closed, then this value will be
* NS_BINDING_ABORTED.
*/
void onStopListening(in nsIServerSocket aServ, in nsresult aStatus);
};

1
netwerk/base/src/Makefile.in
Просмотреть файл

@ -59,6 +59,7 @@ CPPSRCS = \
nsStandardURL.cpp \
nsSocketTransport2.cpp \
nsSocketTransportService2.cpp \
nsServerSocket.cpp \
nsStreamListenerTee.cpp \
nsStreamLoader.cpp \
nsSyncStreamListener.cpp \

435
netwerk/base/src/nsServerSocket.cpp Normal file
Просмотреть файл

@ -0,0 +1,435 @@
/* vim:set ts=2 sw=2 et cindent: */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla.
*
* The Initial Developer of the Original Code is IBM Corporation.
* Portions created by IBM Corporation are Copyright (C) 2003
* IBM Corporation. All Rights Reserved.
*
* Contributor(s):
* Darin Fisher <darin@meer.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsIProxyObjectManager.h"
#include "nsIServiceManager.h"
#include "nsSocketTransport2.h"
#include "nsServerSocket.h"
#include "nsAutoLock.h"
#include "nsAutoPtr.h"
#include "nsNetError.h"
#include "nsNetCID.h"
#include "prnetdb.h"
#include "prio.h"
static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
//-----------------------------------------------------------------------------
typedef void (nsServerSocket:: *nsServerSocketFunc)(void);
struct nsServerSocketEvent : PLEvent
{
nsServerSocketEvent(nsServerSocket *s, nsServerSocketFunc f)
: func(f)
{
NS_ADDREF(s);
PL_InitEvent(this, s, EventHandler, EventCleanup);
}
PR_STATIC_CALLBACK(void *)
EventHandler(PLEvent *ev)
{
nsServerSocket *s = (nsServerSocket *) ev->owner;
nsServerSocketEvent *event = (nsServerSocketEvent *) ev;
nsServerSocketFunc func = event->func;
(s->*func)();
return nsnull;
}
PR_STATIC_CALLBACK(void)
EventCleanup(PLEvent *ev)
{
nsServerSocket *s = (nsServerSocket *) ev->owner;
NS_RELEASE(s);
delete (nsServerSocketEvent *) ev;
}
nsServerSocketFunc func;
};
static nsresult
PostEvent(nsServerSocket *s, nsServerSocketFunc func)
{
nsServerSocketEvent *ev = new nsServerSocketEvent(s, func);
if (!ev)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = gSocketTransportService->PostEvent(ev);
if (NS_FAILED(rv))
PL_DestroyEvent(ev);
return rv;
}
//-----------------------------------------------------------------------------
// nsServerSocket
//-----------------------------------------------------------------------------
nsServerSocket::nsServerSocket()
: mLock(nsnull)
, mFD(nsnull)
, mAttached(PR_FALSE)
{
mCondition = NS_OK;
mPollFlags = 0;
// we want to be able to access the STS directly, and it may not have been
// constructed yet. the STS constructor sets gSocketTransportService.
if (!gSocketTransportService)
{
nsCOMPtr<nsISocketTransportService> sts =
do_GetService(kSocketTransportServiceCID);
NS_ASSERTION(sts, "no socket transport service");
}
// make sure the STS sticks around as long as we do
NS_ADDREF(gSocketTransportService);
}
nsServerSocket::~nsServerSocket()
{
Close(); // just in case :)
if (mLock)
PR_DestroyLock(mLock);
// release our reference to the STS
nsSocketTransportService *serv = gSocketTransportService;
NS_RELEASE(serv);
}
void
nsServerSocket::OnMsgClose()
{
LOG(("nsServerSocket::OnMsgClose [this=%p]\n", this));
if (NS_FAILED(mCondition))
return;
// tear down socket. this signals the STS to detach our socket handler.
mCondition = NS_BINDING_ABORTED;
// if we are attached, then we'll close the socket in our OnSocketDetached.
// otherwise, call OnSocketDetached from here.
if (!mAttached)
OnSocketDetached(mFD);
}
void
nsServerSocket::OnMsgAttach()
{
LOG(("nsServerSocket::OnMsgAttach [this=%p]\n", this));
if (NS_FAILED(mCondition))
return;
mCondition = TryAttach();
// if we hit an error while trying to attach then bail...
if (NS_FAILED(mCondition))
{
NS_ASSERTION(!mAttached, "should not be attached already");
OnSocketDetached(mFD);
}
}
nsresult
nsServerSocket::TryAttach()
{
nsresult rv;
//
// find out if it is going to be ok to attach another socket to the STS.
// if not then we have to wait for the STS to tell us that it is ok.
// the notification is asynchronous, which means that when we could be
// in a race to call AttachSocket once notified. for this reason, when
// we get notified, we just re-enter this function. as a result, we are
// sure to ask again before calling AttachSocket. in this way we deal
// with the race condition. though it isn't the most elegant solution,
// it is far simpler than trying to build a system that would guarantee
// FIFO ordering (which wouldn't even be that valuable IMO). see bug
// 194402 for more info.
//
if (!gSocketTransportService->CanAttachSocket())
{
PLEvent *event = new nsServerSocketEvent(this, &nsServerSocket::OnMsgAttach);
if (!event)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = gSocketTransportService->NotifyWhenCanAttachSocket(event);
if (NS_FAILED(rv))
{
PL_DestroyEvent(event);
return rv;
}
}
//
// ok, we can now attach our socket to the STS for polling
//
rv = gSocketTransportService->AttachSocket(mFD, this);
if (NS_FAILED(rv))
return rv;
mAttached = PR_TRUE;
//
// now, configure our poll flags for listening...
//
mPollFlags = (PR_POLL_READ | PR_POLL_EXCEPT);
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsServerSocket::nsASocketHandler
//-----------------------------------------------------------------------------
void
nsServerSocket::OnSocketReady(PRFileDesc *fd, PRInt16 outFlags)
{
NS_ASSERTION(NS_SUCCEEDED(mCondition), "oops");
NS_ASSERTION(mFD == fd, "wrong file descriptor");
if (outFlags & (PR_POLL_ERR | PR_POLL_HUP | PR_POLL_NVAL))
{
NS_WARNING("error polling on listening socket");
mCondition = NS_ERROR_UNEXPECTED;
return;
}
PRFileDesc *clientFD;
PRNetAddr clientAddr;
clientFD = PR_Accept(mFD, &clientAddr, PR_INTERVAL_NO_WAIT);
if (!clientFD)
{
NS_WARNING("PR_Accept failed");
mCondition = NS_ERROR_UNEXPECTED;
}
else
{
nsRefPtr<nsSocketTransport> trans = new nsSocketTransport;
if (!trans)
mCondition = NS_ERROR_OUT_OF_MEMORY;
else
{
nsresult rv = trans->InitWithConnectedSocket(clientFD, &clientAddr);
if (NS_FAILED(rv))
mCondition = rv;
else
mListener->OnSocketAccepted(this, trans);
}
}
}
void
nsServerSocket::OnSocketDetached(PRFileDesc *fd)
{
// force a failure condition if none set; maybe the STS is shutting down :-/
if (NS_SUCCEEDED(mCondition))
mCondition = NS_ERROR_ABORT;
if (mFD)
{
NS_ASSERTION(mFD == fd, "wrong file descriptor");
PR_Close(mFD);
mFD = nsnull;
}
if (mListener)
{
mListener->OnStopListening(this, mCondition);
// need to atomically clear mListener. see our Close() method.
nsAutoLock lock(mLock);
mListener = nsnull;
}
}
//-----------------------------------------------------------------------------
// nsServerSocket::nsISupports
//-----------------------------------------------------------------------------
NS_IMPL_THREADSAFE_ISUPPORTS1(nsServerSocket, nsIServerSocket)
//-----------------------------------------------------------------------------
// nsServerSocket::nsIServerSocket
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsServerSocket::Init(PRInt32 aPort, PRBool aLoopbackOnly, PRInt32 aBackLog)
{
PRNetAddrValue val;
PRNetAddr addr;
if (aPort < 0)
aPort = 0;
if (aLoopbackOnly)
val = PR_IpAddrLoopback;
else
val = PR_IpAddrAny;
PR_SetNetAddr(val, PR_AF_INET, aPort, &addr);
return InitWithAddress(&addr, aBackLog);
}
NS_IMETHODIMP
nsServerSocket::InitWithAddress(const PRNetAddr *aAddr, PRInt32 aBackLog)
{
NS_ENSURE_TRUE(mFD == nsnull, NS_ERROR_ALREADY_INITIALIZED);
if (!mLock)
{
mLock = PR_NewLock();
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
}
//
// configure listening socket...
//
mFD = PR_OpenTCPSocket(aAddr->raw.family);
if (!mFD)
{
NS_WARNING("unable to create server socket");
return NS_ERROR_FAILURE;
}
PRSocketOptionData opt;
opt.option = PR_SockOpt_Reuseaddr;
opt.value.reuse_addr = PR_TRUE;
PR_SetSocketOption(mFD, &opt);
opt.option = PR_SockOpt_Nonblocking;
opt.value.non_blocking = PR_TRUE;
PR_SetSocketOption(mFD, &opt);
if (PR_Bind(mFD, aAddr) != PR_SUCCESS)
{
NS_WARNING("failed to bind socket");
goto fail;
}
if (aBackLog < 0)
aBackLog = 5; // seems like a reasonable default
if (PR_Listen(mFD, aBackLog) != PR_SUCCESS)
{
NS_WARNING("cannot listen on socket");
goto fail;
}
// get the resulting socket address, which may be different than what
// we passed to bind.
if (PR_GetSockName(mFD, &mAddr) != PR_SUCCESS)
{
NS_WARNING("cannot get socket name");
goto fail;
}
// wait until AsyncListen is called before polling the socket for
// client connections.
return NS_OK;
fail:
Close();
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsServerSocket::Close()
{
NS_ENSURE_TRUE(mLock, NS_ERROR_NOT_INITIALIZED);
{
nsAutoLock lock(mLock);
// we want to proxy the close operation to the socket thread if a listener
// has been set. otherwise, we should just close the socket here...
if (!mListener)
{
if (mFD)
{
PR_Close(mFD);
mFD = nsnull;
}
return NS_OK;
}
}
return PostEvent(this, &nsServerSocket::OnMsgClose);
}
NS_IMETHODIMP
nsServerSocket::AsyncListen(nsIServerSocketListener *aListener)
{
// ensuring mFD implies ensuring mLock
NS_ENSURE_TRUE(mFD, NS_ERROR_NOT_INITIALIZED);
NS_ENSURE_TRUE(mListener == nsnull, NS_ERROR_IN_PROGRESS);
{
nsAutoLock lock(mLock);
nsresult rv = NS_GetProxyForObject(NS_CURRENT_EVENTQ,
NS_GET_IID(nsIServerSocketListener),
aListener,
PROXY_ASYNC | PROXY_ALWAYS,
getter_AddRefs(mListener));
if (NS_FAILED(rv))
return rv;
}
return PostEvent(this, &nsServerSocket::OnMsgAttach);
}
NS_IMETHODIMP
nsServerSocket::GetPort(PRInt32 *aResult)
{
// no need to enter the lock here
PRUint16 port;
if (mAddr.raw.family == PR_AF_INET)
port = mAddr.inet.port;
else
port = mAddr.ipv6.port;
*aResult = (PRInt32) PR_ntohs(port);
return NS_OK;
}
NS_IMETHODIMP
nsServerSocket::GetAddress(PRNetAddr *aResult)
{
// no need to enter the lock here
memcpy(aResult, &mAddr, sizeof(mAddr));
return NS_OK;
}

78
netwerk/base/src/nsServerSocket.h Normal file
Просмотреть файл

@ -0,0 +1,78 @@
/* vim:set ts=2 sw=2 et cindent: */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla.
*
* The Initial Developer of the Original Code is IBM Corporation.
* Portions created by IBM Corporation are Copyright (C) 2003
* IBM Corporation. All Rights Reserved.
*
* Contributor(s):
* Darin Fisher <darin@meer.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsServerSocket_h__
#define nsServerSocket_h__
#include "nsIServerSocket.h"
#include "nsSocketTransportService2.h"
//-----------------------------------------------------------------------------
class nsServerSocket : public nsASocketHandler
, public nsIServerSocket
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSISERVERSOCKET
// nsASocketHandler methods:
virtual void OnSocketReady(PRFileDesc *fd, PRInt16 outFlags);
virtual void OnSocketDetached(PRFileDesc *fd);
nsServerSocket();
private:
virtual ~nsServerSocket();
void OnMsgClose();
void OnMsgAttach();
// try attaching our socket (mFD) to the STS's poll list.
nsresult TryAttach();
// lock protects access to mListener; so it is not cleared while being used.
PRLock *mLock;
PRFileDesc *mFD;
PRNetAddr mAddr;
nsCOMPtr<nsIServerSocketListener> mListener;
PRBool mAttached;
};
//-----------------------------------------------------------------------------
#endif // nsServerSocket_h__

52
netwerk/base/src/nsSocketTransport2.cpp
Просмотреть файл

@ -1,3 +1,4 @@
/* vim:set ts=4 sw=4 et cindent: */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
@ -761,9 +762,50 @@ nsSocketTransport::Init(const char **types, PRUint32 typeCount,
return NS_OK;
}
nsresult
nsSocketTransport::InitWithConnectedSocket(PRFileDesc *fd, const PRNetAddr *addr)
{
NS_ASSERTION(!mFD, "already initialized");
char buf[64];
PR_NetAddrToString(addr, buf, sizeof(buf));
mHost.Assign(buf);
PRUint16 port;
if (addr->raw.family == PR_AF_INET)
port = addr->inet.port;
else
port = addr->ipv6.port;
mPort = PR_ntohs(port);
memcpy(&mNetAddr, addr, sizeof(PRNetAddr));
mPollFlags = (PR_POLL_READ | PR_POLL_WRITE | PR_POLL_EXCEPT);
mState = STATE_TRANSFERRING;
mFD = fd;
mFDref = 1;
mFDconnected = 1;
// make sure new socket is non-blocking
PRSocketOptionData opt;
opt.option = PR_SockOpt_Nonblocking;
opt.value.non_blocking = PR_TRUE;
PR_SetSocketOption(mFD, &opt);
LOG(("nsSocketTransport::InitWithConnectedSocket [this=%p addr=%s:%hu]\n",
this, mHost.get(), mPort));
// jump to InitiateSocket to get ourselves attached to the STS poll list.
return PostEvent(MSG_RETRY_INIT_SOCKET);
}
nsresult
nsSocketTransport::PostEvent(PRUint32 type, nsresult status, nsISupports *param)
{
LOG(("nsSocketTransport::PostEvent [this=%p type=%u status=%x param=%p]\n",
this, type, status, param));
PLEvent *event = new nsSocketEvent(this, type, status, param);
if (!event)
return NS_ERROR_OUT_OF_MEMORY;
@ -952,6 +994,16 @@ nsSocketTransport::InitiateSocket()
return rv;
}
//
// if we already have a connected socket, then just attach and return.
//
if (mFD) {
rv = gSocketTransportService->AttachSocket(mFD, this);
if (NS_SUCCEEDED(rv))
mAttached = PR_TRUE;
return rv;
}
//
// create new socket fd, push io layers, etc.
//

7
netwerk/base/src/nsSocketTransport2.h
Просмотреть файл

@ -133,10 +133,17 @@ public:
nsSocketTransport();
// this method instructs the socket transport to open a socket of the
// given type(s) to the given host or proxy.
nsresult Init(const char **socketTypes, PRUint32 typeCount,
const nsACString &host, PRUint16 port,
nsIProxyInfo *proxyInfo);
// this method instructs the socket transport to use an already connected
// socket with the given address.
nsresult InitWithConnectedSocket(PRFileDesc *socketFD,
const PRNetAddr *addr);
// nsASocketHandler methods:
void OnSocketReady(PRFileDesc *, PRInt16 outFlags);
void OnSocketDetached(PRFileDesc *);

13
netwerk/build/nsNetCID.h
Просмотреть файл

@ -374,6 +374,19 @@
{0x92, 0xb6, 0x00, 0x10, 0x5a, 0x1b, 0x0d, 0x64} \
}
// component implementing nsIServerSocket
#define NS_SERVERSOCKET_CLASSNAME \
"nsServerSocket"
#define NS_SERVERSOCKET_CONTRACTID \
"@mozilla.org/network/server-socket;1"
#define NS_SERVERSOCKET_CID \
{ /* 2ec62893-3b35-48fa-ab1d-5e68a9f45f08 */ \
0x2ec62893, \
0x3b35, \
0x48fa, \
{0xab, 0x1d, 0x5e, 0x68, 0xa9, 0xf4, 0x5f, 0x08} \
}
#define NS_FILETRANSPORTSERVICE_CLASSNAME \
"nsFileTransportService"
#define NS_FILETRANSPORTSERVICE_CONTRACTID \

7
netwerk/build/nsNetModule.cpp
Просмотреть файл

@ -86,6 +86,9 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(nsStreamTransportService)
#undef LOG_ENABLED
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSocketTransportService, Init)
#include "nsServerSocket.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsServerSocket)
#include "nsAsyncStreamCopier.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsAsyncStreamCopier)
@ -588,6 +591,10 @@ static const nsModuleComponentInfo gNetModuleInfo[] = {
NS_SOCKETTRANSPORTSERVICE_CID,
NS_SOCKETTRANSPORTSERVICE_CONTRACTID,
nsSocketTransportServiceConstructor },
{ NS_SERVERSOCKET_CLASSNAME,
NS_SERVERSOCKET_CID,
NS_SERVERSOCKET_CONTRACTID,
nsServerSocketConstructor },
{ NS_SOCKETPROVIDERSERVICE_CLASSNAME,
NS_SOCKETPROVIDERSERVICE_CID,
NS_SOCKETPROVIDERSERVICE_CONTRACTID,

1
netwerk/test/Makefile.in
Просмотреть файл

@ -55,6 +55,7 @@ CPPSRCS = \
TestIOThreads.cpp \
TestOpen.cpp \
TestCookie.cpp \
TestServ.cpp \
$(NULL)
SIMPLE_PROGRAMS = $(CPPSRCS:.cpp=$(BIN_SUFFIX))

189
netwerk/test/TestServ.cpp Normal file
Просмотреть файл

@ -0,0 +1,189 @@
/* vim:set ts=4 sw=4 et cindent: */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla.
*
* The Initial Developer of the Original Code is IBM Corporation.
* Portions created by IBM Corporation are Copyright (C) 2003
* IBM Corporation. All Rights Reserved.
*
* Contributor(s):
* Darin Fisher <darin@meer.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include <stdlib.h>
#include "nsIServiceManager.h"
#include "nsIEventQueueService.h"
#include "nsIEventQueue.h"
#include "nsIServerSocket.h"
#include "nsISocketTransport.h"
#include "nsNetUtil.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "prlog.h"
#if defined(PR_LOGGING)
//
// set NSPR_LOG_MODULES=Test:5
//
static PRLogModuleInfo *gTestLog = nsnull;
#endif
#define LOG(args) PR_LOG(gTestLog, PR_LOG_DEBUG, args)
static PRBool gKeepRunning = PR_TRUE;
static nsIEventQueue* gEventQ = nsnull;
class MySocketListener : public nsIServerSocketListener
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSISERVERSOCKETLISTENER
MySocketListener() {}
virtual ~MySocketListener() {}
};
NS_IMPL_THREADSAFE_ISUPPORTS1(MySocketListener, nsIServerSocketListener)
NS_IMETHODIMP
MySocketListener::OnSocketAccepted(nsIServerSocket *serv,
nsISocketTransport *trans)
{
LOG(("MySocketListener::OnSocketAccepted [serv=%p trans=%p]\n", serv, trans));
nsCAutoString host;
PRInt32 port;
trans->GetHost(host);
trans->GetPort(&port);
LOG((" -> %s:%d\n", host.get(), port));
nsCOMPtr<nsIInputStream> input;
nsCOMPtr<nsIOutputStream> output;
nsresult rv;
rv = trans->OpenInputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(input));
if (NS_FAILED(rv))
return rv;
rv = trans->OpenOutputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(output));
if (NS_FAILED(rv))
return rv;
char buf[256];
PRUint32 n;
rv = input->Read(buf, sizeof(buf), &n);
if (NS_FAILED(rv))
return rv;
const char response[] = "HTTP/1.0 200 OK\r\nContent-Type: text/plain\r\n\r\nFooooopy!!\r\n";
rv = output->Write(response, sizeof(response), &n);
if (NS_FAILED(rv))
return rv;
input->Close();
output->Close();
return NS_OK;
}
NS_IMETHODIMP
MySocketListener::OnStopListening(nsIServerSocket *serv, nsresult status)
{
LOG(("MySocketListener::OnStopListening [serv=%p status=%x]\n", serv, status));
gKeepRunning = PR_FALSE;
return NS_OK;
}
static nsresult
MakeServer(PRInt32 port)
{
nsresult rv;
nsCOMPtr<nsIServerSocket> serv = do_CreateInstance(NS_SERVERSOCKET_CONTRACTID, &rv);
if (NS_FAILED(rv))
return rv;
rv = serv->Init(port, PR_TRUE, 5);
if (NS_FAILED(rv))
return rv;
rv = serv->GetPort(&port);
if (NS_FAILED(rv))
return rv;
LOG((" listening on port %d\n", port));
rv = serv->AsyncListen(new MySocketListener());
return rv;
}
int
main(int argc, char* argv[])
{
nsresult rv= (nsresult)-1;
if (argc < 2) {
printf("usage: %s <port>\n", argv[0]);
return -1;
}
#if defined(PR_LOGGING)
gTestLog = PR_NewLogModule("Test");
#endif
/*
* The following code only deals with XPCOM registration stuff. and setting
* up the event queues. Copied from TestSocketIO.cpp
*/
rv = NS_InitXPCOM2(nsnull, nsnull, nsnull);
if (NS_FAILED(rv)) return rv;
{
// Create the Event Queue for this thread...
nsCOMPtr<nsIEventQueueService> eqs =
do_GetService(NS_EVENTQUEUESERVICE_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
eqs->GetThreadEventQueue(NS_CURRENT_THREAD, &gEventQ);
rv = MakeServer(atoi(argv[1]));
if (NS_FAILED(rv)) {
LOG(("MakeServer failed [rv=%x]\n", rv));
return -1;
}
// Enter the message pump to allow the URL load to proceed.
while (gKeepRunning) {
PLEvent *event;
gEventQ->WaitForEvent(&event);
gEventQ->HandleEvent(event);
}
} // this scopes the nsCOMPtrs
// no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
NS_ShutdownXPCOM(nsnull);
return rv;
}