datagramprotocol.c

Nucleus_2_kvm_Hello 是kvm移植到Nucleus系统的源代码。。。好东西啊

/*=========================================================================
 * FUNCTION:      getIpNumber()
 * CLASS:         com.sun.cldc.io.j2me.datagram.Protocol
 * TYPE:          virtual native function
 * OVERVIEW:      Translate a host name into an ip address
 * INTERFACE (operand stack manipulation):
 *   parameters:  this, string
 *   returns:     int
 *=======================================================================*/

ASYNC_FUNCTION_START(Java_com_sun_cldc_io_j2me_datagram_Protocol_getIpNumber)
{
    STRING_INSTANCE string    = ASYNC_popStackAsType(STRING_INSTANCE);
    INSTANCE        instance  = ASYNC_popStackAsType(INSTANCE);
    char            name[MAX_HOST_LENGTH];
    int ipn;
    long stringlen;

    (void)instance;

    ASYNC_enableGarbageCollection();

    stringlen = string->length + 1;
    (void)getStringContentsSafely(string, name, stringlen);

    ipn = prim_com_sun_cldc_io_j2me_datagram_Protocol_getIpNumber(name);
    NDEBUG2("datagram::getIpNumber name='%s' ipn=%lx\n", name,
            (long)ipn);

    ASYNC_disableGarbageCollection();

    ASYNC_pushStack(ipn);
}
ASYNC_FUNCTION_END

/*=========================================================================
 * FUNCTION:      send0()
 * CLASS:         com.sun.cldc.io.j2me.datagram.Protocol
 * TYPE:          virtual native function
 * OVERVIEW:      Send a datagram
 * INTERFACE (operand stack manipulation):
 *   parameters:  this, iaddr, port, buffer, offset, length
 *   returns:     length
 *=======================================================================*/

ASYNC_FUNCTION_START(Java_com_sun_cldc_io_j2me_datagram_Protocol_send0)
{
    long            length   = ASYNC_popStack();
    long            offset   = ASYNC_popStack();
    BYTEARRAY       array    = ASYNC_popStackAsType(BYTEARRAY);
    long            port     = ASYNC_popStack();
    long            ipnumber = ASYNC_popStack();
    INSTANCE        instance = ASYNC_popStackAsType(INSTANCE);

    long fd;
    int  res;
    aiocb->instance = instance;
    fd = getSocketHandle(aiocb);

    NDEBUG6("datagram::send0 b=%lx o=%ld l=%ld p=%ld ip=%lx fd=%ld\n",
            (long)array, offset, length, port, ipnumber, fd);

#if ASYNCHRONOUS_NATIVE_FUNCTIONS
    {
        char buffer[ASYNC_BUFFER_SIZE];
       /*
        * If necessary reduce the length to that of the buffer. The
        * Java code will call back with more I/O operations if needed.
        */
        if(length > ASYNC_BUFFER_SIZE) {
            ASYNC_raiseException("java/io/IllegalArgumentException");
        } else {
            memcpy(buffer, (char *)array->bdata + offset, length);

            ASYNC_enableGarbageCollection();
            res = prim_com_sun_cldc_io_j2me_datagram_Protocol_send0(fd,
                                      ipnumber, port, buffer, length);
            ASYNC_disableGarbageCollection();
        }
    }
#else
    res = prim_com_sun_cldc_io_j2me_datagram_Protocol_send0(fd,
           ipnumber, port, (char*)(array->bdata)+offset, length);
#endif /* ASYNCHRONOUS_NATIVE_FUNCTIONS */

    NDEBUG2("datagram::send0 res=%ld ne=%ld\n",
             (long)res, (long)netError());

    if (res < 0) {
        if (res == -3) {
            ASYNC_raiseException("java/io/InterruptedIOException");
        } else {
            ASYNC_raiseException("java/io/IOException");
        }
    }

    ASYNC_pushStack(res);
}
ASYNC_FUNCTION_END

/*=========================================================================
 * FUNCTION:      receive0()
 * CLASS:         com.sun.cldc.io.j2me.datagram.Protocol
 * TYPE:          virtual native function
 * OVERVIEW:      Receive a datagram
 * INTERFACE (operand stack manipulation):
 *   parameters:  this, buffer, offset, length
 *   returns:     none
 *=======================================================================*/

