diff -up ./esc/src/app/esc.js.fix4 ./esc/src/app/esc.js

--- ./esc/src/app/esc.js.fix4	2019-01-10 16:19:14.676953557 -0800

+++ ./esc/src/app/esc.js	2019-01-10 16:19:22.530914751 -0800

@@ -23,7 +23,14 @@ const Gio = imports.gi.Gio;

 const GObject = imports.gi.GObject;

 const Pango = imports.gi.Pango;

 const GLib = imports.gi.GLib;

+const PhoneHome = imports.phoneHome;

+const OperationDialog = imports.operationDialog;

+const PinDialog = imports.pinDialog;

+const ESC_CONFIG_FILE_NAME = "esc.conf";

+const ESC_CONFIG_GROUP = "ESC";

+const ESC_PWORD_FILE = "pword";

+const UNKNOWN_LABEL = "unknown";

 const CoolKeyNotifyIface = '<node> \

 <interface name="com.jmagne.CoolKeyNotify"> \

 <method name="notifyCoolKeyEvent"> \

@@ -36,6 +43,25 @@ const CoolKeyNotifyIface = '<node> \

 </interface> \

 </node>';

+

+// Get application folder and add it into the imports path

+function getAppFileInfo() {

+    let stack = (new Error()).stack,

+        stackLine = stack.split('\n')[1],

+        coincidence, path, file;

+

+    if (!stackLine) throw new Error('Can not find path!');

+

+    coincidence = new RegExp('@(.+):\\d+').exec(stackLine);

+    if (!coincidence) throw new Error('Could not find current file!');

+

+    path = coincidence[1];

+    file = Gio.File.new_for_path(path);

+    return [file.get_path(), file.get_parent().get_path(), file.get_basename()];

+}

+const path = getAppFileInfo()[1];

+

