web/js/nbd.js - openbmc/jsnbd - Gitiles

 /* Copyright 2018 IBM Corp.
  *
  * Author: Jeremy Kerr <jk@ozlabs.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License.  You may obtain a copy
  * of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations
  * under the License.
  */

 /* handshake flags */
 const NBD_FLAG_FIXED_NEWSTYLE = 0x1;
 const NBD_FLAG_NO_ZEROES = 0x2;

 /* transmission flags */
 const NBD_FLAG_HAS_FLAGS = 0x1;
 const NBD_FLAG_READ_ONLY = 0x2;

 /* option negotiation */
 const NBD_OPT_EXPORT_NAME = 0x1;
 const NBD_REP_FLAG_ERROR = 0x1 << 31;
 const NBD_REP_ERR_UNSUP = NBD_REP_FLAG_ERROR | 1;

 /* command definitions */
 const NBD_CMD_READ = 0;
 const NBD_CMD_WRITE = 1;
 const NBD_CMD_DISC = 2;
 const NBD_CMD_FLUSH = 3;
 const NBD_CMD_TRIM = 4;

 /* errno */
 const EPERM = 1;
 const EIO = 5;
 const ENOMEM = 12;
 const EINVAL = 22;
 const ENOSPC = 28;
 const EOVERFLOW = 75;
 const ESHUTDOWN = 108;

 /* internal object state */
 const NBD_STATE_UNKNOWN = 1;
 const NBD_STATE_OPEN = 2;
 const NBD_STATE_WAIT_CFLAGS = 3;
 const NBD_STATE_WAIT_OPTION = 4;
 const NBD_STATE_TRANSMISSION = 5;

 function NBDServer(endpoint, file)
 {
     this.file = file;
     this.endpoint = endpoint;
     this.ws = null;
     this.state = NBD_STATE_UNKNOWN;
     this.msgbuf = null;

     this.start = function()
     {
         this.state = NBD_STATE_OPEN;
         this.ws = new WebSocket(this.endpoint);
         this.ws.binaryType = 'arraybuffer';
         this.ws.onmessage = this._on_ws_message.bind(this);
         this.ws.onopen = this._on_ws_open.bind(this);
     }

     this.stop = function()
     {
         this.ws.close();
         this.state = NBD_STATE_UNKNOWN;
     }

     this._log = function(msg)
     {
         if (this.onlog)
             this.onlog(msg);
     }

     /* websocket event handlers */
     this._on_ws_open = function(ev)
     {
         this.client = {
             flags: 0,
         };
         this._negotiate();
     }

     this._on_ws_message = function(ev)
     {
         var data = ev.data;

         if (this.msgbuf == null) {
             this.msgbuf = data;
         } else {
             var tmp = new Uint8Array(this.msgbuf.byteLength + data.byteLength);
             tmp.set(new Uint8Array(this.msgbuf), 0);
             tmp.set(new Uint8Array(data), this.msgbuf.byteLength);
             this.msgbuf = tmp.buffer;
         }

         for (;;) {
             var handler = this.recv_handlers[this.state];
             if (!handler) {
                 this._log("no handler for state " + this.state);
                 this.stop();
                 break;
             }

             var consumed = handler(this.msgbuf);
             if (consumed < 0) {
                 this._log("handler[state=" + this.state +
                         "] returned error " + consumed);
                 this.stop();
                 break;
             }

             if (consumed == 0)
                 break;

             if (consumed > 0) {
                 if (consumed == this.msgbuf.byteLength) {
                     this.msgbuf = null;
                     break;
                 }
                 this.msgbuf = this.msgbuf.slice(consumed);
             }
         }
     }

     this._negotiate = function()
     {
         var buf = new ArrayBuffer(18);
         var data = new DataView(buf, 0, 18);

         /* NBD magic: NBDMAGIC */
         data.setUint32(0,  0x4e42444d);
         data.setUint32(4,  0x41474943);

         /* newstyle negotiation: IHAVEOPT */
         data.setUint32(8,  0x49484156);
         data.setUint32(12, 0x454F5054);

         /* flags: fixed newstyle negotiation, no padding */
         data.setUint16(16, NBD_FLAG_FIXED_NEWSTYLE | NBD_FLAG_NO_ZEROES);

         this.state = NBD_STATE_WAIT_CFLAGS;
         this.ws.send(buf);
     }

     /* handlers */
     this._handle_cflags = function(buf)
     {
         if (buf.byteLength < 4)
             return 0;

         var data = new DataView(buf, 0, 4);
         this.client.flags = data.getUint32(0);

         this._log("client flags received: 0x" +
                 this.client.flags.toString(16));

         this.state = NBD_STATE_WAIT_OPTION;
         return 4;
     }

     this._handle_option = function(buf)
     {
         if (buf.byteLength < 16)
             return 0;

         var data = new DataView(buf, 0, 16);
         if (data.getUint32(0) != 0x49484156 ||
                 data.getUint32(4) != 0x454F5054) {
             this._log("invalid option magic");
             return -1;
         }

         var opt = data.getUint32(8);
         var len = data.getUint32(12);

         this._log("client option received: 0x" + opt.toString(16));

         if (buf.byteLength < 16 + len)
             return 0;

         switch (opt) {
         case NBD_OPT_EXPORT_NAME:
             this._log("negotiation complete, starting transmission mode");
             var n = 10;
             if (!(this.client.flags & NBD_FLAG_NO_ZEROES))
                 n += 124;
             var resp = new ArrayBuffer(n);
             var view = new DataView(resp, 0, 10);
             /* export size. */
             var size = this.file.size;
             view.setUint32(0, Math.floor(size / (2**32)));
             view.setUint32(4, size & 0xffffffff);
             /* transmission flags: read-only */
             view.setUint16(8, NBD_FLAG_HAS_FLAGS | NBD_FLAG_READ_ONLY);
             this.ws.send(resp);

             this.state = NBD_STATE_TRANSMISSION;
             break;

         default:
             /* reject other options */
             var resp = new ArrayBuffer(20);
             var view = new DataView(resp, 0, 20);
             view.setUint32(0, 0x0003e889);
             view.setUint32(4, 0x045565a9);
             view.setUint32(8, opt);
             view.setUint32(12, NBD_REP_ERR_UNSUP);
             view.setUint32(16, 0);
             this.ws.send(resp);
         }

         return 16 + len;
     }

     this._create_cmd_response = function(req, rc, data = null)
     {
         var len = 16;
         if (data)
             len += data.byteLength;
         var resp = new ArrayBuffer(len);
         var view = new DataView(resp, 0, 16);
         view.setUint32(0, 0x67446698);
         view.setUint32(4, rc);
         view.setUint32(8, req.handle_msB);
         view.setUint32(12, req.handle_lsB);
         if (data)
             new Uint8Array(resp, 16).set(new Uint8Array(data));
         return resp;
     }

     this._handle_cmd = function(buf)
     {
         if (buf.byteLength < 28)
             return 0;

         var view = new DataView(buf, 0, 28);

         if (view.getUint32(0) != 0x25609513) {
             this._log("invalid request magic");
             return -1;
         }

         var req = {
             flags: view.getUint16(4),
             type: view.getUint16(6),
             handle_msB: view.getUint32(8),
             handle_lsB: view.getUint32(12),
             offset_msB: view.getUint32(16),
             offset_lsB: view.getUint32(20),
             length: view.getUint32(24),
         };

         /* we don't support writes, so nothing needs the data at present */
         /* req.data = buf.slice(28); */

         var err = 0;
 	var consumed = 28;

         /* the command handlers return 0 on success, and send their
          * own response. Otherwise, a non-zero error code will be
          * used as a simple error response
          */
         switch (req.type) {
         case NBD_CMD_READ:
             err = this._handle_cmd_read(req);
             break;

         case NBD_CMD_DISC:
             err = this._handle_cmd_disconnect(req);
             break;

         case NBD_CMD_WRITE:
 	    /* we also need length bytes of data to consume a write
 	     * request */
 	    if (buf.byteLength < 28 + req.length)
 		    return 0;
 	    consumed += req.length;
 	    err = EPERM;
 	    break;

         case NBD_CMD_TRIM:
             err = EPERM;
             break;

         default:
             this._log("invalid command 0x" + req.type.toString(16));
             err = EINVAL;
         }

         if (err) {
             var resp = this._create_cmd_response(req, err);
             this.ws.send(resp);
         }

         return consumed;
     }

     this._handle_cmd_read = function(req)
     {
         var offset;

         offset = (req.offset_msB * 2**32) + req.offset_lsB;

         if (offset > Number.MAX_SAFE_INTEGER)
             return ENOSPC;

         if (offset + req.length > Number.MAX_SAFE_INTEGER)
             return ENOSPC;

         if (offset + req.length > file.size)
             return ENOSPC;

         this._log("read: 0x" + req.length.toString(16) +
                 " bytes, offset 0x" + offset.toString(16));

         var blob = this.file.slice(offset, offset + req.length);
         var reader = new FileReader();

         reader.onload = (function(ev) {
             var reader = ev.target;
             if (reader.readyState != FileReader.DONE)
                 return;
             var resp = this._create_cmd_response(req, 0, reader.result);
             this.ws.send(resp);
         }).bind(this);

         reader.onerror = (function(ev) {
             var reader = ev.target;
             this._log("error reading file: " + reader.error);
             var resp = this._create_cmd_response(req, EIO);
             this.ws.send(resp);
         }).bind(this);

         reader.readAsArrayBuffer(blob);

         return 0;
     }

     this._handle_cmd_disconnect = function(req)
     {
             this._log("disconnect received");
             this.stop();
             return 0;
     }

     this.recv_handlers = Object.freeze({
         [NBD_STATE_WAIT_CFLAGS]: this._handle_cflags.bind(this),
         [NBD_STATE_WAIT_OPTION]: this._handle_option.bind(this),
         [NBD_STATE_TRANSMISSION]: this._handle_cmd.bind(this),
     });
 }
	/* Copyright 2018 IBM Corp.
	*
	* Author: Jeremy Kerr <jk@ozlabs.org>
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy
	* of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations
	* under the License.
	*/

	/* handshake flags */
	const NBD_FLAG_FIXED_NEWSTYLE = 0x1;
	const NBD_FLAG_NO_ZEROES = 0x2;

	/* transmission flags */
	const NBD_FLAG_HAS_FLAGS = 0x1;
	const NBD_FLAG_READ_ONLY = 0x2;

	/* option negotiation */
	const NBD_OPT_EXPORT_NAME = 0x1;
	const NBD_REP_FLAG_ERROR = 0x1 << 31;
	const NBD_REP_ERR_UNSUP = NBD_REP_FLAG_ERROR \| 1;

	/* command definitions */
	const NBD_CMD_READ = 0;
	const NBD_CMD_WRITE = 1;
	const NBD_CMD_DISC = 2;
	const NBD_CMD_FLUSH = 3;
	const NBD_CMD_TRIM = 4;

	/* errno */
	const EPERM = 1;
	const EIO = 5;
	const ENOMEM = 12;
	const EINVAL = 22;
	const ENOSPC = 28;
	const EOVERFLOW = 75;
	const ESHUTDOWN = 108;

	/* internal object state */
	const NBD_STATE_UNKNOWN = 1;
	const NBD_STATE_OPEN = 2;
	const NBD_STATE_WAIT_CFLAGS = 3;
	const NBD_STATE_WAIT_OPTION = 4;
	const NBD_STATE_TRANSMISSION = 5;

	function NBDServer(endpoint, file)
	{
	this.file = file;
	this.endpoint = endpoint;
	this.ws = null;
	this.state = NBD_STATE_UNKNOWN;
	this.msgbuf = null;

	this.start = function()
	{
	this.state = NBD_STATE_OPEN;
	this.ws = new WebSocket(this.endpoint);
	this.ws.binaryType = 'arraybuffer';
	this.ws.onmessage = this._on_ws_message.bind(this);
	this.ws.onopen = this._on_ws_open.bind(this);
	}

	this.stop = function()
	{
	this.ws.close();
	this.state = NBD_STATE_UNKNOWN;
	}

	this._log = function(msg)
	{
	if (this.onlog)
	this.onlog(msg);
	}

	/* websocket event handlers */
	this._on_ws_open = function(ev)
	{
	this.client = {
	flags: 0,
	};
	this._negotiate();
	}

	this._on_ws_message = function(ev)
	{
	var data = ev.data;

	if (this.msgbuf == null) {
	this.msgbuf = data;
	} else {
	var tmp = new Uint8Array(this.msgbuf.byteLength + data.byteLength);
	tmp.set(new Uint8Array(this.msgbuf), 0);
	tmp.set(new Uint8Array(data), this.msgbuf.byteLength);
	this.msgbuf = tmp.buffer;
	}

	for (;;) {
	var handler = this.recv_handlers[this.state];
	if (!handler) {
	this._log("no handler for state " + this.state);
	this.stop();
	break;
	}

	var consumed = handler(this.msgbuf);
	if (consumed < 0) {
	this._log("handler[state=" + this.state +
	"] returned error " + consumed);
	this.stop();
	break;
	}

	if (consumed == 0)
	break;

	if (consumed > 0) {
	if (consumed == this.msgbuf.byteLength) {
	this.msgbuf = null;
	break;
	}
	this.msgbuf = this.msgbuf.slice(consumed);
	}
	}
	}

	this._negotiate = function()
	{
	var buf = new ArrayBuffer(18);
	var data = new DataView(buf, 0, 18);

	/* NBD magic: NBDMAGIC */
	data.setUint32(0, 0x4e42444d);
	data.setUint32(4, 0x41474943);

	/* newstyle negotiation: IHAVEOPT */
	data.setUint32(8, 0x49484156);
	data.setUint32(12, 0x454F5054);

	/* flags: fixed newstyle negotiation, no padding */
	data.setUint16(16, NBD_FLAG_FIXED_NEWSTYLE \| NBD_FLAG_NO_ZEROES);

	this.state = NBD_STATE_WAIT_CFLAGS;
	this.ws.send(buf);
	}

	/* handlers */
	this._handle_cflags = function(buf)
	{
	if (buf.byteLength < 4)
	return 0;

	var data = new DataView(buf, 0, 4);
	this.client.flags = data.getUint32(0);

	this._log("client flags received: 0x" +
	this.client.flags.toString(16));

	this.state = NBD_STATE_WAIT_OPTION;
	return 4;
	}

	this._handle_option = function(buf)
	{
	if (buf.byteLength < 16)
	return 0;

	var data = new DataView(buf, 0, 16);
	if (data.getUint32(0) != 0x49484156 \|\|
	data.getUint32(4) != 0x454F5054) {
	this._log("invalid option magic");
	return -1;
	}

	var opt = data.getUint32(8);
	var len = data.getUint32(12);

	this._log("client option received: 0x" + opt.toString(16));

	if (buf.byteLength < 16 + len)
	return 0;

	switch (opt) {
	case NBD_OPT_EXPORT_NAME:
	this._log("negotiation complete, starting transmission mode");
	var n = 10;
	if (!(this.client.flags & NBD_FLAG_NO_ZEROES))
	n += 124;
	var resp = new ArrayBuffer(n);
	var view = new DataView(resp, 0, 10);
	/* export size. */
	var size = this.file.size;
	view.setUint32(0, Math.floor(size / (2**32)));
	view.setUint32(4, size & 0xffffffff);
	/* transmission flags: read-only */
	view.setUint16(8, NBD_FLAG_HAS_FLAGS \| NBD_FLAG_READ_ONLY);
	this.ws.send(resp);

	this.state = NBD_STATE_TRANSMISSION;
	break;

	default:
	/* reject other options */
	var resp = new ArrayBuffer(20);
	var view = new DataView(resp, 0, 20);
	view.setUint32(0, 0x0003e889);
	view.setUint32(4, 0x045565a9);
	view.setUint32(8, opt);
	view.setUint32(12, NBD_REP_ERR_UNSUP);
	view.setUint32(16, 0);
	this.ws.send(resp);
	}

	return 16 + len;
	}

	this._create_cmd_response = function(req, rc, data = null)
	{
	var len = 16;
	if (data)
	len += data.byteLength;
	var resp = new ArrayBuffer(len);
	var view = new DataView(resp, 0, 16);
	view.setUint32(0, 0x67446698);
	view.setUint32(4, rc);
	view.setUint32(8, req.handle_msB);
	view.setUint32(12, req.handle_lsB);
	if (data)
	new Uint8Array(resp, 16).set(new Uint8Array(data));
	return resp;
	}

	this._handle_cmd = function(buf)
	{
	if (buf.byteLength < 28)
	return 0;

	var view = new DataView(buf, 0, 28);

	if (view.getUint32(0) != 0x25609513) {
	this._log("invalid request magic");
	return -1;
	}

	var req = {
	flags: view.getUint16(4),
	type: view.getUint16(6),
	handle_msB: view.getUint32(8),
	handle_lsB: view.getUint32(12),
	offset_msB: view.getUint32(16),
	offset_lsB: view.getUint32(20),
	length: view.getUint32(24),
	};

	/* we don't support writes, so nothing needs the data at present */
	/* req.data = buf.slice(28); */

	var err = 0;
	var consumed = 28;

	/* the command handlers return 0 on success, and send their
	* own response. Otherwise, a non-zero error code will be
	* used as a simple error response
	*/
	switch (req.type) {
	case NBD_CMD_READ:
	err = this._handle_cmd_read(req);
	break;

	case NBD_CMD_DISC:
	err = this._handle_cmd_disconnect(req);
	break;

	case NBD_CMD_WRITE:
	/* we also need length bytes of data to consume a write
	* request */
	if (buf.byteLength < 28 + req.length)
	return 0;
	consumed += req.length;
	err = EPERM;
	break;

	case NBD_CMD_TRIM:
	err = EPERM;
	break;

	default:
	this._log("invalid command 0x" + req.type.toString(16));
	err = EINVAL;
	}

	if (err) {
	var resp = this._create_cmd_response(req, err);
	this.ws.send(resp);
	}

	return consumed;
	}

	this._handle_cmd_read = function(req)
	{
	var offset;

	offset = (req.offset_msB * 2**32) + req.offset_lsB;

	if (offset > Number.MAX_SAFE_INTEGER)
	return ENOSPC;

	if (offset + req.length > Number.MAX_SAFE_INTEGER)
	return ENOSPC;

	if (offset + req.length > file.size)
	return ENOSPC;

	this._log("read: 0x" + req.length.toString(16) +
	" bytes, offset 0x" + offset.toString(16));

	var blob = this.file.slice(offset, offset + req.length);
	var reader = new FileReader();

	reader.onload = (function(ev) {
	var reader = ev.target;
	if (reader.readyState != FileReader.DONE)
	return;
	var resp = this._create_cmd_response(req, 0, reader.result);
	this.ws.send(resp);
	}).bind(this);

	reader.onerror = (function(ev) {
	var reader = ev.target;
	this._log("error reading file: " + reader.error);
	var resp = this._create_cmd_response(req, EIO);
	this.ws.send(resp);
	}).bind(this);

	reader.readAsArrayBuffer(blob);

	return 0;
	}

	this._handle_cmd_disconnect = function(req)
	{
	this._log("disconnect received");
	this.stop();
	return 0;
	}

	this.recv_handlers = Object.freeze({
	[NBD_STATE_WAIT_CFLAGS]: this._handle_cflags.bind(this),
	[NBD_STATE_WAIT_OPTION]: this._handle_option.bind(this),
	[NBD_STATE_TRANSMISSION]: this._handle_cmd.bind(this),
	});
	}