ASYNC_FUNCTION_START(Java_com_sun_cldc_io_j2me_datagram_Protocol_receive0)
{
    long            length   = ASYNC_popStack();
    long            offset   = ASYNC_popStack();
    BYTEARRAY       array    = ASYNC_popStackAsType(BYTEARRAY);
    INSTANCE        instance = ASYNC_popStackAsType(INSTANCE);

    int ipnumber, port, res;
    ulong64 lres;
    long fd;

    aiocb->instance = instance;
    fd = getSocketHandle(aiocb);

    NDEBUG4("datagram::receive0 b=%lx o=%ld l=%ld fd=%ld\n",
            (long)array, offset, length, fd);

#if ASYNCHRONOUS_NATIVE_FUNCTIONS
    {
        char buffer[ASYNC_BUFFER_SIZE];
       /*
        * If necessary reduce the length to that of the buffer. The
        * Java code will call back with more I/O operations if needed.
        */
        if (length > ASYNC_BUFFER_SIZE) {
            ASYNC_raiseException("java/io/IllegalArgumentException");
        } else {
            aiocb->array = array;

            ASYNC_enableGarbageCollection();
            res = prim_com_sun_cldc_io_j2me_datagram_Protocol_receive0(fd,
                                         &ipnumber, &port, buffer, length);
            ASYNC_disableGarbageCollection();

            if (res > 0) {
                memcpy((char *)aiocb->array->bdata + offset, buffer, length);
            }
        }
    }
#else
    res = prim_com_sun_cldc_io_j2me_datagram_Protocol_receive0(fd,
          &ipnumber, &port, (char *)(array->bdata)+offset, length);
#endif /* ASYNCHRONOUS_NATIVE_FUNCTIONS */

    NDEBUG4("datagram::receive0 res=%ld ip=%lx p=%ld ne=%ld\n",
            (long)res, (long)ipnumber, (long)port, (long)netError());

    if (res < 0) {
        if (res == -3) {
            ASYNC_raiseException("java/io/InterruptedIOException");
        } else {
            ASYNC_raiseException("java/io/IOException");
        }
    }

    if (res > 0xFFFF) {
        fatalError(KVM_MSG_CANNOT_RECEIVE_DATAGRAMS_LONGER_THAN_65535);
    }

#if COMPILER_SUPPORTS_LONG
    lres = (((ulong64)ipnumber) << 32) + (unsigned)((port&0xFFFF) << 16) + (res&0xFFFF);
#else
    lres.high = ipnumber;
    lres.low = (unsigned)((port&0xFFFF) << 16) + (res&0xFFFF);
#endif /* COMPILER_SUPPORTS_LONG */

    ASYNC_pushLong(lres);
}
ASYNC_FUNCTION_END

/*=========================================================================
 * FUNCTION:      close0()
 * CLASS:         com.sun.cldc.io.j2me.datagram.Protocol
 * TYPE:          virtual native function
 * OVERVIEW:      Close a datagram socket
 * INTERFACE (operand stack manipulation):
 *   parameters:  this
 *   returns:     none
 *=======================================================================*/

ASYNC_FUNCTION_START(Java_com_sun_cldc_io_j2me_datagram_Protocol_close0)
{
    INSTANCE instance = ASYNC_popStackAsType(INSTANCE);
    long fd;
    int  res = 0;
    aiocb->instance = instance;
    fd = getSocketHandle(aiocb);

    if (fd != -1L) {
        setSocketHandle(aiocb, -1);
        ASYNC_enableGarbageCollection();
        res = prim_com_sun_cldc_io_j2me_datagram_Protocol_close(fd);
        ASYNC_disableGarbageCollection();
    }

    NDEBUG3("datagram::close res=%ld fd=%ld ne=%ld\n",
            (long)res, (long)fd, (long)netError());

    if (res < 0) {
        ASYNC_raiseException("java/io/IOException");
    }
}
ASYNC_FUNCTION_END

/*=========================================================================
 * FUNCTION:      registerCleanup
 * CLASS:         com.sun.cldc.io.j2me.datagram.Protocol
 * TYPE:          virtual native function
 * OVERVIEW:      Close a TCP socket
 * INTERFACE (operand stack manipulation):
 *   parameters:  this
 *   returns:     none
 *=======================================================================*/

static void
datagramCleanup(INSTANCE_HANDLE instanceHandle)
{ 
    INSTANCE instance = unhand(instanceHandle);
    long fd = instance->data[0].cell;
    if (fd != -1L) {
        prim_com_sun_cldc_io_j2me_datagram_Protocol_close(fd);
    }
}

void Java_com_sun_cldc_io_j2me_datagram_Protocol_registerCleanup() 
{
    START_TEMPORARY_ROOTS
        DECLARE_TEMPORARY_ROOT(INSTANCE, instance, popStackAsType(INSTANCE));
        registerCleanup(&instance, datagramCleanup);
    END_TEMPORARY_ROOTS
}