socket.pmc

/*
Copyright (C) 2008-2013, 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_getprotobyname(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.

If the socket is closed or on other errors, it throws an .EXCEPTION_PIO_ERROR
Exception.

=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 up to the given number of bytes from the socket and return them in a string.

This method behaves always the same as recv(). Only if the socket is already closed
return an empty string.

=cut

TODO: add setsockopt(level, option, value) for the pre-parrot 4.10 behavior, to receive
larger buffers.

The receive low-water mark (the SO_RCVLOWAT setsockopt option) determines the minimum
amount of data that must be received before the read function is completed. If the read
function times out, any data that was received is returned to the application even if the
amount of data received is less than the receive low-water mark value.

*/

    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' :
 */