#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <inttypes.h>
#include <unistd.h>
#include <endian.h>

#include <sys/ioctl.h>
#include <netinet/in.h>
#include <byteswap.h>

typedef uint32_t u32;
typedef uint64_t u64;
#include <linux/nbd.h>

#if __BYTE_ORDER == __BIG_ENDIAN
#define ntohll(netlong) (netlong)
#elif __BYTE_ORDER == __LITTLE_ENDIAN
#define ntohll(netlong) __bswap_64(netlong)
#else
error, you should not exist
#endif

struct rstate {
  struct nbd_request req;
  u32 req_read; /* how many octets of req are valid */
  u32 data_read; /* how many octets of the data sv are valid */
};

MODULE = Linux::NBD		PACKAGE = Linux::NBD::Client

PROTOTYPES: DISABLE

void
_set_sock (int dev, int fd)
	CODE:
        ioctl (dev, NBD_SET_SOCK, (unsigned long)fd);

void
_doit (int dev, int server = 0)
	CODE:
        if (server)
          for (server = 0; server < 4095; server++)
            if (server != dev)
              close (server);

        ioctl (dev, NBD_DO_IT);

        if (server)
          _exit (0);

void
_disconnect (int dev)
	CODE:
        ioctl (dev, NBD_DISCONNECT);

void
_clear_sock (int dev)
	CODE:
        ioctl (dev, NBD_CLEAR_SOCK);

void
_clear_que (int dev)
	CODE:
        ioctl (dev, NBD_CLEAR_QUE);

void
_set_blksize (int dev, unsigned long blocksize)
	CODE:
        ioctl (dev, NBD_SET_BLKSIZE, blocksize);

void
_set_size (int dev, unsigned long size)
	CODE:
        ioctl (dev, NBD_SET_SIZE, size);

void
_set_size_blocks (int dev, unsigned long nblocks)
	CODE:
        ioctl (dev, NBD_SET_SIZE_BLOCKS, nblocks);

void
_set_timeout (int dev, unsigned long timeout)
	CODE:
        ioctl (dev, NBD_SET_TIMEOUT, timeout);

void
_print_debug (int dev)
	CODE:
        ioctl (dev, NBD_PRINT_DEBUG, 0);

MODULE = Linux::NBD		PACKAGE = Linux::NBD::Server

void
_one_request (SV *obj, int fd)
	CODE:
{
	struct rstate *s;
        u64 from;
        u32 len;
        char *method;
	MAGIC *mg = mg_find (SvRV (obj), PERL_MAGIC_ext);

        if (!mg)
          {
            mg = sv_magicext (SvRV (obj), 0, PERL_MAGIC_ext, 0, 0, 0);
            mg->mg_len = sizeof (struct rstate);
            New (0, mg->mg_ptr, mg->mg_len, char);

            ((struct rstate *)mg->mg_ptr)->req_read = 0; /* initialise the state machine */
          }

        s = (struct rstate *)mg->mg_ptr;

        if (s->req_read < sizeof (struct nbd_request))
          {
            int res = read (fd, s->req_read + (char *)&s->req, sizeof (struct nbd_request) - s->req_read);

            if (res > 0)
              s->req_read += res;
            else if (res == 0)
              XSRETURN_UNDEF; /* should req->eof */
            else if (errno != EAGAIN && errno != EWOULDBLOCK)
              XSRETURN_UNDEF; /* should req->error */

            s->data_read = 0;
          }

        if (s->req_read < sizeof (struct nbd_request))
          XSRETURN_NO;

        /* now we have a full request, so check for data */
        if (s->req.magic != htonl (NBD_REQUEST_MAGIC))
          croak ("Linux::NBD::Server received illegal request magic %08lx - protocol error.\n", ntohl (s->req.magic));

        from = ntohll (s->req.from);
        len  = ntohl  (s->req.len);

        switch (ntohl (s->req.type))
          {
            case NBD_CMD_WRITE:
              if (!mg->mg_obj)
                {
                  mg->mg_flags |= MGf_REFCOUNTED;
                  mg->mg_obj = NEWSV (0, len);
                  SvPOK_only (mg->mg_obj);
                  SvCUR_set (mg->mg_obj, len);
                }

              if (s->data_read < len)
                {
                  int res = read (fd, s->data_read + SvPVX (mg->mg_obj), len - s->data_read);

                  if (res > 0)
                    s->data_read += res;
                  else if (res == 0)
                    XSRETURN_UNDEF; /* should req->eof */
                  else if (errno != EAGAIN && errno != EWOULDBLOCK)
                    XSRETURN_UNDEF; /* should req->error */
                }

              if (s->data_read < len)
                XSRETURN_NO;

              /* fallthrough */
            case NBD_CMD_READ:
              s->req_read = 0;

              PUSHMARK (SP);
              EXTEND (SP, 4);
              PUSHs (obj);
              PUSHs (sv_2mortal (newSVpvn (s->req.handle, sizeof (s->req.handle))));
              PUSHs (sv_2mortal (sizeof (UV) < 8 && from > 0xffffffffUL
                                 ? newSVnv (from)
                                 : newSVuv (from)));

              if (mg->mg_obj)
                {
                  PUSHs (sv_2mortal (mg->mg_obj));
                  mg->mg_obj = 0;
                  method = "req_write";
                }
              else
                {
                  PUSHs (sv_2mortal (newSVuv (len)));
                  method = "req_read";
                }

              break;

            case NBD_CMD_DISC:
              s->req_read = 0;

              method = "req_disc";

              PUSHMARK (SP);
              XPUSHs (obj);

              break;

            default:
              croak ("Linux::NBD::Server received unsupported request type %d.\n", ntohl (s->req.type));
          }

        PUTBACK;
        call_method (method, G_DISCARD);
        SPAGAIN;

        XSRETURN_YES;
}

SV *
format_reply (SV *unused, SV *handle, unsigned int error = 0, SV *data = 0)
	CODE:
{
        struct nbd_reply rep;
        STRLEN len;
        char *h = SvPV (handle, len);

        if (len != sizeof (rep.handle))
          croak ("format_reply: illegal handle (length %d, should be %d)", len, sizeof (rep.handle));

        rep.magic = htonl (NBD_REPLY_MAGIC);
        rep.error = htonl (error);
        memcpy (rep.handle, h, sizeof (rep.handle));

        RETVAL = newSVpvn ((char *)&rep, sizeof (rep));

        if (data && !error)
          sv_catsv (RETVAL, data);
}        
        OUTPUT:
        RETVAL