/**
 **      ==============================
 **       O           O      O   OOOO
 **       O           O     O O  O   O
 **       O           O     O O  O   O
 **       OOOO   OOOO O     OOO  OOOO
 **       O   O       O    O   O O   O
 **       O   O       O    O   O O   O
 **       OOOO        OOOO O   O OOOO
 **      ==============================
 **      BSSLAB, Dr. Stefan Bosse http://www.bsslab.de
 **
 **      COPYRIGHT: THIS SOFTWARE, EXECUTABLE AND SOURCE CODE IS OWNED
 **                 BY THE AUTHOR(S).
 **                 THIS SOURCE CODE MAY NOT BE COPIED, EXTRACTED,
 **                 MODIFIED, OR OTHERWISE USED IN A CONTEXT
 **                 OUTSIDE OF THE SOFTWARE SYSTEM.
 **
 **    $AUTHORS:     Stefan Bosse
 **    $INITIAL:     (C) 2006-2017 bLAB
 **    $CREATED:     2-6-15 by sbosse.
 **    $VERSION:     1.3.1
 **
 **    $INFO:
 **
 **  DOS: DNS Server, Embedded version
 *
 * Simplified embeddable DNS server without external persistent storage, used,
 * for example, by the host server publishing servers. The DNS service can be
 * restricted to handle only one root directory (restricted root mode).
 **
 **    $ENDOFINFO
 */
"use strict";

var log=0;

var util = Require('util');
var Io = Require('com/io');
var trace = Io.tracing;

var Net = Require('dos/network');
var Std = Require('dos/std');
var Sch = Require('dos/scheduler');
var Buf = Require('dos/buf');
var Rpc = Require('dos/rpc');
var Dns = Require('dos/dns_srv_common');
var Cs = Require('dos/capset');
var Comp = Require('com/compat');
var Cache = Require('dos/cache');
var Filename = Comp.filename;
var String = Comp.string;
var Array = Comp.array;
var Perv = Comp.pervasives;
var assert = Comp.assert;
var div = Perv.div;
var Rand = Comp.random;
var Status = Net.Status;
var Command = Net.Command;
var Rights = Net.Rights;
var Printf = Comp.printf;


/**
 * DNS Embedded Server Class
 * @param {rpcint} rpc
 * @constructor
 * @typedef {{rpc,std,cs,pubport,privport,random,rootmode,rootcs:capset,rootdir:dns_dir,ncols,cols,dirs,dirs_free,dirs_top,stats}} dns_server_emb~obj
 * @see dns_server_emb~obj
 * @see dns_server_emb~meth
 */
var dns_server_emb = function (rpc) {
    this.rpc=rpc;
    /** @type {std} std */
    this.std=Std.StdInt(rpc);
    this.cs=Cs.CsInt(rpc);
    this.pubport=undefined;
    this.privport=undefined;
    this.random=undefined;
    // one root directory only?
    this.rootmode=false;
    // root capability set
    this.rootcs=undefined;
    // root directory object
    this.rootdir=undefined;
    this.ncols=0;
    this.cols=[];
    this.lock=Sch.Lock();

    /** Capability cache to speed-up row
     *  capability restriction using a column mask.
     *  Key: cap-key+mask
     *  Value: Restricted cap
     *
     */
    this.cache_cap = Cache.Cache(100);

    /*
    ** Directory partition: associative array
     */
    this.dirs=[];
    this.dirs_free=[];
    this.dirs_top=0;
    this.stats = {
        op_read:0,
        op_modify:0,
        op_create:0,
        op_destroy:0
    }
};

/** Initialite and start up services
 *
 */

dns_server_emb.prototype.init = function () {
  var self=this;
  Sch.AddTimer(1000,'DNS Server Garbage Collector',function () {
    self.cache_cap.refresh(function (key,data) {
      if (data.tmo) { data.tmo--; return data.tmo>0}
      else return true;      
    });
  });
}

dns_server_emb.prototype.lock = function () {
    this.lock.acquire();
};

dns_server_emb.prototype.try_lock = function () {
    return this.lock.try_acquire();
};
dns_server_emb.prototype.unlock = function () {
    return this.lock.release();
};