+

 const CoolKeyNotify = new Lang.Class({

     Name: 'CoolKeyNotify',

@@ -73,8 +99,20 @@ class ESC {

         this.application = new Gtk.Application();

         this.application.connect('activate', this._onActivate.bind(this));

         this.application.connect('startup', this._onStartup.bind(this));

+        this._selectedTokenInfo = null;

+        this._notifyCallback = null;

+        this._currentDir = path;

     }

+    _setNotifyCallback(cb) {

+        this._notifyCallback = cb;

+

+    }

+

+    _clearNotifyCallback() {

+        this._notifyCallback = null;

+     }

+

     _onActivate() {

         this._window.present();

     }

@@ -94,6 +132,28 @@ class ESC {

          }

      }

+   _onCertDetail() {

+       this._promptPin();

+    }

+

+   _onFormat() {

+        this._operationMgr = new OperationDialog.operationDialog(this);

+        this._operationMgr.launchOperation(this._selectedTokenInfo,OperationDialog.OP_FORMAT);

+    }

+

+    _onEnroll() {

+        this._operationMgr = new OperationDialog.operationDialog(this);

+        this._operationMgr.launchOperation(this._selectedTokenInfo,OperationDialog.OP_ENROLL);

+    }

+

+    _onResetPin() {

+       this._operationMgr = new OperationDialog.operationDialog(this);

+       this._operationMgr.launchOperation(this._selectedTokenInfo,OperationDialog.OP_PIN_RESET);

+    }

+

+   _onPhoneHome() {

+       this._phoneHomeMgr.getPhoneHomeInfo(this._selectedTokenInfo,true);

+    }

     _onExit() {

         if(this.notify) {

             this.notify._dbusImpl.unexport();

@@ -115,6 +175,9 @@ class ESC {

                this._removeCoolkey(aKeyType, aKeyID, aKeyState, aData, strData);

             break;

             default:

+               if(this._notifyCallback) {

+                   this._notifyCallback(aKeyType, aKeyID,aKeyState, aData,strData);

+               }

             break;

         }

     }

@@ -126,10 +189,10 @@ class ESC {

             break;

             case 2:

-                return "unitialized";

+                return "uninitialized";

             break;

             case 1:

-                return "no applet";

+                return "unknown";

             break;

             default:

                 return "unknown";

@@ -137,8 +200,12 @@ class ESC {

         }

      }

-    _insertCoolkey(aKeyType, aKeyID, aKeyState, aData, strData) {

+    _phoneHome(url) {

+        let info = this.mgr.phone_home(url); 

+        return info;

+     }

+    _insertCoolkey(aKeyType, aKeyID, aKeyState, aData, strData) {

          if(aKeyType && aKeyID) {

              let inserted = new Coolkey.Token({ key_type: String(aKeyType) ,

@@ -146,8 +213,68 @@ class ESC {

              this.mgr.get_token_info(inserted);

+             let issuer = inserted.issuer;

+             let issuedTo = inserted.issued_to;

+

+             if(issuer == null || issuer.length == 0) {

+                 issuer = "unknown";

+             }

+             if(issuedTo == null || issuedTo.length == 0) {

+                 issuedTo = "unknown";

+             }

              this._tokenStore.set (this._tokenStore.append(), [0, 1, 2, 3, 4],

-                [inserted.issuer, inserted.issued_to, this._getStatusString(inserted.status), aKeyID,aKeyType]);

+                [issuer, issuedTo, this._getStatusString(inserted.status), aKeyID,aKeyType]);

+

+             let [ isSelected, iter]  = this._tokenStore.get_iter_first();

+

+              while(isSelected) {

+                  if(aKeyID == this._tokenStore.get_value(iter,3)) {

+                      this.selection.select_iter(iter);

+                      break;

+                  }

+                  isSelected  = this._tokenStore.iter_next(iter);

+              }

+

+         }

+     }

+

+     _updateCoolkey(originalKey) {

+         if(originalKey) {

+             this._removeCoolkey(originalKey.key_type, originalKey.cuid,null, null, null);

+             this._insertCoolkey(originalKey.key_type, originalKey.cuid,null, null, null);

+         }

+

+     }

+     _updateOperationsArea(insertedToken, doReset) {

+         if(!insertedToken && !doReset) {

+             return;

+         }

+     

+         if(doReset) {

+             this._operationsGrid.remove(this._phoneHomeButton);

+             this._operationsGrid.remove(this._enrollButton);

+             this._operationsGrid.remove(this._resetPinButton);

+             this._operationsGrid.remove(this._formatButton);

+             this._operationsGrid.remove(this._certDetailButton);

+             this._operationsGrid.show_all();

+             return;

+         }

+ 

+         if(insertedToken.is_a_cool_key) {   

+             this._operationsGrid.add(this._phoneHomeButton);

+             this._operationsGrid.add(this._formatButton);

+             if(insertedToken.status == 2 ) {

+                 this._operationsGrid.add(this._enrollButton);

+             }

+          

+             // if enrolled 

+             if(insertedToken.status == 4) { 

+                 this._operationsGrid.add(this._enrollButton);

+                 this._operationsGrid.add(this._resetPinButton);

+                 this._operationsGrid.add(this._certDetailButton);

+             }

+

+             this._operationsGrid.show_all();

          }

      }

@@ -158,10 +285,13 @@ class ESC {

               if(aKeyID == this._tokenStore.get_value(iter,3)) {

                   this._tokenStore.remove(iter);

                   this._tokenInfoBuffer.text = "";

+                  this._updateOperationsArea(null,true);

                   return;

               }

               isSelected  = this._tokenStore.iter_next(iter);

          }

+

+         this._updateOperationsArea(null,true);

      }

     _updateTokenInfoTextView(coolkey_token) {

@@ -172,9 +302,160 @@ class ESC {

         let atr  = coolkey_token.atr;

         let issuer_info = coolkey_token.issuer_info;

-        this._tokenInfoBuffer.text = "Token ID: " + cuid + "\n" 

+        this._tokenInfoBuffer.text = "Token ID: " + cuid + "\n"

              + "ATR: " + atr + "\n"

-             + "Token Issuer URL: " + issuer_info + "\n";

+             + "Token Issuer URL: " + issuer_info + "\n"

+             + "Token is a CoolKey: " + coolkey_token.is_a_cool_key + "\n\n\n " ;

+

+     }

+

+     _getCertListDetail(certsList,pFileName) {

+

+          let i = 0;

+          let detail = "\n\nCerts In Detail \n\n";

+          let curDetail = "";

+          if(certsList == null) {

+             return null;

+          }

+

+          //right now for some reason specifying a nickname will list all certs

+          for(i = 0 ; i < 1; i++ ) {

+              curDetail = this._getCertDetail(certsList[i],pFileName); 

+

+              if(curDetail.length < 100) {

+                  detail += "Error finding cert detail.";

+              } else {

+                  detail += curDetail + "\n";

+              }

+          }

+

+          return detail;    

+

+     }

+

+     _getCertDetail(certObj, pFileName) {

+         if(certObj == null || pFileName == null) {

+             return null;

+         }

+

+         let certDetail = "";

+         let token = "";

+         let nick = "";

+         if(certObj.token == null) 

+             token = "internal"; 

+         else

+             token = certObj.token;

+

+         nick = certObj.nick;

+ 

+         certDetail = this._execProgram(['/usr/bin/certutil','-L','-d', this._getConfigPath(), '-h', token, '-f' , pFileName, '-n', token + ":" + nick]);

+

+         return certDetail;

+     }

+

+     _getCertList(coolkey_token,pFileName) {

+

+        let certInfo = "";

+

+        certInfo =  this._execProgram(['/usr/bin/certutil','-L','-d', this._getConfigPath(), '-h', 'all', '-f' , pFileName]);

+

+        let certs = this._parseCertList(certInfo);

+

+        let i = 0;

+        let certsInfo = "Certificate List\n";

+

+        if(certs.length == 0 ) {

+            certsInfo = certsInfo + "No Certificates Found\n";

+            return certsInfo;

+        }

+      

+        for(i = 0 ; i < certs.length; i++ ) {

+            certsInfo += "\n" + certs[i].token + " : " + certs[i].nick +  "\n";

+        }

+

+        certsInfo += this._getCertListDetail(certs,pFileName) + "\n";

+

+        return certsInfo;

+     }

+

+     _parseCertList(listStr) {

+

+         if(!listStr)

+            return;

+

+         let lines = listStr.split('\n');

+

+         let line = "";

+         let i = 0;

+         let token = "";

+         let nick = "";

+

+         let certlist = [];

+         for(i = 3 ; i < lines.length; i++) {

+

+             token = "";

+             nick = "";

+             let index = lines[i].search(/,/i);

+

+             if(index > 0) {

+                 line = lines[i];

+                 index -= 2;

+                 line = line.substring(0,index);

+                 line = line.trim();

+

+                 let sepIndex = line.indexOf(":");

+

+                 if(sepIndex > 0 ) {

+

+                     let res = line.split(":");

+

+                      if(res.length == 2) {

+                         token = res[0];

+                          nick = res[1];

+                      } else {

+                          token = "";

+                          nick = line;

+                      }

+                 

+                     certlist.push({

+                         token: token,

+                         nick: nick,

+                         certDetail: ""

+                     });

+                 }

+             }

+

+

+         }

+     

+         return certlist;   

+     }

+

+    _execProgram(args) {

+

+        let result = -1;

+        try {

+            let proc = new Gio.Subprocess({

+                argv: args ,

+                flags: Gio.SubprocessFlags.STDOUT_PIPE

+            });

+

+            proc.init(null);

+

+            let [res,stdoutb,stderrb] =  proc.communicate_utf8(null,null);

+

+            if(res == false) {

+               result = -1;

+               return result;

+            }

+

+            result = stdoutb.toString();

+

+        } catch (e) {

+            return result;

+        }

+

+        return result;

      }

     _onTokenTreeViewSelectionChanged()  {

@@ -188,9 +469,78 @@ class ESC {

              cuid: this._tokenStore.get_value(iter,3) } );

         this.mgr.get_token_info(selected);

+        this._updateOperationsArea(selected,true);

+        this._updateOperationsArea(selected,false);

+        this._selectedTokenInfo = selected;

         this._updateTokenInfoTextView(selected);

     }

+    _configValueWithKeyID(aKeyID,configValue) {

+        if(!configValue || !aKeyID)

+            return null;

+

+        return configValue + "-" + aKeyID;

+

+    }

+

+    _setConfigValue(name,value) {

+        if(!this._configFile) {

+            return;

+        }

+

+        try {

+            this._configFile.set_string(ESC_CONFIG_GROUP,name,value);

+            this._configFile.save_to_file(this._configFileName);

+        } catch(e) {

+            return;

+        }

+    }

+

+    _getConfigValue(name) {

+         if(!this._configFile) {

+             return null;

+         }

+

+         let value = null;

+         try {

+             value = this._configFile.get_string(ESC_CONFIG_GROUP,name);

+         } catch(e) {

+             return null;

+         }

+

+         return value;

+     }

+

+    _getPropertyValue(name) {

+         if(!this._propFile) {

+             return null;

+         }

+

+         let value = null;

+         try {

+             value = this._propFile.get_string(ESC_CONFIG_GROUP,name);

+         } catch(e) {

+             return null;

+         }

+

+         return value;

+     }

+

+    _initProperties() {

+

+         this._propFile = new GLib.KeyFile();    

+

+         this._propFileName =  this._currentDir + "/esc.properties";

+         let res = false;

+         try {

+             res = this._propFile.load_from_file (this._propFileName,  0 );

+         } catch(e) {

+             this._onExitClicked();

+             //IO error

+         }

+

+

+    }

     _initConfig() {

          // See if it exists already, otherwise create

          this._configFile =  new GLib.KeyFile();

@@ -208,17 +558,17 @@ class ESC {

              }

          }

-         let config_name = this._configPath + "/esc.conf";

+         this._configFileName = this._configPath + "/esc.conf";

          let res = false;

          try {

-             res = this._configFile.load_from_file (config_name,  0 );

+             res = this._configFile.load_from_file (this._configFileName,  0 );

          } catch(e) {

              // need to create config file

          }

          if (res == false) {

              this._configFile.set_string("ESC","name","Smart Card Utility");

-             res = this._configFile.save_to_file(config_name); 

+             this._configFile.save_to_file(this._configFileName); 

          } 

      }

@@ -235,24 +585,30 @@ class ESC {

                 this._window.set_icon_name('application-x-executable');

             }

-            this._hb = new Gtk.HeaderBar();

+            this._hb = new Gtk.HeaderBar({spacing: 10 });

             this._hb.set_title("Smart Card Manager");

             this._hb.set_show_close_button(true);

-            this._window.set_titlebar(this._hb);

-            this._headerTokenBox = new Gtk.Box({orientation: Gtk.Orientation.HORIZONTAL,halign: Gtk.Align.CENTER});

-            this._headerInfoBox = new Gtk.Box({orientation: Gtk.Orientation.HORIZONTAL,halign: Gtk.Align.CENTER});

+            this._window.set_titlebar(this._hb);

             this._infoLabel = new Gtk.Label({label: "Token Information",use_markup: true});

             this._tokenLabel = new Gtk.Label({label: "Tokens",use_markup: true});

-            this._headerInfoBox.add(this._infoLabel);

+            this._vSep = new Gtk.VSeparator();

+

+            this._hb.add(this._tokenLabel);

+            this._hb.pack_end(this._infoLabel);

+            //this._hb.add(this._vSep);

-            this._headerTokenBox.add(this._tokenLabel);

             this._initConfig();

+            this._initProperties();

+

+            this._statusMessages = null; 

+            this._getStatusMessages();

+         

             this._outerGrid = new Gtk.Grid({orientation: Gtk.Orientation.HORIZONTAL, border_width: 0});

-            this._tokenFrame = new Gtk.Frame({hexpand: true});

+            this._tokenFrame = new Gtk.Frame({hexpand: false, width_request: 300});

             this._infoFrame  = new Gtk.Frame({border_width: 0});

             this._tokenBox = new Gtk.Grid({orientation: Gtk.Orientation.VERTICAL, border_width: 0,hexpand: true});

@@ -280,33 +636,33 @@ class ESC {

              // Create the treeview

             this._tokenTreeView = new Gtk.TreeView ({

-                expand: true,

+                hexpand: true,

+                vexpand: true,

                 model: this._tokenStore });

             let issuer = new Gtk.TreeViewColumn ({ title: "Issuer" });

             let issuedTo = new Gtk.TreeViewColumn ({ title: "Issued To" });

             let status = new Gtk.TreeViewColumn ({ title: "Status" });

-            let tokenId = new Gtk.TreeViewColumn({ title: "Token Id"});

+            //let tokenId = new Gtk.TreeViewColumn({ title: "Token Id"});

             let bold = new Gtk.CellRendererText ({

-              weight: Pango.Weight.BOLD });

-

+              weight: Pango.Weight.BOLD});

             let normal = new Gtk.CellRendererText ();

             issuer.pack_start (bold, true);

             issuedTo.pack_start (normal, true);

             status.pack_start (normal, true);

-            tokenId.pack_start(normal,true);

+            //tokenId.pack_start(normal,true);

             issuer.add_attribute (bold, "text", 0);

             issuedTo.add_attribute (normal, "text", 1);

             status.add_attribute (normal, "text", 2);

-            tokenId.add_attribute(normal,"text",3);

+            //tokenId.add_attribute(normal,"text",3);

             this._tokenTreeView.insert_column (issuer, 0);

             this._tokenTreeView.insert_column (issuedTo, 1);

             this._tokenTreeView.insert_column (status, 2);

-            this._tokenTreeView.insert_column (tokenId, 3);

+            //this._tokenTreeView.insert_column (tokenId, 3);

             // Connect view slection to a method

             this._label = new Gtk.Label ({ label: "" });

@@ -329,37 +685,175 @@ class ESC {

                 hscrollbar_policy: Gtk.PolicyType.AUTOMATIC,

                 vscrollbar_policy: Gtk.PolicyType.AUTOMATIC,

                 shadow_type: Gtk.ShadowType.ETCHED_IN,

-                height_request: 400,

-                width_request: 400, });

+                height_request: 500,

+                width_request: 400 });

             this._scrolledTokenInfoWindow.add_with_viewport (this._tokenInfoTextView);

