From fb6989edb8944b8c149b403bac52304c617239b2 Mon Sep 17 00:00:00 2001
From: sbosse <sbosse@uni-bremen.de>
Date: Mon, 21 Jul 2025 22:45:18 +0200
Subject: [PATCH] Mon 21 Jul 22:43:21 CEST 2025

---
 js/dos/dns.js | 939 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 939 insertions(+)
 create mode 100644 js/dos/dns.js

diff --git a/js/dos/dns.js b/js/dos/dns.js
new file mode 100644
index 0000000..930db0d
--- /dev/null
+++ b/js/dos/dns.js
@@ -0,0 +1,939 @@
+/**
+ **      ==============================
+ **       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:     31-3-15 by sbosse.
+ **    $VERSION:     1.1.8
+ **
+ **    $INFO:
+ **
+ **  DOS: DNS Client Interface
+ **
+ **    $ENDOFINFO
+ */
+"use strict";
+var log = 0;
+
+var util = Require('util');
+var Io = Require('com/io');
+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 Cs = Require('dos/capset');
+var Comp = Require('com/compat');
+var String = Comp.string;
+var Filename = Comp.filename;
+var Array = Comp.array;
+var Perv = Comp.pervasives;
+var Rand = Comp.random;
+var Status = Net.Status;
+var Command = Net.Command;
+var Rights = Net.Rights;
+
+
+/*
+** Use the default DNS server
+*/
+var DNS_DEFAULT      = undefined;
+var DNS_MAXPATH      = 255;
+var DNS_DEFAULT_COLS = ['owner','group','others'];
+var DNS_DEFAULT_RIGHTS = [
+    Rights.DNS_RGT_OWNER|Rights.DNS_RGT_GROUP|Rights.DNS_RGT_OTHERS|
+    Rights.DNS_RGT_READ|Rights.DNS_RGT_MODIFY|Rights.DNS_RGT_DELETE|Rights.DNS_RGT_CREATE,
+    Rights.DNS_RGT_GROUP|Rights.DNS_RGT_OTHERS|
+    Rights.DNS_RGT_READ,
+    Rights.DNS_RGT_OTHERS|
+    Rights.DNS_RGT_READ
+];
+var DNS_NTRY         = 3;
+var DNS_NOMOREROWS   = -1;
+var DNS_MAXCOLUMNS   = Net.DNS_MAXCOLUMNS;
+
+/** {@link dir_entry~obj}
+ * Directory Entry Class - one row
+ *
+ * @param {string} de_name
+ * @param {string} de_time
+ * @param {number []} de_columns
+ * @constructor
+ * @typedef {{de_name,de_time,de_columns}} dir_entry~obj
+ */
+var dir_entry = function (de_name,de_time,de_columns) {
+    this.de_name      = de_name;      // string;
+    this.de_time      = de_time;      // number;
+    this.de_columns   = de_columns;   // rights_bits array;
+};
+
+/** {@link dir~obj}
+** Directory Class - One directory
+ *
+ *
+ * @param {capset} [di_capset]
+ * @param {number} [di_ncols]
+ * @param {number} [di_nrows]
+ * @param {string []} [di_colnames]
+ * @param {dir_entry []} [di_rows]
+ * @param {number} [di_curpos]
+ * @constructor
+ * @typedef {{di_capset,di_ncols,di_nrows,di_colnames,di_rows,di_curpos}} dir~obj
+ */
+var dir = function (di_capset,di_ncols,di_nrows,di_colnames,di_rows,di_curpos) {
+    this.di_capset   = di_capset;       // capset
+    this.di_ncols    = di_ncols||0;     // int
+    this.di_nrows    = di_nrows||0;     // int
+    this.di_colnames = di_colnames||[]; // string array
+    this.di_rows     = di_rows||[];     // dns_dir_entry array
+    this.di_curpos   = di_curpos||0;    // int
+};
+
+/** Directory Entry Object
+ *
+ * @param de_name
+ * @param de_time
+ * @param de_columns
+ * @returns {dir_entry}
+ * @constructor
+ */
+function Dir_entry (de_name,de_time,de_columns) {
+    var obj = new dir_entry(de_name,de_time,de_columns);
+    Object.preventExtensions(obj);
+    return obj;
+}
+/**
+ ** One directory
+ *
+ *
+ * @param {capset} [di_capset]
+ * @param {number} [di_ncols]
+ * @param {number} [di_nrows]
+ * @param {string []} [di_colnames]
+ * @param {dir_entry []} [di_rows]
+ * @param {number} [di_curpos]
+ * @returns {dir}
+ */
+function Dir (di_capset,di_ncols,di_nrows,di_colnames,di_rows,di_curpos) {
+    var obj = new dir(di_capset,di_ncols,di_nrows,di_colnames,di_rows,di_curpos);
+    Object.preventExtensions(obj);
+    return obj;
+}
+
+
+/*
+** BUFFER operations
+ */
+function buf_put_rights (buf,rights) {
+    Buf.buf_put_int32(buf,rights);
+}
+
+function buf_get_rights (buf) {
+    var rights=0;
+    rights=Buf.buf_get_int32(buf);
+    return rights;
+}
+
+
+/*
+** ==========
+** DNS CLIENT
+ * ==========
+*/
+/** {@link dns~obj}
+ *  DNS Client Programming Interface
+ * @param {rpcint} rpc
+ * @constructor
+ */
+var dnsint = function(rpc,env) {
+    this.rpc=rpc;
+    this.std=Std.StdInt(rpc);
+    this.cs=Cs.CsInt(rpc);
+    this.env=env||{};
+    if (!this.env.rootdir) this.env.rootdir=Cs.nilcapset;
+    if (!this.env.rootdir) this.env.workdir=Cs.nilcapset;
+};
+
+/**
+ *
+ * @returns {[]}
+ */
+dnsint.prototype.default_colmask = function () {
+    var nmasks = Net.DNS_MAXCOLUMNS;
+    var def_mask = Io.getenv('DNSMASK','');
+    var mask_array=[];
+    if (String.equal(def_mask,'')) {
+        mask_array=Array.create(nmasks,0xff)
+    } else {
+        var def_mask_list = def_mask.split(':');
+        var def_mask_len = def_mask_list.length;
+        if (def_mask_len > nmasks) Io.err('default_colmask: invalid dns mask from environment');
+        for (var i=0;i<def_mask_len;i++) {
+            mask_array.push(Perv.int_of_string(def_mask_list[i]));
+        }
+    }
+    return mask_array;
+};
+
+/**
+ *
+ * @returns {capset|undefined}
+ */
+dnsint.prototype.get_workdir = function () {
+    return this.env.workdir;
+};
+
+/**
+ *
+ * @returns {capset|undefined}
+ */
+dnsint.prototype.get_rootdir = function () {
+    return this.env.rootdir;
+};
+
+/**
+ *
+ * @param cap
+ */
+dnsint.prototype.set_workdir = function (cap) {
+    this.env.workdir=this.cs.cs_singleton(cap);
+};
+
+/**
+ *
+ * @param cap
+ */
+dnsint.prototype.set_rootdir = function (cap) {
+    this.env.rootdir=this.cs.cs_singleton(cap);
+};
+
+/**
+ ** Perform a request to the DNS server. This function tries
+ ** to find out a valid capability from the capability set 'cs'.
+ *
+ *
+ * @param ntries
+ * @param {rpcio} rpcio
+ * @param {capset} cs
+ */
+dnsint.prototype.mktrans = function (ntries,rpcio,cs) {
+    var cs=cs,
+        buf,
+        self=this,
+        err = Status.STD_UNKNOWN,
+        failed = Status.STD_UNKNOWN,
+        tries = 1,
+        i=0,
+        s;
+
+    if (ntries>1) {
+        buf=Buf.Buffer(); // we must save the rpcio data, it may be overridden by a previous transaction!
+        Buf.buf_copy(buf,rpcio);
+    }
+    Io.log((log<1)||('Dns.mktrans max('+ntries+') '+Cs.Print.capset(cs)));
+    Sch.ScheduleLoop(function () {
+        return (tries <= ntries && err != Net.Status.STD_OK);
+    },[
+        function () {
+            s = cs.cs_suite[i];
+            i++;
+            if (i==cs.cs_final) {
+                i=0; tries++;
+            }
+            if (s.s_current == true) {
+                rpcio.header.h_port = s.s_object.cap_port;
+                Net.Copy.private(s.s_object.cap_priv,rpcio.header.h_priv);
+                if (ntries>1) Buf.buf_copy(rpcio,buf);
+
+                Io.log((log<1)||('Dns.mktrans ('+(tries-1)+') '+Rpc.Print.rpcio(rpcio)));
+                Sch.ScheduleBlock([
+                    /*
+                     ** Do the real transaction
+                     */
+                    [Sch.Bind(self.rpc, self.rpc.trans), rpcio],
+                    [function () {
+                        Io.log((log<10)||('mktrans returned ' + Rpc.Print.rpcio(rpcio)));
+                        err = rpcio.status||rpcio.header.h_status;
+                        if (err==Status.RPC_FAILURE && ntries > 1) {
+                            /*
+                             ** Retry idempotent operation, but return RPC_FAILURE
+                             ** in case we don't succeed in a following iteration.
+                             */
+                            failed=Status.RPC_FAILURE;
+                        }
+                    }]
+                ]);
+            }
+        }
+    ],[
+        function () {if (failed!=Status.STD_UNKNOWN) rpcio.status=failed;}
+    ], function(e) {
+        if (typeof e == 'number') rpcio.status=e; else {
+            Io.printstack(e,'Dns.mktrans');
+            rpcio.status=Status.STD_SYSERR;
+        }
+    })
+};
+
+/**
+ ** lookup  returns  the capability-set stored under the name
+ ** 'path' relative to the directory 'root'.  The root directory
+ ** can be any directory in the directory tree. The path rest
+ ** that can not be eresolved will be returned, too.
+ *
+ *
+ * @param {capset} rootcs
+ * @param {string} path
+ * @param {function(status:(Status.STD_OK|*),cs:(capset|undefined),string)} callback
+ */
+dnsint.prototype.dns_lookup = function (rootcs,path,callback) {
+    var self=this,
+        err,cs,res,
+        rpcio,depth,pos,path_len,cs_parent,finished,max_steps;
+    Io.log((log<1)||('Dns.dns_lookup ('+path+') root='+(rootcs?Cs.Print.capset(rootcs):'[]')));
+    try {
+        if (String.equal(path, '/')) {
+          rootcs=rootcs||this.get_rootdir();
+          if (rootcs) callback(Status.STD_OK, rootcs, '');
+          else throw Status.STD_NOTNOW;
+        } else {
+            path = Filename.path_normalize(path);
+            if (path.length==0) throw Status.STD_ARGBAD;
+            max_steps=10;
+            if (rootcs==DNS_DEFAULT) {
+                if (String.get(path,0)=='/') cs=self.get_rootdir();
+                else cs=self.get_workdir();
+                if (cs==undefined) res=[Status.STD_STD_NOTNOW];
+                else res=[Status.STD_OK,cs];
+            } else res=[Status.STD_OK,self.cs.cs_copy(rootcs)];
+            err=res[0];
+            cs=res[1];
+            if (err != Status.STD_OK) throw (err==undefined?Status.STD_SYSERR:err);
+            /*
+             ** Loop over the path components step by step and resolve the path.
+             ** Each run, the next path component is the new parent directory
+             ** for the next lookup.
+             */
+            rpcio=self.rpc.router.pkt_get();
+            depth= 1;
+            pos;
+            path_len=path.length;
+            cs_parent=cs;
+            finished=false;
+            if (path_len>0 && String.get(path,0)=='/') {
+                // remove a leading slash from path
+                path=String.trim(path,1,0);
+            }
+            Sch.ScheduleLoop(function () {
+                return (finished==false && err==Status.STD_OK);
+            },[
+                function () {
+                    if (depth>max_steps) {finished=true; cs=undefined; err=Status.STD_OVERFLOW;}
+                    path_len=path.length;
+                    if (String.equal(path,'.') || path_len==0) {
+                        finished=true;
+                        cs=cs_parent;
+                    }
+                },
+                function () {
+                    if (!finished && err==Status.STD_OK) {
+                        rpcio.header.h_command=Command.DNS_LOOKUP;
+                        rpcio.header.h_status=Status.STD_UNKNOWN;
+                        rpcio.pos=0;
+                        Buf.buf_put_string(rpcio,path);
+                        /*
+                         *  ------------
+                         *  name(string)
+                         *  ------------
+                         *  path(string)
+                         *  cs(capset)
+                         *  ------------
+                         */
+                        self.mktrans(DNS_NTRY,rpcio,cs_parent);
+                    }
+                },
+                function () {
+                    if (!finished && err==Status.STD_OK) {
+                        err=rpcio.status||rpcio.header.h_status;
+                        if (err==Status.STD_OK) {
+                            // Get path
+                            rpcio.pos=0;
+                            path=Buf.buf_get_string(rpcio);
+                            // Get capset
+                            cs=Cs.buf_get_capset(rpcio);
+                            cs_parent=cs;
+                            // Remove a leading slash from path
+                            if (path.length>0 && path[0]=='/') path=String.trim(path,1,0);
+                            depth++;
+                        } else {
+                            finished=true;
+                            cs=undefined;
+                        }
+                    }
+                }
+            ],[
+                // Finalize block
+                function () {
+                    callback(err,cs,path);
+                    self.rpc.router.pkt_discard(rpcio);
+                }
+            ],  // Exception handler function
+                function(e) {
+                    if (typeof e == 'number') callback(e, undefined, '');
+                    else {
+                        Io.printstack(e,'Dns.dns_lookup');
+                        callback(Status.STD_SYSERR, undefined, '');
+                    }
+                    self.rpc.router.pkt_discard(rpcio);
+                }
+            );
+        }
+    } catch (e) {
+        if (typeof e == 'number') callback(e, undefined, ''); else {
+            Io.printstack(e,'Dns.dns_lookup');
+            callback(Status.STD_SYSERR, undefined, '');
+        }
+    }
+};
+
+/**
+ ** Lookup a set of directory capabilities specified by a (directory capability set - row name) list.
+ ** The (status, row capset) tuple list is returned.
+ *
+ * @param {capset} server root directory
+ * @param {* []} dirs (dir:capset * rowname:string) []
+ * @param {function((Status.STD_OK|*),* [])} callback (Status*capset) []
+ */
+dnsint.prototype.dns_setlookup = function (server,dirs,callback) {
+    var rpcio=self.rpc.router.pkt_get();
+    var ndirs = dirs.length;
+    var stat;
+    Sch.ScheduleBlock([
+        function () {
+            /*
+             *  ------------
+             *  nrows(int16)
+             *  [
+             *    dir(capset)
+             *    rowname(string)
+             *  ] #nrows
+             *  ------------
+             *  [
+             *    status(int16)
+             *    cs(capset)
+             *  ] #nrows
+             *  ------------
+             */
+            rpcio.header.h_command=Command.DNS_SETLOOKUP;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            Buf.buf_put_int16(dirs.length);
+            Array.iter (dirs,function(dir) {
+                Cs.buf_put_capset(rpcio,dir[0]);    // directory capability set
+                Buf.buf_put_string(rpcio,dir[1]);   // row name
+            });
+            self.mktrans(DNS_NTRY,rpcio,server);
+        },
+        function(){
+            var i;
+            var res;
+            if (rpcio.status==Status.STD_OK) stat=rpcio.header.h_status;
+            if (stat != Status.STD_OK) throw(stat);
+            rpcio.pos=0;
+            for(i=0;i<ndirs;i++) {
+                var statn=Buf.buf_get_int16(rpcio);
+                var cs=Cs.buf_get_capset(rpcio);
+                res.push([stat,cs]);
+            }
+            callback(stat,res);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function(e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e, []); else {
+            Io.printstack(e,'Dns.dns_setlookup');
+            callback(Status.STD_SYSERR,[]);
+        }
+    });
+};
+
+/**
+ ** dns_list: return the row list of the directory specified by
+ **          'dir'
+ *
+ *
+ * @param {capset} dircs
+ * @param {function((Status.STD_OK|*),dir|undefined)} callback
+ */
+dnsint.prototype.dns_list = function (dircs,callback) {
+    var self=this,
+        stat=Status.STD_OK,
+        dir=Dir(dircs),
+        next_row=0,
+        ncols=0,
+        nrows=0,
+        rowoff=0,
+        rpcio=this.rpc.router.pkt_get();
+
+    function addtodir(firstrow,numrows,buf) {
+        var i,j;
+
+        for (i = firstrow; i < numrows; i++) {
+            var name = Buf.buf_get_string(buf);
+            var time = Buf.buf_get_int32(buf);
+            var rbits = [];
+            for (j = 0; j < dir.di_ncols; j++) {
+                rbits[j] = buf_get_rights(buf);
+            }
+            dir.di_rows.push(Dir_entry(name, time, rbits));
+        }
+    }
+    Io.log((log<1)||('Dns.dns_list dircs='+Cs.Print.capset(dircs)));
+    Sch.ScheduleLoop(
+        function (index) {
+            return (stat==Status.STD_OK && next_row != DNS_NOMOREROWS);
+        },[
+            function () {
+                rpcio.header.h_command = Command.DNS_LIST;
+                rpcio.header.h_status = Status.STD_UNKNOWN;
+                rpcio.pos = 0;
+                Buf.buf_put_int16(rpcio,rowoff);
+                /*
+                 *  --------------
+                 *  rowoff(int16)
+                 * ---------------
+                 *  next_row(int16)
+                 *  ncols(int16)
+                 *  nrows(int16)
+                 *  cols: [name(string)]   #ncols
+                 *  rows: [
+                 *    name(string)
+                 *    time(int32)
+                 *    [rights(int16)] #ncols
+                 *  ] #nrows
+                 *  --------------
+                 */
+                self.mktrans(DNS_NTRY, rpcio, dircs);
+            },
+            function () {
+                var i,rowoff,nrowschunk,numrows;
+                rpcio.pos=0;
+
+                if (rpcio.status==Status.STD_OK) stat=rpcio.header.h_status;
+                else stat=rpcio.status;
+                if (stat==Status.STD_OK) {
+                    if (next_row==0) {
+                        /*
+                        ** Initial request...
+                         */
+                        next_row = Buf.buf_get_int16(rpcio);
+                        ncols = Buf.buf_get_int16(rpcio);
+                        nrows = Buf.buf_get_int16(rpcio);
+                        dir.di_ncols=ncols;
+                        dir.di_nrows=nrows;
+                        for (i=0;i<ncols;i++) {
+                            dir.di_colnames.push(Buf.buf_get_string(rpcio));
+                        }
+                        if (nrows>0) {
+                            if (next_row != DNS_NOMOREROWS) numrows = next_row;
+                            else numrows=nrows;
+                            addtodir(0,numrows,rpcio);
+                        }
+                     } else {
+                        /*
+                        ** following requests
+                        */
+                        next_row = Buf.buf_get_int16(rpcio);
+                        ncols = Buf.buf_get_int16(rpcio);
+                        nrowschunk = Buf.buf_get_int16(rpcio);
+                        for (i=0;i<ncols;i++) {
+                            Buf.buf_get_string(rpcio);
+                        }
+                        /*
+                         ** append the current chunk of rows to dirs
+                         */
+                        if (next_row > 0) numrows = next_row-rowoff;
+                        else numrows=nrowschunk-rowoff;
+                        addtodir(rowoff,numrows,rpcio);
+                    }
+                }
+            }
+         ],[
+            function () {
+                callback(stat,dir);
+                self.rpc.router.pkt_discard(rpcio);
+            }
+        ],
+        function (e) {
+            self.rpc.router.pkt_discard(rpcio);
+            if (typeof e == 'number') callback(e, undefined); else {
+                Io.printstack(e,'Dns.dns_list');
+                callback(Status.STD_SYSERR,undefined);
+            }
+        }
+    );
+};
+
+/**
+ ** Append new 'obj' capability to directory specified with capset 'dir'
+ ** with row 'name' and the new column rights 'cols'. 'name' may not
+ ** a path! Use dns_lookup to resolve directory capability instead!
+ *
+ *
+ * @param {capset} dir
+ * @param {string} name
+ * @param {capset} obj
+ * @param {number []} cols
+ * @param {function(stat:(Status.STD_OK|*))} callback
+ */
+dnsint.prototype.dns_append = function (dir,name,obj,cols,callback) {
+    var self=this;
+    var ncols=cols.length;
+    var rpcio=self.rpc.router.pkt_get();
+    var stat=Status.STD_UNKNOWN;
+    Sch.ScheduleBlock([
+        function() {
+            rpcio.header.h_command=Command.DNS_APPEND;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            /*
+            *  -----
+            *  name:string
+            *  obj:capset
+            *  ncols:number
+            *  -----
+            *  -----
+             */
+            Buf.buf_put_string(rpcio,name);
+            Cs.buf_put_capset(rpcio,obj);
+            Buf.buf_put_int16(rpcio,ncols);
+            for (var n = 0; n < ncols; n++) {
+                buf_put_rights(rpcio, cols[n]);
+            }
+            self.mktrans(1,rpcio,dir);
+        },
+        function() {
+            if (rpcio.stat && rpcio.stat != Status.STD_OK) stat=rpcio.stat;
+            else stat=rpcio.header.h_status;
+            callback(stat);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function (e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e); else {
+            Io.printstack(e,'Dns.dns_append');
+            callback(Status.STD_SYSERR);
+        }
+    });
+};
+
+/**
+ *
+ * @param {capset} dir
+ * @param {string} oldname
+ * @param {string} newname
+ * @param {function((Status.STD_OK|*))} callback
+ */
+dnsint.prototype.dns_rename = function (dir,oldname,newname,callback) {
+    var self=this;
+    var stat;
+    var rpcio=self.rpc.router.pkt_get();
+    Sch.ScheduleBlock([
+        function() {
+            rpcio.header.h_command=Command.DNS_RENAME;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            /*
+             *  -----
+             *  oldname:string
+             *  newname:string
+             *  -----
+             *  -----
+             */
+            Buf.buf_put_string(rpcio,oldname);
+            Buf.buf_put_string(rpcio,newname);
+            self.mktrans(DNS_NTRY,rpcio,dir);
+        },
+        function() {
+            if (rpcio.stat && rpcio.stat != Status.STD_OK) stat=rpcio.stat;
+            else stat=rpcio.header.h_status;
+            callback(stat);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function (e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e); else {
+            Io.printstack(e,'Dns.dns_rename');
+            callback(Status.STD_SYSERR);
+        }
+    });
+
+};
+
+/**
+ ** dns_delete deletes the directory entry (which may itself be a
+ ** directory capability)  specified  by  'name' in directory
+ ** specified with capset 'dir'.
+ *
+ * @param {capset} dir
+ * @param {string} name
+ * @param {function((Status.STD_OK|*))} callback
+ */
+dnsint.prototype.dns_delete = function (dir,name,callback) {
+    var self=this;
+    var stat;
+    var rpcio=self.rpc.router.pkt_get();
+    Sch.ScheduleBlock([
+        function() {
+            rpcio.header.h_command=Command.DNS_DELETE;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            /*
+             *  -----
+             *  rowname:string
+             *  -----
+             *  -----
+             */
+            Buf.buf_put_string(rpcio,name);
+            self.mktrans(1,rpcio,dir);
+        },
+        function() {
+            if (rpcio.stat && rpcio.stat != Status.STD_OK) stat=rpcio.stat;
+            else stat=rpcio.header.h_status;
+            callback(stat);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function (e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e); else {
+            Io.printstack(e,'Dns.dns_delete');
+            callback(Status.STD_SYSERR);
+        }
+    });
+
+};
+/**
+ *
+ * @param {capset} rootdir
+ * @param {number []} colnames
+ * @param {function((Status.STD_OK|*),capset|undefined)} callback
+ */
+dnsint.prototype.dns_create = function (rootdir,colnames,callback) {
+    var cs=undefined;
+    var self=this;
+    var stat;
+    var ncols=colnames.length;
+    var rpcio=self.rpc.router.pkt_get();
+    Sch.ScheduleBlock([
+        function() {
+            rpcio.header.h_command=Command.DNS_CREATE;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            /*
+             *  -----
+             *  ncols(int16)
+             *  [colname(string)] #ncols
+             *  -----
+             *  cs(capset)
+             *  -----
+             */
+            Buf.buf_put_int16(rpcio,ncols);
+            for(var i=0;i<ncols;i++) {
+                Buf.buf_put_string(rpcio,colnames[i]);
+            }
+            self.mktrans(1,rpcio,rootdir);
+        },
+        function() {
+            rpcio.pos=0;
+            if (rpcio.stat && rpcio.stat != Status.STD_OK) stat=rpcio.stat;
+            else stat=rpcio.header.h_status;
+            if (stat==Status.STD_OK) {
+                var cs=Cs.buf_get_capset(rpcio);
+                callback(stat,cs);
+            } else
+                callback(stat,undefined);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function (e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e,undefined); else {
+            Io.printstack(e,'Dns.dns_create');
+            callback(Status.STD_SYSERR,undefined);
+        }
+    });
+};
+
+/**
+ ** dns_destroy deletes the entire directory
+ ** specified with capset 'dir'.
+ *
+ * @param {capset} dir
+ * @param {string} name
+ * @param {function((Status.STD_OK|*))} callback
+ */
+dnsint.prototype.dns_destroy = function (dir,name,callback) {
+    var self=this;
+    var stat;
+    var rpcio=self.rpc.router.pkt_get();
+    Sch.ScheduleBlock([
+        function() {
+            rpcio.header.h_command=Command.STD_DESTROY;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            /*
+             *  -----
+             *  -----
+             *  -----
+             */
+            self.mktrans(1,rpcio,dir);
+        },
+        function() {
+            if (rpcio.stat && rpcio.stat != Status.STD_OK) stat=rpcio.stat;
+            else stat=rpcio.header.h_status;
+            callback(stat);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function (e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e); else {
+            Io.printstack(e,'Dns.dns_destroy');
+            callback(Status.STD_SYSERR);
+        }
+    });
+
+};
+
+/** Try to get the server root capability set (e.g., from host server),
+ *  Only the host server port is required without any authorization fields.
+ *  Therefore, the request can be rejected by a server.
+ *
+ * @param {port} server
+ * @param {function((Status.STD_OK|*),capability|undefined)} callback
+ */
+dnsint.prototype.dns_getrootcap = function (server,callback) {
+    var cs=undefined;
+    var self=this;
+    var stat;
+    var rpcio=self.rpc.router.pkt_get();
+    Sch.ScheduleBlock([
+        function() {
+            rpcio.header.h_port=server;
+            rpcio.header.h_priv=Net.Private();
+            rpcio.header.h_command=Command.DNS_GETROOT;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            /*
+             *  -----
+             *  -----
+             *  cap(capability)
+             *  -----
+             */
+            /*
+             ** Do the real transaction
+             */
+            self.rpc.trans(rpcio);
+        },
+        function() {
+            rpcio.pos=0;
+            if (rpcio.stat && rpcio.stat != Status.STD_OK) stat=rpcio.stat;
+            else stat=rpcio.header.h_status;
+            if (stat==Status.STD_OK) {
+                var cap=Buf.buf_get_cap(rpcio);
+                callback(stat,cap);
+            } else
+                callback(stat,undefined);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function (e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e,undefined); else {
+            Io.printstack(e,'Dns.dns_getrootcap');
+            callback(Status.STD_SYSERR,undefined);
+        }
+    });
+};
+
+/** Try to get the default AFS server capability set (e.g., from DNS server),
+ *
+ * @param {capset} rootdir
+ * @param {function((Status.STD_OK|*),capability|undefined)} callback
+ */
+dnsint.prototype.dns_getdefafs = function (rootdir,callback) {
+    var cs=undefined;
+    var self=this;
+    var stat;
+    var rpcio=self.rpc.router.pkt_get();
+    Sch.ScheduleBlock([
+        function() {
+            rpcio.header.h_command=Command.DNS_GETDEFAFS;
+            rpcio.header.h_status=Status.STD_UNKNOWN;
+            rpcio.pos=0;
+            /*
+             *  -----
+             *  -----
+             *  cap(capability)
+             *  -----
+             */
+            self.mktrans(1,rpcio,rootdir);
+        },
+        function() {
+            rpcio.pos=0;
+            if (rpcio.stat && rpcio.stat != Status.STD_OK) stat=rpcio.stat;
+            else stat=rpcio.header.h_status;
+            if (stat==Status.STD_OK) {
+                var cap=Buf.buf_get_cap(rpcio);
+                callback(stat,cap);
+            } else
+                callback(stat,undefined);
+            self.rpc.router.pkt_discard(rpcio);
+        }
+    ],function (e) {
+        self.rpc.router.pkt_discard(rpcio);
+        if (typeof e == 'number') callback(e,undefined); else {
+            Io.printstack(e,'Dns.dns_getdefafs');
+            callback(Status.STD_SYSERR,undefined);
+        }
+    });
+};
+
+/** DNS Client Interface
+ *
+ *
+ */
+module.exports = {
+    DNS_MAXPATH:DNS_MAXPATH,
+    DNS_DEFAULT_COLS:DNS_DEFAULT_COLS,
+    DNS_DEFAULT_RIGHTS:DNS_DEFAULT_RIGHTS,
+    DNS_MAXCOLUMNS:DNS_MAXCOLUMNS,
+    DNS_NOMOREROWS:DNS_NOMOREROWS,
+    buf_put_rights:buf_put_rights,
+    buf_get_rights:buf_get_rights,
+    RIGHTS_SIZE:4,
+    Dir_entry:Dir_entry,
+    Dir:Dir,
+    /**
+     *
+     * @param {rpcint} rpc
+     * @returns {dnsint}
+     */
+    DnsInt: function(rpc,env) {
+        var obj = new dnsint(rpc,env);
+        Object.preventExtensions(obj);
+        return obj;
+    }
+};