epocnet.cpp

大名鼎鼎的远程登录软件putty的Symbian版源码

static int sk_tcp_write(Socket s, const char *data, int len);
static int sk_tcp_write_oob(Socket s, const char *data, int len);
static void sk_tcp_set_private_ptr(Socket s, void *ptr);
static void *sk_tcp_get_private_ptr(Socket s);
static void sk_tcp_set_frozen(Socket s, int is_frozen);
static const char *sk_tcp_socket_error(Socket s);

extern char *do_select(RSocketS *skt, int startup);

Socket sk_register(void *sock, Plug plug)
{
    static const struct socket_function_table fn_table = {
	sk_tcp_plug,
	sk_tcp_close,
	sk_tcp_write,
	sk_tcp_write_oob,
	sk_tcp_flush,
	sk_tcp_set_private_ptr,
	sk_tcp_get_private_ptr,
	sk_tcp_set_frozen,
	sk_tcp_socket_error
    };

    char *errstr;
    Actual_Socket ret;
    TInt err;

    /*
     * Create Socket structure.
     */
    ret = (Actual_Socket)smalloc(sizeof(struct Socket_tag));
    ret->fn = &fn_table;
    ret->error = NULL;
    ret->plug = plug;
    bufchain_init(&ret->output_data);
    ret->writable = 1;		       /* to start with */
    ret->sending_oob = 0;
    ret->frozen = 1;
    ret->frozen_readable = 0;
    ret->localhost_only = 0;	       /* unused, but best init anyway */
    ret->listening = 0;		       /* unused, but best init anyway */
    ret->pending_error = 0;
    ret->accepted=NULL;
    ret->killing=0;

    ret->s = (RSocketS *)sock;

    if (ret->s == INVALID_SOCKET) {
	ret->error = FormatError("Socket register", KInvalSocket);
	return (Socket) ret;
    }

    ret->s->estat=KRequestPending;
    ret->s->r=NULL;
    ret->s->s=NULL;
    ret->s->a=NULL;

    ret->oobinline = 0;
    errstr = do_select(ret->s, 1);
    if (errstr) {
	ret->error = errstr;
	return (Socket) ret;
    }

    TRAP(err,ret->s->r = CRecver::NewL((Socket)ret));
    ret->s->r->StartRecver();
    TRAP(err,ret->s->s = CSender::NewL((Socket)ret));

    add234(netStatics->iSocketTree, ret);

    return (Socket) ret;
}

Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
	      int nodelay, int keepalive, Plug plug)
{
    static const struct socket_function_table fn_table = {
	sk_tcp_plug,
	sk_tcp_close,
	sk_tcp_write,
	sk_tcp_write_oob,
	sk_tcp_flush,
	sk_tcp_set_private_ptr,
	sk_tcp_get_private_ptr,
	sk_tcp_set_frozen,
	sk_tcp_socket_error
    };

    TInt err;
    TInetAddr locaddr;
    TRequestStatus cstat;
    char *errstr;
    Actual_Socket ret;
    short localport;

#ifdef DEBUGLOG
    TBuf<40> buf;
    char buf8[41];
    addr->address->Output(buf);
    DesToString(buf, buf8);
    LOGF(("sk_new: Connecting to %s, port %d, family %d", buf8, port, addr->family));
#endif
    
    /*
     * Create Socket structure.
     */
    ret = (Actual_Socket) smalloc(sizeof(struct Socket_tag));
    ret->fn = &fn_table;
    ret->error = NULL;
    ret->plug = plug;
    bufchain_init(&ret->output_data);
    ret->connected = 0;		       /* to start with */
    ret->writable = 0;		       /* to start with */
    ret->sending_oob = 0;
    ret->frozen = 0;
    ret->frozen_readable = 0;
    ret->localhost_only = 0;	       /* unused, but best init anyway */
    ret->listening = 0;		       /* unused, but best init anyway */
    ret->pending_error = 0;
    ret->accepted=NULL;
    ret->killing=0;

    /*
     * Open socket.
     */
    ret->s = new RSocketS;
    if (ret->s == NULL) {
	ret->error = "Not enough memory to allocate RSocketS";
	return (Socket) ret;
    }
    ret->s->id=netStatics->iNextId++;
    ret->s->estat=KRequestPending;
    ret->s->r=NULL;
    ret->s->s=NULL;
    ret->s->a=NULL;

    if ( netStatics->iWatcher ) {
        netStatics->iWatcher->SocketOpened();
    }

    err=ret->s->Open(netStatics->iSocketServ, KAfInet, KSockStream,
                     KProtocolInetTcp);
    if (err!=KErrNone) {
	    ret->error = FormatError("Socket open", err);
            LOGF(("sk_new: Open failed: %d, %s", err, ret->error));
	    return (Socket) ret;
    }

    ret->oobinline = oobinline;
    if (oobinline) {
	err=ret->s->SetOpt(KSoTcpOobInline, KSolInetTcp, 1);
	if (err!=KErrNone) {
	    ret->error = FormatError("Socket OOB inline", err);
            LOGF(("sk_new: SetOpt for KSoTcpOobInline failed: %d, %s", err, ret->error));
	    return (Socket) ret;
        }
    }

    if (nodelay) {
	err=ret->s->SetOpt(KSoTcpNoDelay, KSolInetTcp, 1);
	if (err!=KErrNone) {
	    ret->error = FormatError("Socket no delay", err);
            LOGF(("sk_new: SetOpt for KSoTcpNoDelay failed: %d, %s", err, ret->error));
	    return (Socket) ret;
        }
    }

    if ( keepalive ) {
        err = ret->s->SetOpt(KSoTcpKeepAlive, KSolInetTcp, 1);
        if ( err != KErrNone ) {
	    ret->error = FormatError("Socket keep alive", err);
            LOGF(("sk_new: SetOpt for KSoTcpKeepAlive failed: %d, %s", err, ret->error));
	    return (Socket) ret;
        }
    }

    /*
     * Bind to local address.
     */
    if (privport)
	localport = 1023;	       /* count from 1023 downwards */
    else
	localport = 0;		       /* just use port 0 (ie winsock picks) */

    /* Loop round trying to bind */
    while (localport >= 0) {

#ifdef IPV6
        if ( addr->family == KAfInet6 ) {
            locaddr = TInetAddr(KInet6AddrNone, localport);
        } else {
            locaddr = TInetAddr(KInetAddrAny, localport);
        }
#else
	locaddr = TInetAddr(KInetAddrAny, localport);
#endif
	err = ret->s->Bind(locaddr);
	if (err == KErrNone) break;		       /* done */
	else {
	    if (err != KErrInUse) break; /* failed, for a bad reason */
	}

	if (localport == 0)
	    break;		       /* we're only looping once */
	localport--;
	if (localport == 0)
	    break;		       /* we might have got to the end */
    }

    if (err!=KErrNone) {
	ret->error = FormatError("Socket bind", err);
        LOGF(("sk_new: Bind failed: %d, %s", err, ret->error));
	return (Socket) ret;
    }

    /*
     * Connect to remote address.
     */

    TInetAddr tempaddr(*addr->address);
    tempaddr.SetPort(port);
    ret->s->Connect(tempaddr, cstat);
    // FIXME: This is potentially unsafe -- it could eat events from the
    // active scheduler
    User::WaitForRequest(cstat);	// We block it here to ease our problem in the active objects.
    if ( cstat != KErrNone ) {
	    ret->error = FormatError("Socket connect", cstat.Int());
            LOGF(("sk_new: Connect failed: %d, %s", cstat.Int(), ret->error));
	    return (Socket) ret;
	}

    ret->connected = 1;
    ret->writable = 1;

    errstr = do_select(ret->s, 1);
    if (errstr) {
	ret->error = errstr;
	return (Socket) ret;
    }

    TRAP(err, ret->s->r = CRecver::NewL((Socket)ret));
    ret->s->r->StartRecver();
    TRAP(err,ret->s->s = CSender::NewL((Socket)ret));

    add234(netStatics->iSocketTree, ret);

    sk_addr_free(addr);

    LOGF(("sk_new: Done"));
    return (Socket) ret;
}

Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only)
{
    static const struct socket_function_table fn_table = {
	sk_tcp_plug,
	sk_tcp_close,
	sk_tcp_write,
	sk_tcp_write_oob,
	sk_tcp_flush,
	sk_tcp_set_private_ptr,
	sk_tcp_get_private_ptr,
	sk_tcp_set_frozen,
	sk_tcp_socket_error
    };

    TInt err;
    TInetAddr locaddr;
//    char *errstr;
    Actual_Socket ret;
    LOGF(("sk_newlistener: Starting"));

    /*
     * Create Socket structure.
     */
    ret = (Actual_Socket)smalloc(sizeof(struct Socket_tag));
    ret->fn = &fn_table;
    ret->error = NULL;
    ret->plug = plug;
    bufchain_init(&ret->output_data);
    ret->writable = 0;		       /* to start with */
    ret->sending_oob = 0;
    ret->frozen = 0;
    ret->frozen_readable = 0;
    ret->localhost_only = local_host_only;
    ret->listening = 1;
    ret->pending_error = 0;
    ret->accepted=NULL;
    ret->killing=0;

    /*
     * Open socket.
     */
    ret->s = new RSocketS;
    if (ret->s == NULL) {
	ret->error = "Not enough memory to allocate RSocketS";
	return (Socket) ret;
    }
    ret->s->id=netStatics->iNextId++;
    ret->s->estat=KRequestPending;
    ret->s->r=NULL;
    ret->s->s=NULL;
    ret->s->a=NULL;

    if ( netStatics->iWatcher ) {
        netStatics->iWatcher->SocketOpened();
    }

    err=ret->s->Open(netStatics->iSocketServ, KAfInet, KSockStream,
                     KUndefinedProtocol);
    if (err!=KErrNone) {
        ret->error = FormatError("Socket open", err);
        LOGF(("sk_newlistener: Open failed: %d, %s", err, ret->error));
        return (Socket) ret;
    }

    ret->oobinline = 0;

    ret->s->SetOpt(KSoReuseAddr, KSolInetIp, 1);

    // Try to bind to a specified source address
    int gotaddr = 0;
    if ( srcaddr ) {
        TBuf<16> buf;
        locaddr = TInetAddr(port);
        StringToDes(srcaddr, buf);
        if ( locaddr.Input(buf) == KErrNone ) {
            gotaddr = 1;
        }
    }
    if ( !gotaddr ) {
        locaddr = TInetAddr(local_host_only ? KInetAddrLoop : KInetAddrAny, port);
    }
    err = ret->s->Bind(locaddr);
    if (err) {
	ret->error = FormatError("Socket bind", err);
        LOGF(("sk_newlistener: Bind failed: %d, %s", err, ret->error));
	return (Socket) ret;
    }


    err = ret->s->Listen(3);
    if (err!=KErrNone) {
        ret->s->Close();
	ret->error = FormatError("Socket listen", err);
	return (Socket) ret;
    }

    TRAP(err,ret->s->a = CAcceptor::NewL((Socket)ret));
    ret->s->a->StartAcceptor();

    add234(netStatics->iSocketTree, ret);

    LOGF(("sk_newlistener: Done"));
    return (Socket) ret;
}

