FlashPolicyFileServer

var slice = Array.prototype.slice
  , net = require('net');

function Server(options, origins){
  var me = this;
  
  this.origins = origins || ['*:*'];
  this.port = 843;
  this.log = console.log;
  
  // merge `this` with the options
  Object.keys(options).forEach(function(key){
    me[key] && (me[key] = options[key])
  });
  
  // create the net server
  this.socket = net.createServer(function createServer(socket){
    socket.on('error', function socketError(){ me.responder.call(me, socket) });
    me.responder.call(me, socket);
  });
  
  // Listen for errors as the port might be blocked because we do not have root priv.
  this.socket.on('error', function serverError(err){
    // Special and common case error handling
    if (err.errno == 13){
      me.log && me.log(
        'Unable to listen to port `' + me.port + '` as your Node.js instance does not have root privileges. ' +
        (
          me.server
          ? 'The Flash Policy file will now be served inline over the supplied HTTP server, Flash Policy files request will suffer.'
          : 'No fallback server supplied.'
        )
      );
      
      me.socket.removeAllListeners();
      delete me.socket;

      me.emit('connect_failed', err);
    } else {
      me.log && me.log('FlashPolicyFileServer received a error event:\n' + (err.message ? err.message : err));
    }
  });
  
  this.socket.on('timeout', function serverTimeout(){});
  this.socket.on('close', function serverClosed(err){
    err && me.log && me.log('Server closing due to an error: \n' + (err.message ? err.message : err));
    
    if (me.server){
      // not online anymore
      delete me.server.online;
      
      // Remove the inline policy listener if we close down
      // but only when the server was `online` (see listen prototype)
      if( me.server['@'] && me.server.online){
        me.server.removeListener('connection', me.server['@']);
      }
    }
    me.log && me.log('Shutting down FlashPolicyFileServer');
  });
  
  // Compile the initial `buffer`
  this.compile();
}

Server.prototype.listen = function listen(port, server, cb){
  var me = this
    , args = slice.call(arguments, 0)
    , callback;
  
  // assign the correct vars, for flexible arguments
  args.forEach(function args(arg){
    var type = typeof arg;
    
    if (type === 'number') me.port = arg;
    if (type === 'function') callback = arg;
    if (type === 'object') me.server = arg;
  });
  
  if (this.server){
    
    // no one in their right mind would ever create a `@` prototype, so Im just gonna store
    // my function on the server, so I can remove it later again once the server(s) closes
    this.server['@'] = function connection(socket){
      socket.once('data', function requestData(data){
        // if it's a Flash policy request, and we can write to the 
        if (
             data
          && data[0] === 60
          &amp;&amp; data.toString() === '<policy-file-request/>\0'
          &amp;&amp; socket
          &amp;&amp; (socket.readyState === 'open' || socket.readyState === 'writeOnly')
        ){
          // send the buffer
          socket.end(me.buffer);
        }
      });
    };
    // attach it
    this.server.on('connection', this.server['@']);
  }
  
  // We add a callback method, so we can set a flag for when the server is `enabled` or `online`.
  // this flag is needed because if a error occurs and the we cannot boot up the server the
  // fallback functionality should not be removed during the `close` event
  this.socket.listen(this.port, function serverListening(){
   me.socket.online = true;
   
   if (callback) callback(), callback = undefined;
   
  });
  
  return this;
};

Server.prototype.add = function add(){
  var args = slice.call(arguments, 0)
    , i = args.length;
  
  // flag duplicates
  while (i--){
    if (this.origins.indexOf(args[i]) >= 0){
      args[i] = null;
    }
  }
  
  // Add all the arguments to the array
  // but first we want to remove all `falsy` values from the args
  Array.prototype.push.apply(
    this.origins
  , args.filter(function(value){ return !!value })
  );
  
  this.compile();
  return this;
};

Server.prototype.remove = function remove(origin){
  var position = this.origins.indexOf(origin);
  
  // only remove and recompile if we have a match
  if (position > 0){
    this.origins.splice(position,1);
    this.compile();
  }
  
  return this;
};

Server.prototype.close = function close(){
  this.socket.removeAllListeners();
  this.socket.close();
  
  return this;
};

Object.keys(process.EventEmitter.prototype).forEach(function proxy(key){
  Server.prototype[key] = Server.prototype[key] || function (){
    if (this.socket) this.socket[key].apply(this.socket, arguments);
    return this;
  };
});

exports.createServer = function createServer(options, origins){
  origins = Array.isArray(origins) ? origins : (Array.isArray(options) ? options : false);
  options = !Array.isArray(options) && options ? options : {};
  
  return new Server(options, origins);
};

exports.Server = Server;

exports.version = '0.0.2';