-            this._infoBox.add(this._headerInfoBox);

+            //this._infoBox.add(this._headerInfoBox);

+

+            //this._escImage = new Gtk.Image({file: this._currentDir + "/" + "enrolled-keyx2.png"});

+            //this._infoBox.add(this._escImage);

             this._infoBox.add(this._scrolledTokenInfoWindow);

-            this._operationsGrid =  new Gtk.Grid({orientation: Gtk.Orientation.VERTICAL, 

+

+            this._operationsGrid =  new Gtk.Grid({orientation: Gtk.Orientation.HORIZONTAL, 

                 halign: Gtk.Align.CENTER,

                 valign: Gtk.Align.CENTER,

-                row_spacing: 20,

-                border_width: 0});

+                row_spacing: 10,

+                column_spacing: 6,

+                border_width: 6});

             this._operationsLabel = new Gtk.Label({label: "Operations", use_markup: true});

+

+            this._certDetailButton = new Gtk.Button({ label: "Cert Info" });

+            this._certDetailButton.connect("clicked", this._onCertDetail.bind(this));

+

+

             this._infoBox.add(this._operationsGrid); 

-            this._operationsGrid.add(this._operationsLabel);

             this._exitButton = new Gtk.Button({ label: "Exit" });

             this._exitButton.connect("clicked", this._onExit.bind(this));