static void sk_tcp_close(Socket sock)
{
    Actual_Socket s = (Actual_Socket) sock;

    if (bufchain_size(&(s->output_data))>0 && s->killing==0)
    {
	    s->killing=1;
	    return;
    }
    if ( netStatics->iWatcher ) {
        netStatics->iWatcher->SocketClosed();
    }
    del234(netStatics->iSocketTree, s);
    do_select(s->s, 0);
    if (s->accepted!=NULL) delete s->accepted;
    if (s->s->r!=NULL) delete s->s->r;
    if (s->s->s!=NULL) delete s->s->s;
    if (s->s->a!=NULL) delete s->s->a;
    s->s->Close();
    delete s->s;
    sfree(s);
}

static int sk_tcp_write(Socket sock, const char *buf, int len)
{
    Actual_Socket s = (Actual_Socket) sock;

    /*
     * Add the data to the buffer list on the socket.
     */
    bufchain_add(&s->output_data, buf, len);

    /*
     * Now try sending from the start of the buffer list.
     */
    if (s->writable) s->s->s->Sendit();

    return bufchain_size(&s->output_data);
}

static int sk_tcp_write_oob(Socket sock, const char *buf, int len)
{
    Actual_Socket s = (Actual_Socket) sock;

    /*
     * Replace the buffer list on the socket with the data.
     */
    bufchain_clear(&s->output_data);
    __ASSERT_ALWAYS(len <= (int)sizeof(s->oobdata),User::Leave(KErrOverflow));
    memcpy(s->oobdata, buf, len);
    s->sending_oob = len;

    /*
     * Now try sending from the start of the buffer list.
     */
    if (s->writable) s->s->s->Sendit();

    return s->sending_oob;
}

int select_result(RSocketS *wParam, int /*lParam*/)
{
    // FIXME: I guess this function isn't used for anything?
//    TInt err;
    Actual_Socket s;
//    TInt atmark;

    s = (Actual_Socket) find234(netStatics->iSocketTree, (void *) wParam,
                                cmpforsearch);
    if (!s) return 1;		       /* boggle */
    return 0;