/**
 * @typedef {{
 * create_dns:dns_server.create_dns,
 * lookup_dir:dns_server.lookup_dir,
 * check_dir:dns_server.check_dir,
 * create_dir:dns_server.create_dir,
 * acquire_dir:dns_server.acquire_dir,
 * release_dir:dns_server.release_dir,
 * request_dir:dns_server.request_dir,
 * restrict:dns_server.restrict,
 * capset_of_dir:dns_server.capset_of_dir,
 * dir_of_capset:dns_server.dir_of_capset,
 * search_row:dns_server.search_row,
 * append_row:dns_server.append_row,
 * rename_row:dns_server.rename_row,
 * time:dns_server.time,
 * }} dns_server_emb~meth
 */

/**
 *
 * @param {port} pubport
 * @param {port} privport
 * @param {port} random
 * @param {boolean} rootmode
 * @param {string []} cols
 */
dns_server_emb.prototype.create_dns = function (pubport,privport,random,rootmode,cols) {
    this.pubport=pubport;
    this.privport=privport;
    this.random=random;
    this.ncols=cols.length;
    this.cols=cols;
    this.rootmode=rootmode;
    this.dirs=[];
    this.dirs_free=[];
    this.dirs_top=1;    // The next not allocated entry
    /*
    ** Create the root directory (object number 1)
     */
    this.rootdir=this.create_dir(cols);
    this.rootdir.dd_random=random;
    this.rootcs=this.capset_of_dir(this.rootdir,Rights.PRV_ALL_RIGHTS);
    this.release_dir(this.rootdir);
};



/** Lookup a directory object (priv.prv_obj) and check the required rights.
 *  The directory is returned unlocked!
 *
 * @param {privat} priv
 * @param {number} req
 * @returns {dns_dir|undefined}
 */
dns_server_emb.prototype.lookup_dir = function(priv,req) {
    var self = this;
    var obj = Net.prv_number(priv);

    if (obj < 1 || obj >= this.dirs_top) return undefined;
    var dir = self.dirs[obj];
    var rights = Net.prv_rights(priv);
    /*
     ** When checking the presence of column rights, only take the
     ** *actual*
     ** columns present into account (i.e., do not use DNS_COLMASK here)
     */
    var colmask = Dns.dns_col_bits[dir.dd_ncols] - 1;

    Io.log((log<1)||('Dns_server.lookup_dir: '+Net.Print.private(priv))+' req='+req+' colmask='+colmask+' rights='+rights);

    if (!Net.prv_decode(priv, dir.dd_random)) {
        return undefined;
    }
    if ((rights & colmask) == 0 ||
        (rights & req) != req) {
        return undefined;
    }
    return dir;
};

/**
 ** With a given directory capability set check if this directory belongs
 ** to this server.
 *
 *
 * @param {capset} dir
 * @returns {private|undefined}
 */
dns_server_emb.prototype.check_dir = function(dir) {
    var self=this;
    Io.log((log<1)||('Dns_server.check_dir: '+Cs.Print.capset(dir)));
    if (dir==undefined) return undefined;
    for (var i = 0; i<dir.cs_final;i++) {
        var s = dir.cs_suite[i];
        if (s.s_current == true) {
            var cap = s.s_object;
            if (Net.Equal.port(cap.cap_port, self.pubport) == true &&
                Net.prv_number(cap.cap_priv) != 0) {
                /*
                 ** A capability for me. Check it.
                 */
                return cap.cap_priv;
            }
        }
    }
    Io.log((log<1)||'Dns_server.check_dir: not for me');
    return undefined;
};

/**
 ** Create a new directory. Return the directory structure and
 ** the status returned by the server create function. The super structure
 ** is already modified by this function. The new directory remains
 ** locked.
 *
 *
 * @param {string []} colnames
 * @returns {dns_dir|undefined}
 */
dns_server_emb.prototype.create_dir = function(colnames) {
    var ncols=colnames.length;
    /**
     *
     * @type {dns_dir|undefined}
     */
    var dir=undefined;
    if (!Array.empty(this.dirs_free)) {
        /*
        ** There is an already unused existing directory, claim it.
         */
        var next = Array.pop(this.dirs_free);
        dir=this.dirs[next];
        assert((dir!=undefined && dir.dd_objnum==next)||'Dns_server.create_dir: invalid directory found');
        dir.init(colnames,Dns.Dns_dir_state.DD_unlocked,this.time(),Dns.DNS_MAX_LIVE);
        dir.lock();  // non-blocking, we are the first one accessing the directory
    } else {
        dir=Dns.Dns_dir(this.dirs_top,ncols,0,colnames,Net.uniqport(),
                                 [],Dns.Dns_dir_state.DD_unlocked,this.time(),Dns.DNS_MAX_LIVE);
        this.dirs[this.dirs_top]=dir;
        this.dirs_top++;
        dir.lock();  // non-blocking, we are the first one accessing the directory
    }
    return dir;
};