+

             this._operationsGrid.add(this._exitButton);

-           

-            this._tokenBox.add(this._headerTokenBox);

+            

+            this._operationsGrid.add(this._operationsLabel);

+            // operations buttons

+

+

+            this._phoneHomeButton = new Gtk.Button({ label: "Phone Home" });

+            this._phoneHomeButton.connect("clicked", this._onPhoneHome.bind(this));

+          

+            this._formatButton = new Gtk.Button({ label: "Format" });

+            this._formatButton.connect("clicked", this._onFormat.bind(this));

+

+            this._enrollButton = new Gtk.Button({ label: "Enroll" });

+            this._enrollButton.connect("clicked", this._onEnroll.bind(this));

+

+            this._resetPinButton = new Gtk.Button({ label: "Reset Pin" });

+            this._resetPinButton.connect("clicked", this._onResetPin.bind(this));

+

             this._tokenBox.add(this._tokenTreeView);

-            this._window.set_default_size(750, 550);

+            this._window.set_default_size(950, 500);

             this._window.connect('destroy',this._onWindowDestroy.bind(this));

             this._window.show_all();

+           

     } 

     _createCoolKeyMgr(dbusName) {

-        this.mgr = new Coolkey.Mgr({ dbusUniqueName: dbusName, config_dir: this._configPath});

-        //this.mgr.speak("Welcome to ESC...");

+        this.mgr = new Coolkey.Mgr({ dbusUniqueName: dbusName, config_dir: this._configPath, config_file_name: ESC_CONFIG_FILE_NAME });

+

+        this._phoneHomeMgr = new PhoneHome.phoneHome(this);

+       

+        if(!this.mgr || !this._phoneHomeMgr) {

+            this._onExitClicked(); 

+        }

     }

