socket.pmc

/*
Copyright (C) 2008-2011, Parrot Foundation.

=head1 NAME

src/pmc/socket.pmc - Socket PMC

=head1 DESCRIPTION

The Socket PMC performs network I/O operations.

=head2 Vtable Functions

=over 4

=cut

*/

#include "../src/io/io_private.h"
#include "pmc/pmc_sockaddr.h"

#define CHUNK_SIZE      2048

/* HEADERIZER HFILE: none */
/* HEADERIZER BEGIN: static */
/* HEADERIZER END: static */

pmclass Socket extends Handle provides socket auto_attrs {
    ATTR PMC *local;           /* Local addr                   */
    ATTR PMC *remote;          /* Remote addr                  */
    ATTR INTVAL  family;
    ATTR INTVAL  type;
    ATTR INTVAL  protocol;

/*

=item C<void init()>

Initializes a newly created Socket object.

=cut

*/

    VTABLE void init() {
        Parrot_Socket_attributes * const data_struct =
                (Parrot_Socket_attributes *) PMC_data(SELF);

        data_struct->record_separator = CONST_STRING(interp, "\n");
        data_struct->local            = PMCNULL;
        data_struct->remote           = PMCNULL;
        data_struct->io_vtable = (IO_VTABLE *)Parrot_io_get_vtable(interp, IO_VTABLE_SOCKET, NULL);
        data_struct->read_buffer      = NULL;
        data_struct->write_buffer     = NULL;
        data_struct->encoding         = STRINGNULL;

        Parrot_io_socket_initialize(INTERP, SELF);

        PObj_custom_mark_destroy_SETALL(SELF);
    }

/*

=item C<PMC *clone()>

Create a copy of the socket handle.

=cut

*/

    VTABLE PMC *clone() {
        PMC * const copy = SUPER();
        const Parrot_Socket_attributes * const old_struct = PARROT_SOCKET(SELF);
        Parrot_Socket_attributes * const data_struct = PARROT_SOCKET(copy);

        if (!PMC_IS_NULL(old_struct->local))
            data_struct->local      = VTABLE_clone(INTERP, old_struct->local);
        if (!PMC_IS_NULL(old_struct->remote))
            data_struct->remote     = VTABLE_clone(INTERP, old_struct->remote);

        return copy;
    }

/*

=item C<void mark()>

Mark active socket handle data as live.

=cut

*/

    VTABLE void mark() {
        Parrot_Socket_attributes * const data = PARROT_SOCKET(SELF);

        if (data) {
            Parrot_gc_mark_PMC_alive(INTERP, data->local);
            Parrot_gc_mark_PMC_alive(INTERP, data->remote);
            Parrot_gc_mark_STRING_alive(INTERP, data->encoding);
            Parrot_gc_mark_STRING_alive(INTERP, data->record_separator);
            Parrot_io_buffer_mark(interp, data->read_buffer);
            Parrot_io_buffer_mark(interp, data->write_buffer);
        }
    }
/*

=item C<void destroy()>

Free structures.

=cut

*/
    VTABLE void destroy() {
        /* TODO: Make sure to free the buffers */
        Parrot_io_close(INTERP, SELF, 1);
    }

/*

=item C<INTVAL get_bool()>

Returns whether the Socket is currently open.

=cut

*/

    VTABLE INTVAL get_bool() {
        return !Parrot_io_is_closed(INTERP, SELF);
    }

/*

=back

=head2 Methods

=over 4

=item C<socket(INTVAL fam, INTVAL type, INTVAL proto)>

=cut

*/


    METHOD socket(INTVAL fam, INTVAL type, INTVAL proto) {
        if (Parrot_io_socket(INTERP, SELF, fam, type, proto))
            RETURN(PMC * SELF);
        RETURN(PMC * PMCNULL);
    }

/*

=item C<poll(INTVAL which, INTVAL sec, INTVAL usec)>

Watches the socket for C<sec> seconds and C<usec> microseconds.  C<which>
is a bitmask representing the states you want to watch for.  Or together 1
for readable, two for writeable, and four for exceptions.

=cut

*/


    METHOD poll(INTVAL which, INTVAL sec, INTVAL usec) {
        const INTVAL poll = Parrot_io_poll(INTERP, SELF, which, sec, usec);
        RETURN(INTVAL poll);
    }

/*

=item C<sockaddr(STRING * address, INTVAL port, INTVAL family :optional)>

C<sockaddr> returns an object representing a socket address, generated
from a port number (integer) , address (string) and an optional address
family (integer). If no address family is given, it defaults to IPv4.

=cut

*/

    METHOD sockaddr(STRING * address, INTVAL port, INTVAL family :optional) {
        PMC *array;
        PMC *res;

        if (!family)
            family = PIO_PF_INET;

        array = Parrot_io_internal_getaddrinfo(INTERP, address, port, PIO_PROTO_TCP,
                    family, 0);

        if (VTABLE_elements(interp, array))
            res = VTABLE_get_pmc_keyed_int(interp, array, 0);
        else
            res = PMCNULL;

        RETURN(PMC * res);
    }

/*

=item C<getaddrinfo(STRING * address, INTVAL port, INTVAL protocol, INTVAL family, INTVAL passive)>

C<getaddrinfo> returns an array of Sockaddr PMCs representing the result of the
C<getaddrinfo(3)> function which consists of multiple socket addresses,
including family and protocol. It can be passed to C<bind()> or C<connect()>.

=cut

*/
    METHOD getaddrinfo(STRING * address,
                       INTVAL port, INTVAL protocol, INTVAL family, INTVAL passive) {
        PMC * const res = Parrot_io_internal_getaddrinfo(INTERP, address, port, protocol, family,
                                                         passive);
        RETURN(PMC * res);
    }

/*

=item C<remote_address()>

C<remote_address> returns the remote address of this socket PMC.

=cut

*/
    METHOD remote_address() {
        PMC * const res = PARROT_SOCKET(SELF)->remote;
        RETURN(PMC * res);
    }

/*

=item C<local_address()>

C<local_address> returns the local address of this socket PMC.

=cut

*/
    METHOD local_address() {
        PMC * const res = PARROT_SOCKET(SELF)->local;
        RETURN(PMC * res);
    }


/*

=item C<METHOD is_closed()>

Test if the socket is closed.

=cut

*/

    METHOD is_closed() {
        const INTVAL status = !VTABLE_get_bool(INTERP, SELF);
        RETURN(INTVAL status);
    }


/*

=item C<getprotobyname(STRING * name)>

C<getprotobyname> returns a protocol number suitable for passing to
C<socket>, based on the given protocol name. This is normal only
necessary when opening sockets in raw mode.

=cut

*/

    METHOD getprotobyname(STRING * name) {
        INTVAL proto = Parrot_io_get_proto_by_name(INTERP, name);
        RETURN(INTVAL proto);
    }

/*

=item C<connect(PMC * address)>

Connects a socket object to an address.

The asynchronous version takes an additional final PMC callback
argument, and only returns a status object. When the socket operation is
complete, it invokes the callback, passing it a status object and the
socket object it was called on. [If you want notification when a connect
operation is completed, you probably want to do something with that
connected socket object.]

=cut

*/

    METHOD connect(PMC * address) {
        Parrot_io_socket_connect(INTERP, SELF, address);
        RETURN(INTVAL 0);
    }

/*

=item C<recv()>

Receives a message from a connected socket object. It returns
the message in a string.

The asynchronous version takes an additional final PMC callback
argument, and only returns a status object. When the recv operation is
complete, it invokes the callback, passing it a status object and a
string containing the received message.

=cut

*/

    METHOD recv() {
        STRING * const result = Parrot_io_read_s(INTERP, SELF, PIO_READ_SIZE_ANY);
        RETURN(STRING * result);
    }

/*

=item C<send(STRING *buf)>

Sends a message string to a connected socket object.

The asynchronous version takes an additional final PMC callback
argument, and only returns a status object. When the send operation is
complete, it invokes the callback, passing it a status object.

=cut

*/

    METHOD send(STRING *buf) {
        const INTVAL res = Parrot_io_write_s(INTERP, SELF, buf);
        RETURN(INTVAL res);
    }

/*

=item C<bind(PMC *host)>

C<bind> binds a socket object to the port and address specified by an
address object (the result of C<getaddrinfo>).

The asynchronous version takes an additional final PMC callback
argument, and only returns a status object. When the bind operation is
complete, it invokes the callback, passing it a status object and the
socket object it was called on. [If you want notification when a bind
operation is completed, you probably want to do something with that
bound socket object.]

=cut

*/

    METHOD bind(PMC *host) {
        Parrot_io_socket_bind(INTERP, SELF, host);
        RETURN(INTVAL 0);
    }

/*

=item C<listen(INTVAL backlog)>

C<listen> specifies that a socket object is willing to accept incoming
connections. The integer argument gives the maximum size of the queue
for pending connections.

There is no asynchronous version. C<listen> marks a set of attributes on
the socket object.

=cut

*/

    METHOD listen(INTVAL backlog) {
        Parrot_io_socket_listen(INTERP, SELF, backlog);
        RETURN(INTVAL 0);
    }

/*

=item C<accept()>

C<accept> accepts a new connection on a given socket object, and returns
a newly created socket object for the connection.

The asynchronous version takes an additional final PMC callback
argument, and only returns a status object. When the accept operation
receives a new connection, it invokes the callback, passing it a status
object and a newly created socket object for the connection. [While the
synchronous C<accept> has to be called repeatedly in a loop (once for
each connection received), the asynchronous version is only called once,
but continues to send new connection events until the socket is closed.]

=cut

*/

    METHOD accept() {
        PMC * const res = Parrot_io_socket_accept(INTERP, SELF);
        RETURN(PMC * res);
    }

/*

=item C<METHOD read(INTVAL bytes)>

Read the given number of bytes from the socket and return them in a string.

=cut

*/

    METHOD read(INTVAL nb) {
        STRING *buf;

        if (Parrot_io_is_closed(INTERP, SELF))
            RETURN(STRING * STRINGNULL);

        buf = Parrot_io_read_s(INTERP, SELF, nb);

        RETURN(STRING *buf);
    }


/*

=item C<METHOD readline(STRING delimiter)>

Read a line from the socket and return it in a string. If C<delimiter> is
present, it is used to determine line endings instead of the default C<\n>.

=cut

*/

    METHOD readline(STRING *delimiter    :optional,
                    INTVAL has_delimiter :opt_flag) {

        if (!has_delimiter)
            delimiter = PARROT_SOCKET(SELF)->record_separator;
        {
            STRING *result = Parrot_io_readline_s(INTERP, SELF, delimiter);
            RETURN(STRING *result);
        }
    }

/*

=item C<METHOD puts(STRING *buf)>

Print the string to the socket.

=cut

*/

    METHOD puts(STRING *buf) {
        const INTVAL res = Parrot_io_write_s(INTERP, SELF, buf);
        RETURN(INTVAL res);
    }

/*

=back

=cut

*/

} /* end pmclass */

/*
 * Local variables:
 *   c-file-style: "parrot"
 * End:
 * vim: expandtab shiftwidth=4 cinoptions='\:2=2' :
 */