/** Create a new directory. Return the directory structure and
 ** the status returned by the server create function. The super structure
 ** is already modified by this function. The new directory remains
 ** locked.
 *
 * @param colnames
 * @param {function ((Status.STD_OK|*),(dns_dir|undefined))} callback
 */
dns_server_emb.prototype.alloc_dir = function (colnames,callback) {
    var self=this;
    assert(self.try_lock());
    var dir = self.create_dir(colnames);
    self.unlock();
    if (dir!=undefined) callback(Status.STD_OK,dir);
    else callback(Status.STD_NOSPACE,undefined);
};

/** Acquire and lock a directory with object number 'obj'. A
 ** release_dir call must follow this operation. [BLOCKING]
 *
 * @param {number} obj
 * @param {function((Status.STD_OK|*),dns_dir|undefined)} callback
 */

dns_server_emb.prototype.acquire_dir = function(obj,callback) {
    if (obj < 1 || obj >= this.dirs_top) callback(Status.STD_OBJBAD,undefined);
    else {
        var dir = this.dirs[obj];
        if (dir == undefined) callback(Status.STD_NOTFOUND,undefined); else
        Sch.ScheduleBlock([
            function () {dir.lock();},
            function () {callback(Status.STD_OK,dir)}
        ]);
    }
};



/** Release an acquired directory
 * @param {dns_dir} dir
 * @param callback
 */
dns_server_emb.prototype.release_dir = function(dir,callback) {
    if (dir.dd_state == Dns.Dns_dir_state.DD_unlocked ||
        dir.dd_state == Dns.Dns_dir_state.DD_modified) {
        // Nothing to do here!
        dir.dd_state=Dns.Dns_dir_state.DD_locked;
    }
    dir.unlock();
    if (callback!=undefined) callback(Status.STD_OK);
};

/** Release an unmodified directory [NON BLOCKING].
 *
 * @param dir
 */
dns_server_emb.prototype.release_unmodified_dir = function(dir) {
    this.release_dir(dir);
};

/**
 ** A client request arrived.  Enter the critical section.  Check the capability.
 ** If correct, check whether the required rights are present or not.
 ** Return the directory structure, but only if the required rights are present.
 *
 * @param {private} priv
 * @param req
 * @param {function((Status.STD_OK|*),dns_dir|undefined)} callback
 */
dns_server_emb.prototype.request_dir = function(priv,req,callback) {
    var self=this;
    var obj = Net.prv_number(priv);
    var dir=undefined;
    var stat=Status.STD_UNKNOWN;

    Sch.ScheduleBlock([
        function () {
            Io.log((log<1)||('Dns_server.request_dir: acquire_dir('+obj+')'));
            self.acquire_dir(obj,function (_stat,_dir) {
                stat=_stat;
                dir=_dir;
            })
        },
        function () {
            if (stat!=Status.STD_OK) throw stat;
            var rights = Net.prv_rights(priv);

            /*
             ** When checking the presence of column rights, only take the
             ** *actual*
             ** columns present into account (i.e., do not use DNS_COLMASK here)
             */
            var colmask = Dns.dns_col_bits[dir.dd_ncols]-1;

            Io.log((log<1)||('Dns_server.request_dir: '+Net.Print.private(priv))+' req='+req+' colmask='+colmask+' rights='+rights);

            if (!Net.prv_decode(priv,dir.dd_random)) {

                throw Status.STD_DENIED;
            }
            if ((rights & colmask) ==0 ||
                (rights & req) != req) {
                throw Status.STD_DENIED;
            }
            callback(Status.STD_OK,dir);
        }
    ],function (e) {
        if (dir!=undefined) self.release_unmodified_dir(dir);
        if (typeof e != 'number') {Io.printstack(e,'Dns_server.request_dir');}
        if (typeof e == 'number') callback(e,undefined); else callback(Status.STD_SYSERR,undefined);
    });
};


