duk_trans_socket_unix.c File Reference

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <poll.h>
#include <errno.h>
#include "duktape.h"

Go to the source code of this file.

Macros
#define	DUK_DEBUG_PORT   9091

Functions
void	duk_trans_socket_init (void)
void	duk_trans_socket_finish (void)
void	duk_trans_socket_waitconn (void)
duk_size_t	duk_trans_socket_read_cb (void *udata, char *buffer, duk_size_t length)
duk_size_t	duk_trans_socket_write_cb (void *udata, const char *buffer, duk_size_t length)
duk_size_t	duk_trans_socket_peek_cb (void *udata)
void	duk_trans_socket_read_flush_cb (void *udata)
void	duk_trans_socket_write_flush_cb (void *udata)

Variables
static int	server_sock = -1
static int	client_sock = -1

Macro Definition Documentation

DUK_DEBUG_PORT

#define DUK_DEBUG_PORT   9091

Definition at line 18 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

Referenced by duk_trans_socket_init(), and duk_trans_socket_waitconn().

Function Documentation

duk_trans_socket_finish()

void duk_trans_socket_finish

(

void

)

Definition at line 74 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                   {
    if (client_sock >= 0) {
        (void) close(client_sock);
        client_sock = -1;
    }
    if (server_sock >= 0) {
        (void) close(server_sock);
        server_sock = -1;
    }
}

duk_trans_socket_init()

void duk_trans_socket_init

(

void

)