+

+    _alert(msg) {

+        this._messageDialog = new Gtk.MessageDialog ({

+            transient_for: this._window,

+            modal: true,

+            buttons: Gtk.ButtonsType.OK,

+            message_type: Gtk.MessageType.WARNING,

+            text: msg });

+

+        this._messageDialog.connect ('response', Lang.bind(this, this._response_cb));

+        this._messageDialog.show();

+    }

+

+    _promptPin() {

+

+        let status = this._selectedTokenInfo.status;

+

+        if(status == 4 /* enrolled */) {

+            this._pinMgr = new PinDialog.pinDialog(this);

+            this._pinMgr.launchPinPrompt(this._promptPinDone.bind(this));

+        }

+      

+    }

+    _promptPinDone(tempFileName) {

+

+        let coolkey_token = this._selectedTokenInfo;

+

+        this._tokenInfoBuffer.text += 

+              this._getCertList(coolkey_token,tempFileName)  + "\n";

+

+     }

+    _response_cb() {

+        if(this._messageDialog) {

+            this._messageDialog.destroy();

+        }

+        this._messageDialog = null;

+    }

+    _getConfigPath() {

+        return this._configPath;

+    }

+

+    _getStatusMessages() {

+

+        this._statusMessages = new Array(

+            this._getPropertyValue("errorNone"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorProblemCommToken"),

+            this._getPropertyValue("errorProblemResetTokenPin"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorLifeCyclePDU"),

+            this._getPropertyValue("errorTokenEnrollment"),

+            this._getPropertyValue("errorProblemCommToken"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorTermSecureConn"),

+            this._getPropertyValue("errorAuthFailure"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorTokenDisabled"),

+            this._getPropertyValue("errorSecureChannel"),

+            this._getPropertyValue("errorServerMisconfig"),

+            this._getPropertyValue("errorTokenUpgrade"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorExternalAuth"),

+            this._getPropertyValue("errorInvalidTokenType"),

+            this._getPropertyValue("errorInvalidTokenTypeParams"),

+            this._getPropertyValue("errorCannotPublish"),

+            this._getPropertyValue("errorCommTokenDB"),

+            this._getPropertyValue("errorTokenSuspended"),

+            this._getPropertyValue("errorPinResetable"),

+            this._getPropertyValue("errorConnLost"),

+            this._getPropertyValue("errorEntryTokenDB"),

+            this._getPropertyValue("errorNoTokenState"),

+            this._getPropertyValue("errorInvalidLostTokenReason"),

+            this._getPropertyValue("errorTokenUnusable"),

+            this._getPropertyValue("errorNoInactiveToken"),

+            this._getPropertyValue("errorProcessMultiTokens"),

+            this._getPropertyValue("errorTokenTerminated"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorKeyRecoveryFailed"),

+            this._getPropertyValue("errorInternalServer"),

+            this._getPropertyValue("errorKeyArchival"),