/** Restrict a directory capability set.
 *  The directoty structure from capability set 'dir' must be unlocked to avoid.
 *
 * @param {capset} cs
 * @param mask
 * @param {function((Status.STD_OK|*),capset|undefined)} callback
 */
dns_server_emb.prototype.restrict = function(cs,mask,callback) {
    var self=this,
        cs=Cs.Copy.capset(cs),
        stat=Status.STD_CAPBAD,
        index=0;
    Sch.ScheduleLoop(function() {
        return (stat!=Status.STD_OK && index<cs.cs_final);
    },[
        function () {
            var s = cs.cs_suite[index],
                cap,key,cache;
            index++;
            if (s.s_current == true) {
                cap = s.s_object;
                if (Net.Equal.port(cap.cap_port, self.pubport) == true &&
                    Net.prv_number(cap.cap_priv) != 0) {
                    /*
                     ** A capability for me. Restrict it.
                     */
                    var dir = self.lookup_dir(cap.cap_priv,0);  // dir is unlocked, no release!
                    cap.cap_priv=Net.prv_encode(cap.cap_priv.prv_obj,
                        cap.cap_priv.prv_rights & mask,
                        dir.dd_random);
                    stat=Status.STD_OK;
                } else {
                    Io.log((log<1)||('Dns_server.restrict: doing std_restrict for '+Net.Print.capability(cap)+' with mask='+mask));
                    // Try to use capability cache - but can be outdated
                    key=Net.key(cap);
                    cache=self.cache_cap.lookup(key);
                    if (cache && cache.restrict && cache.restrict[mask]) {
                      Net.Copy.private(cache.restrict[mask].cap_priv,cap.cap_priv);
                      stat=cache.stat;
                    } else self.std.std_restrict(cap,mask,function (_stat,_cap) {
                        Io.log((log<1)||('Dns_server.restrict: std_restrict returned: '+Status.print(_stat)));
                        stat=_stat;
                        if (stat==Status.STD_OK) {
                          if (cache && cache.restrict) {cache.stat=stat; cache.restrict[mask]=_cap; cache.tmo=10;} else
                            self.cache_cap.add(key,{restrict:self.cache_cap.map(mask,_cap),tmo:10,stat:stat});
                          Net.Copy.private(_cap.cap_priv,cap.cap_priv);
                        } else {
                          if (cache && cache.restrict) {
                            cache.stat=stat; 
                            cache.restrict[mask]=Net.nilcap, 
                            cache.cap=cap
                          } else 
                            self.cache_cap.add(key,{restrict:self.cache_cap.map(mask,Net.nilcap),
                                                    tmo:10,stat:stat,cap:cap});
                        }
                    });
                }
            }
        }
    ],[
        function () {
            callback(stat,cs);
        }
    ],function (e) {
        if (typeof e != 'number') {Io.printstack(e,'Dns_server.restrict');}
        if (typeof e == 'number') callback(e,undefined); else callback(Status.STD_SYSERR,undefined);
    });
};

/** Convert a directory structure into a capability set with optional
 ** restricted rights.
 *
 * @param {dns_dir} dir
 * @param {number} [rights]
 * @returns {capset}
 */
dns_server_emb.prototype.capset_of_dir = function(dir,rights) {
    var cap = Net.Capability(
        this.pubport,
        Net.prv_encode(dir.dd_objnum, rights||Rights.PRV_ALL_RIGHTS, dir.dd_random)
    );

    return this.cs.cs_singleton(cap);
};

/** Get a directory from a capability set - non-blocking version.
 ** Fail if the directory is already locked. Internal use only.
 ** The directoty will not be locked (acquired)!
 *
 * @param {capset} cs
 * @return {dns_dir|undefined}
 */
dns_server_emb.prototype.dir_of_capset = function(cs) {
    var dir = undefined;
    var priv = this.check_dir(cs);
    if (priv == undefined) return undefined;
    var obj = Net.prv_number(priv);
    if (obj < 1 || obj >= this.dirs_top) return undefined;
    else {
        dir = this.dirs[obj];
        if (dir.dd_lock.is_locked()) return undefined;
        return dir;
    }
};


/** Search a row in the directory with give name.
 *
 * @param {dns_dir} dir
 * @param {string} name
 * @returns {dns_row|undefined}
 */