Definition at line 32 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                 {
    struct sockaddr_in addr;
    int on;
 
    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sock < 0) {
        fprintf(stderr, "%s: failed to create server socket: %s\n",
                __FILE__, strerror(errno));
        fflush(stderr);
        goto fail;
    }
 
    on = 1;
    if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(on)) < 0) {
        fprintf(stderr, "%s: failed to set SO_REUSEADDR for server socket: %s\n",
                __FILE__, strerror(errno));
        fflush(stderr);
        goto fail;
    }
 
    memset((void *) &addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(DUK_DEBUG_PORT);
 
    if (bind(server_sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        fprintf(stderr, "%s: failed to bind server socket: %s\n",
                __FILE__, strerror(errno));
        fflush(stderr);
        goto fail;
    }
 
    listen(server_sock, 1 /*backlog*/);
    return;
 
 fail:
    if (server_sock >= 0) {
        (void) close(server_sock);
        server_sock = -1;
    }
}

duk_trans_socket_peek_cb()

duk_size_t duk_trans_socket_peek_cb

(

void *

udata

)

Definition at line 255 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                                 {
    struct pollfd fds[1];
    int poll_rc;
 
    (void) udata;  /* not needed by the example */
 
#if defined(DEBUG_PRINTS)
    fprintf(stderr, "%s: udata=%p\n", __func__, (void *) udata);
    fflush(stderr);
#endif
 
    if (client_sock < 0) {
        return 0;
    }
 
    fds[0].fd = client_sock;
    fds[0].events = POLLIN;
    fds[0].revents = 0;
 
    poll_rc = poll(fds, 1, 0);
    if (poll_rc < 0) {
        fprintf(stderr, "%s: poll returned < 0, closing connection: %s\n",
                __FILE__, strerror(errno));
        fflush(stderr);
        goto fail;  /* also returns 0, which is correct */
    } else if (poll_rc > 1) {
        fprintf(stderr, "%s: poll returned > 1, treating like 1\n",
                __FILE__);
        fflush(stderr);
        return 1;  /* should never happen */
    } else if (poll_rc == 0) {
        return 0;  /* nothing to read */
    } else {
        return 1;  /* something to read */
    }
 
 fail:
    if (client_sock >= 0) {
        (void) close(client_sock);
        client_sock = -1;
    }
    return 0;
}

duk_trans_socket_read_cb()

duk_size_t duk_trans_socket_read_cb	(	void *	udata,
		char *	buffer,
		duk_size_t	length )

Definition at line 138 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                                                                  {
    ssize_t ret;
 
    (void) udata;  /* not needed by the example */
 
#if defined(DEBUG_PRINTS)
    fprintf(stderr, "%s: udata=%p, buffer=%p, length=%ld\n",
            __func__, (void *) udata, (void *) buffer, (long) length);
    fflush(stderr);
#endif
 
    if (client_sock < 0) {
        return 0;
    }
 
    if (length == 0) {
        /* This shouldn't happen. */
        fprintf(stderr, "%s: read request length == 0, closing connection\n",
                __FILE__);
        fflush(stderr);
        goto fail;
    }
 
    if (buffer == NULL) {
        /* This shouldn't happen. */
        fprintf(stderr, "%s: read request buffer == NULL, closing connection\n",
                __FILE__);
        fflush(stderr);
        goto fail;
    }
 
    /* In a production quality implementation there would be a sanity
     * timeout here to recover from "black hole" disconnects.
     */
 
    ret = read(client_sock, (void *) buffer, (size_t) length);
    if (ret < 0) {
        fprintf(stderr, "%s: debug read failed, closing connection: %s\n",
                __FILE__, strerror(errno));
        fflush(stderr);
        goto fail;
    } else if (ret == 0) {
        fprintf(stderr, "%s: debug read failed, ret == 0 (EOF), closing connection\n",
                __FILE__);
        fflush(stderr);
        goto fail;
    } else if (ret > (ssize_t) length) {
        fprintf(stderr, "%s: debug read failed, ret too large (%ld > %ld), closing connection\n",
                __FILE__, (long) ret, (long) length);
        fflush(stderr);
        goto fail;
    }
 
    return (duk_size_t) ret;
 
 fail:
    if (client_sock >= 0) {
        (void) close(client_sock);
        client_sock = -1;
    }
    return 0;
}

duk_trans_socket_read_flush_cb()

void duk_trans_socket_read_flush_cb

(

void *

udata

)

Definition at line 299 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                                 {
    (void) udata;  /* not needed by the example */
 
#if defined(DEBUG_PRINTS)
    fprintf(stderr, "%s: udata=%p\n", __func__, (void *) udata);
    fflush(stderr);
#endif
 
    /* Read flush: Duktape may not be making any more read calls at this
     * time.  If the transport maintains a receive window, it can use a
     * read flush as a signal to update the window status to the remote
     * peer.  A read flush is guaranteed to occur before Duktape stops
     * reading for a while; it may occur in other situations as well so
     * it's not a 100% reliable indication.
     */
 
    /* This TCP transport requires no read flush handling so ignore.
     * You can also pass a NULL to duk_debugger_attach() and not
     * implement this callback at all.
     */
}

duk_trans_socket_waitconn()

void duk_trans_socket_waitconn

(

void

)

Definition at line 85 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                     {
    struct sockaddr_in addr;
    socklen_t sz;
 
    if (server_sock < 0) {
        fprintf(stderr, "%s: no server socket, skip waiting for connection\n",
                __FILE__);
        fflush(stderr);
        return;
    }
    if (client_sock >= 0) {
        (void) close(client_sock);
        client_sock = -1;
    }
 
    fprintf(stderr, "Waiting for debug connection on port %d\n", (int) DUK_DEBUG_PORT);
    fflush(stderr);
 
    sz = (socklen_t) sizeof(addr);
    client_sock = accept(server_sock, (struct sockaddr *) &addr, &sz);
    if (client_sock < 0) {
        fprintf(stderr, "%s: accept() failed, skip waiting for connection: %s\n",
                __FILE__, strerror(errno));
        fflush(stderr);
        goto fail;
    }
 
    fprintf(stderr, "Debug connection established\n");
    fflush(stderr);
 
    /* XXX: For now, close the listen socket because we won't accept new
     * connections anyway.  A better implementation would allow multiple
     * debug attaches.
     */
 
    if (server_sock >= 0) {
        (void) close(server_sock);
        server_sock = -1;
    }
    return;
 
 fail:
    if (client_sock >= 0) {
        (void) close(client_sock);
        client_sock = -1;
    }
}

duk_trans_socket_write_cb()

duk_size_t duk_trans_socket_write_cb	(	void *	udata,
		const char *	buffer,
		duk_size_t	length )

Definition at line 202 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                                                                         {
    ssize_t ret;
 
    (void) udata;  /* not needed by the example */
 
#if defined(DEBUG_PRINTS)
    fprintf(stderr, "%s: udata=%p, buffer=%p, length=%ld\n",
            __func__, (void *) udata, (const void *) buffer, (long) length);
    fflush(stderr);
#endif
 
    if (client_sock < 0) {
        return 0;
    }
 
    if (length == 0) {
        /* This shouldn't happen. */
        fprintf(stderr, "%s: write request length == 0, closing connection\n",
                __FILE__);
        fflush(stderr);
        goto fail;
    }
 
    if (buffer == NULL) {
        /* This shouldn't happen. */
        fprintf(stderr, "%s: write request buffer == NULL, closing connection\n",
                __FILE__);
        fflush(stderr);
        goto fail;
    }
 
    /* In a production quality implementation there would be a sanity
     * timeout here to recover from "black hole" disconnects.
     */
 
    ret = write(client_sock, (const void *) buffer, (size_t) length);
    if (ret <= 0 || ret > (ssize_t) length) {
        fprintf(stderr, "%s: debug write failed, closing connection: %s\n",
                __FILE__, strerror(errno));
        fflush(stderr);
        goto fail;
    }
 
    return (duk_size_t) ret;
 
 fail:
    if (client_sock >= 0) {
        (void) close(client_sock);
        client_sock = -1;
    }
    return 0;
}

duk_trans_socket_write_flush_cb()

void duk_trans_socket_write_flush_cb

(

void *

udata

)

Definition at line 321 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

                                                  {
    (void) udata;  /* not needed by the example */
 
#if defined(DEBUG_PRINTS)
    fprintf(stderr, "%s: udata=%p\n", __func__, (void *) udata);
    fflush(stderr);
#endif
 
    /* Write flush.  If the transport combines multiple writes
     * before actually sending, a write flush is an indication
     * to write out any pending bytes: Duktape may not be doing
     * any more writes on this occasion.
     */
 
    /* This TCP transport requires no write flush handling so ignore.
     * You can also pass a NULL to duk_debugger_attach() and not
     * implement this callback at all.
     */
    return;
}

Variable Documentation

client_sock

int client_sock = -1

static

Definition at line 26 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

Referenced by duk_trans_socket_finish(), duk_trans_socket_peek_cb(), duk_trans_socket_read_cb(), duk_trans_socket_waitconn(), and duk_trans_socket_write_cb().

server_sock

int server_sock = -1

static

Definition at line 25 of file duktape-1.5.2/examples/debug-trans-socket/duk_trans_socket_unix.c.

Referenced by duk_trans_socket_finish(), duk_trans_socket_init(), and duk_trans_socket_waitconn().