dns_server_emb.prototype.search_row = function(dir,name) {
    return Array.find(dir.dd_rows,function (row) {
        return String.equal(row.dr_name,name);
    })
};

/** Append a row to a directory.
 *
 * @param {dns_dir}  dir
 * @param {dns_row} row
 */
dns_server_emb.prototype.append_row = function(dir,row) {
    dir.dd_rows.push(row);
    dir.dd_nrows++;
    dir.dd_state=Dns.Dns_dir_state.DD_modified;
};

/** Rename a row. Return status.
 *
 * @param {dns_dir} dir
 * @param oldname
 * @param newname
 * @returns {(Status.STD_OK|*)}
 */
dns_server_emb.prototype.rename_row = function(dir,oldname,newname) {
    var row=Array.find(dir.dd_rows,function(row) {
        return (String.equal(row.dr_name,oldname));
    });
    if (row!=undefined) {
        /*
         ** Check that the new entry name doesn't exist already
         */
        var exist = Array.check(dir.dd_rows,function(row) {
                return (String.equal(row.dr_name,newname));
            });
        if (exist) return Status.STD_EXISTS;
        row.dr_name=newname;
        dir.dd_state=Dns.Dns_dir_state.DD_modified;
        return Status.STD_OK;
    } else return Status.STD_NOTFOUND;
};

/** Search a row in the directory with give name.
 *
 * @param {dns_dir} dir
 * @param {string} name
 */
dns_server_emb.prototype.delete_row = function(dir,name) {
    var found;
    dir.dd_rows =  Array.filter(dir.dd_rows,function (row) {
        var eq=String.equal(row.dr_name,name);
        if (eq) found=true;
        return !eq;
    });
    dir.dd_nrows=Array.length(dir.dd_rows);
    if (found) return Status.STD_OK;
    else return Status.STD_NOTFOUND;
};

dns_server_emb.prototype.stat = function () {
  var str='Statistics\n==========\n';
  str=str+Printf.sprintf2([['%20s','#DIRS'],':',['%8d',this.dirs.length],'  ',
                           ['%20s','#FREE'],':',['%8d',this.dirs_free.length]])+'\n';
  str=str+Printf.sprintf2([['%20s','READ'],':',['%8d',this.stats.op_read],'  ',
                           ['%20s','MODIFY'],':',['%8d',this.stats.op_modify]])+'\n';
  str=str+Printf.sprintf2([['%20s','CREATE'],':',['%8d',this.stats.op_create],'  ',
                           ['%20s','DESTROY'],':',['%8d',this.stats.op_destroy]])+'\n';
  return str;
}
/**
 ** Get the current system time in 10s units
 *
 * @returns {number}
 */
dns_server_emb.prototype.time =function () {
    var self=this;
    return div(Perv.time(),10);
};

/*
 ** ================
 ** PUBLIC INTERFACE
 ** ================
 */

var DnsRpc = Require('dos/dns_srv_rpc');
//dns_server.prototype=new DnsRpc.dns_server_rpc();
dns_server_emb.prototype.dns_lookup=DnsRpc.dns_server_rpc.prototype.dns_lookup;
dns_server_emb.prototype.dns_create=DnsRpc.dns_server_rpc.prototype.dns_create;
dns_server_emb.prototype.dns_append=DnsRpc.dns_server_rpc.prototype.dns_append;
dns_server_emb.prototype.dns_rename=DnsRpc.dns_server_rpc.prototype.dns_rename;
dns_server_emb.prototype.dns_delete=DnsRpc.dns_server_rpc.prototype.dns_delete;
dns_server_emb.prototype.dns_info=DnsRpc.dns_server_rpc.prototype.dns_info;
dns_server_emb.prototype.dns_stat=DnsRpc.dns_server_rpc.prototype.dns_stat;
dns_server_emb.prototype.dns_list=DnsRpc.dns_server_rpc.prototype.dns_list;
dns_server_emb.prototype.dns_setlookup=DnsRpc.dns_server_rpc.prototype.dns_setlookup;


module.exports = {
    /**
     *
     * @param {rpcint} rpc
     * @returns {dns_server_emb}
     */
    Server: function(rpc) {
        var obj = new dns_server_emb(rpc);
        Object.preventExtensions(obj);
        return obj;
    }
};