//var gBrandBundle; -- defined in mailWindow.js
// manipulates some globals from msgReadSMIMEOverlay.js
-
-const SECURE_HEADER_SEPARATOR = "###HEADER_SEPARATOR###";
-const HEADER_VAL_SEPARATOR = "###HEADER_VAL###";
-
const nsICMSMessageErrors = Components.interfaces.nsICMSMessageErrors;
// Push signer header into existing header list
gSMIMEContainer.collapsed = false;
gSignedUINode.collapsed = false;
-
+ //gConsole.logStringMessage("[smimeHeaderSink:smimeHeaderSink] nsICMSMessageErrors : " + aSignatureStatus);
switch (aSignatureStatus) {
case nsICMSMessageErrors.SUCCESS:
gSignedUINode.setAttribute("signed", "ok");
if (askUser)
gMessageNotificationBar.setSMIMEReceiptRequestMsg(SMIMEReceiptGenerator, aReceiptsTo);
},
- secureHeadersStatus: function(aSecureHeaders, aCanonAlgo)
- {
+ updateSecureHeadersState: function(msgSrc){
+ // parse mime msg : extract headers
+ var currentMimeHeaderDataArray = {};
+ // get MIME headers only
+ var idxEnd = msgSrc.indexOf("\r\n\r\n",0); // * CRLF DOS : "\r\n"
+ if(idxEnd == -1) idxEnd = msgSrc.indexOf("\n\n",0); // * CRLF UNIX : "\n"
+ if(idxEnd == -1) idxEnd = msgSrc.indexOf("\r\r",0); //CRLF OS : "\r"
+ if(idxEnd != -1) msgSrc = msgSrc.substr(0,idxEnd); //dbg gConsole.logStringMessage("[smime - MessageAnalyser - succes getting mime headers : ] \n" + msgSrc);
+
+ // filter on IMF headers - append data to array
+ var separator = new RegExp("\\r\\n|\\r|\\n", "i");// end line
+ var tab = msgSrc.split(separator);
+ var reg_folding = new RegExp("( )","g");
+ var reg_folding2 = new RegExp("(\t)","g");
+ for(var idxTab=0; idxTab<tab.length; ++idxTab){
+ var header_line = tab[idxTab];
+ // search for long header fields (folding) - RFC 2822
+ if(header_line[0]!= " "){
+ try{
+ while( idxTab < tab.length ){
+ var next_line = tab[idxTab+1];
+ if(next_line){
+ if(next_line[0] == " " || next_line[0] == "\t"){
+ header_line += next_line; //next_line.toLowerCase();
+ header_line = header_line.replace(reg_folding," ");
+ header_line = header_line.replace(reg_folding2,"");
+ ++idxTab;
+ }else{ break; }
+ }else{ break; }
+ }
+ }catch(e){}
+ }
+ //gConsole.logStringMessage("[ximfmail - createXimfHdrArray - decode header line : ] \n" + header_line);
+
+ if(header_line.indexOf(":")!=-1){
+ var oEntry = new Object;
+ oEntry.headerName = header_line.substring(0,header_line.indexOf(": ",0));
+ oEntry.headerValue = header_line.substring(header_line.indexOf(": ",header_line)+2);
+ currentMimeHeaderDataArray[oEntry.headerName] = oEntry;
+ //gConsole.logStringMessage("[smime - MessageAnalyser - push : ] \n" + oEntry.headerName + " :: "+ oEntry.headerValue);
+ }
+ }
+ // Compute secure headers and mime headers
+ //gConsole.logStringMessage("[smime - updatesecureheaders ] *** secureHeaders analysis begin *** " );
var secStatus = true; //flag for the global secure headers status, set at true as default means all secure headers were not modified
- gSecureHeaders="";
-
- if(aSecureHeaders)
- {
- // gConsole.logStringMessage("*** secureHeaders analysis begin ***\ncanonization Algorithm : " + aCanonAlgo);
gSecureHeadersState=1;
- var secureHeaders=aSecureHeaders.QueryInterface(nsIArray);
- var hdrArray=getMsgHdr(); //get selected mime message headers list
- for(var i=0;i<secureHeaders.length;++i)
- {
- var sHeader = secureHeaders.queryElementAt(i,nsIMsgSMIMESecureHeader);
- if(sHeader){
- var hdrName = sHeader.headerName; // signed header
- var hdrValue = sHeader.headerValue; // Value in the signature
- var hdrMimeValue = ""; // value in the MIME message
- var hdrStatus = ""+sHeader.headerStatus;
- var hdrValidity = "valid" //set the default header validity to ok, it means the header was not modified
- var hdrCanonizValue=aCanonAlgo;
- var headerMimeExists = false;
- var tmp_hdrName = "";
- var tmp_hdrMimeName = "";
- //var headerEncrypted = sHeader.headerEncrypted;
+ for (headerName in gSecureHeadersArray) {
//Verify the value validity only in the case where header status is duplicated
- tmp_hdrName = hdrName;
- if(aCanonAlgo){
+ var headerMimeExists = false;
+ var tmp_hdrName = gSecureHeadersArray[headerName].hdrName;
+ var canonalgo = gSecureHeadersArray[headerName].hdrCanonAlgo;
+ if(canonalgo){
// RFC 4871 - relaxed header canonicalization algorithm - convert header field names to lowercase
tmp_hdrName = tmp_hdrName.toLowerCase();
}
- // gConsole.logStringMessage("secureHeadersStatus - \n check for signed header "+tmp_hdrName);
- for(var j=0;j<hdrArray.length;++j){
- tmp_hdrMimeName = hdrArray[j]._hdrName;
- if(aCanonAlgo){
+ //gConsole.logStringMessage("secureHeadersStatus - \n check for signed header "+tmp_hdrName);
+ //for(var j=0;j<hdrArray.length;++j){
+ for(headerMimeName in currentMimeHeaderDataArray){
+ var tmp_hdrMimeName = currentMimeHeaderDataArray[headerMimeName].headerName;
+ if(canonalgo){
// RFC 4871 - relaxed header canonicalization algorithm - convert header field names to lowercase
tmp_hdrMimeName = tmp_hdrMimeName.toLowerCase();
}
- // gConsole.logStringMessage("secureHeadersStatus - \nsigned header : "+tmp_hdrName+"\nmime header : "+tmp_hdrMimeName);
-
- if(tmp_hdrName==tmp_hdrMimeName){
+ //gConsole.logStringMessage("secureHeadersStatus - \nsigned header : "+tmp_hdrName+"\nmime header : "+tmp_hdrMimeName);
+ if(tmp_hdrName == tmp_hdrMimeName){
// compare secured value ans MIME value of header
headerMimeExists = true; // header is in mime
- hdrMimeValue=hdrArray[j]._hdrValue;
+ var hdrValue = gSecureHeadersArray[headerName].hdrSecureValue;
+ var hdrMimeValue = currentMimeHeaderDataArray[headerMimeName].headerValue;
var charset = getMimeValueCharset(hdrMimeValue);
// body - delete SP/WPS characters before and after body
hdrMimeValue = deleteFirstAndLastWhiteSpace(hdrMimeValue);
hdrValue = deleteFirstAndLastWhiteSpace(hdrValue);
- if(aCanonAlgo){
+ if(canonalgo){
hdrMimeValue = canonilizeHeaderValue(hdrMimeValue);
hdrValue = canonilizeHeaderValue(hdrValue);
//gConsole.logStringMessage("secureHeadersStatus - relaxed canonicalization \n mime value:\n>" +hdrMimeValue+ "<\nsigend value:\n>"+hdrValue+"<");
if(hdrValue!=hdrMimeValue) //test if the header value in the signature and that one in the mime message is the same
{
- hdrValidity="invalid"; //header was modified
+ gSecureHeadersArray[headerName].hdrSignedRes = "invalid"; //hdrValidity="invalid"; //header was modified
secStatus=false;
//gConsole.logStringMessage("Warning - failed on verifing secured header "+hdrName+" :\n mime value:\n>" +hdrMimeValue+ "<\nsecured value:\n>"+hdrValue+"<");
}
}
// decode values from MIME format
+ var tmpDecdodedValue=null;
var mimeEncoder = Components.classes["@mozilla.org/messenger/mimeconverter;1"].getService(Components.interfaces.nsIMimeConverter);
- hdrMimeValue = mimeEncoder.decodeMimeHeader(hdrMimeValue, charset, false, true);//encodeMimePartIIStr(hdrValue, false, "ISO-8859-1" , 0, 72);
- hdrValue = mimeEncoder.decodeMimeHeader(hdrValue,charset,false,true);
- // gConsole.logStringMessage("secureHeadersStatus - header "+hdrName+" \nmime value: >" +hdrMimeValue+ "<\nsigned value:>"+hdrValue+"<");
-
-
+ tmpDecdodedValue = mimeEncoder.decodeMimeHeader(hdrMimeValue, charset, false, true);//encodeMimePartIIStr(hdrValue, false, "ISO-8859-1" , 0, 72);
+ if(tmpDecdodedValue){
+ gSecureHeadersArray[headerName].hdrMimeValue = tmpDecdodedValue;
+ }else{
+ gSecureHeadersArray[headerName].hdrMimeValue = hdrMimeValue;
+ }
+ tmpDecdodedValue = null;
+ tmpDecdodedValue = mimeEncoder.decodeMimeHeader(hdrValue,charset,false,true);
+ if(tmpDecdodedValue){
+ gSecureHeadersArray[headerName].hdrSecureValue = tmpDecdodedValue;
+ }else{
+ gSecureHeadersArray[headerName].hdrSecureValue = hdrValue;
+ }
+ gSecureHeaders = "signedData in";
+ //dbg gConsole.logStringMessage("secureHeadersStatus - header "+headerName+" \nmime value: >" +gSecureHeadersArray[headerName].hdrMimeValue+ "<\nsigned value:>"+gSecureHeadersArray[headerName].hdrSecureValue+"<");
break; // header is correctly checked
}
}
// mime header has been lost, deleted...
if(!headerMimeExists){
- hdrValidity="invalid"; //header was modified
+ gSecureHeadersArray[headerName].hdrSignedRes ="invalid"; //header was modified
secStatus=false;
}
if((!secStatus))
{
- // TCA I don't see why we shouldn't override signed status in the case of succesful signature check
+ // TCA I don't see why we shouldn't override signed status only in the case of succesful signature check
// if(gSignatureStatus == nsICMSMessageErrors.SUCCESS) {
//At least one secure header was modified, set the signed status to "not ok"
gSignedUINode.setAttribute("signed", "notok");
gStatusBar.setAttribute("signed", "notok");
//}
gSecureHeadersState=0;
-
+ gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString("secureinfomsg_hdrnok"));
+ gSMIMEInfoMsgMore.value=gSMIMEBundle.getString("secureinfomsgmore_default").replace(/<BR>/g,"\n");
}
//gConsole.logStringMessage("*** secureHeaders analysis end ***");
gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString("secureinfomsg_hdrnok"));
gSMIMEInfoMsgMore.value=gSMIMEBundle.getString("secureinfomsgmore_default").replace(/<BR>/g,"\n");
}
- },
+ },//end updateSecureHeadersState
+ secureHeadersStatus: function(aSecureHeaders, aCanonAlgo){
+ gSecureHeaders = "";
+ gSecureHeadersArray={}; // clear array
+ if(aSecureHeaders)
+ {
+ var secureHeadersArray=aSecureHeaders.QueryInterface(nsIArray);
+ if(secureHeadersArray.length <= 0 ){
+ gConsole.logStringMessage("[smimeHeaderSink:secureHeadersStatus] *** no secure headers in smime signeddata ");
+ return;
+ }
+
+ for(var i=0;i<secureHeadersArray.length;++i)
+ {
+ var sHeader = secureHeadersArray.queryElementAt(i,nsIMsgSMIMESecureHeader);
+ if(sHeader){
+ var oEntry = new Object;
+ oEntry.hdrName = sHeader.headerName; // signed header
+ oEntry.hdrSecureValue = sHeader.headerValue; // Value in the signature
+ oEntry.hdrMimeValue = ""; // value in the MIME message
+ oEntry.hdrSignedStatus = sHeader.headerStatus;
+ oEntry.hdrCanonAlgo = aCanonAlgo;
+ oEntry.hdrEncryptStatus = "";
+ oEntry.hdrSignedRes = "valid";
+ gSecureHeadersArray[oEntry.hdrName] = oEntry;
+ }
+ }
+ getMessageSource(gFolderDisplay.selectedMessageUris[0], this.updateSecureHeadersState);
+ }
// Check the SMIME receipt with the request
SMIMEReceiptStatus: function(aSignedContentIdentifier,
aSignedContentIdentifierLen,
onEndHeaders: function()
{
- gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString("secureinfomsg_default"));
+ // gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString("secureinfomsg_default"));
// display secure info message panel
var setSmimeInfoMsg = true;
prefBranch.setBoolPref("smimeinfomsg_on", setSmimeInfoMsg);
}
}catch(e){
- gConsole.logStringMessage("[msgHdrViewSMIMEOnLoad] smimeinfomsg error : " + e);
+ //gConsole.logStringMessage("[msgHdrViewSMIMEOnLoad] smimeinfomsg error : " + e);
var prefBranch = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService).getBranch(null);
if(prefBranch.prefHasUserValue("smimeinfomsg_on")){
setSmimeInfoMsg = prefBranch.getBoolPref("smimeinfomsg_on");
document.getElementById("secureinfomsg").setAttribute("collapsed","true");
}
}
- },
+ // check if message is signed
+ if(checkSignedDataMsg()){
+ //gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString(""));
+ //gSMIMEInfoMsgMore.value=gSMIMEBundle.getString("secureinfomsgmore_nok").replace(/<BR>/g,"\n");
+ gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString("secureinfomsg_default"));
+ gSMIMEInfoMsgMore.value=gSMIMEBundle.getString("secureinfomsgmore_default").replace(/<BR>/g,"\n");
+ }else{
+ gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString("secureinfomsg_unsecured"));
+ gSMIMEInfoMsgMore.value=gSMIMEBundle.getString("secureinfomsgmore_default").replace(/<BR>/g,"\n");
+ }
+ },
onBeforeShowHeaderPane: function() {
gConsole.logStringMessage("onBeforeShowHeaderPane: " + gSignerCert);
currentHeaderData["signer"] = {headerName:"Signer", headerValue:""};
- for (headerName in currentHeaderData) {
- var headerField = currentHeaderData[headerName];
- }
+ //for (headerName in currentHeaderData) {
+ // var headerField = currentHeaderData[headerName];
+ //}
}
};
+//
function onSmartCardChange()
{
// only reload encrypted windows
}
}
+//
function msgHdrViewSMIMEOnLoad(event)
{
window.crypto.enableSmartCardEvents = true;
gSMIMEInfoMsg = document.getElementById("secureinfomsgl2");
gSMIMEInfoMsgMore = document.getElementById("secureinfomsgd2");
}
- gSMIMEInfoMsg.setAttribute("value", gSMIMEBundle.getString("secureinfomsg_default"));
- gSMIMEInfoMsgMore.value=gSMIMEBundle.getString("secureinfomsgmore_default").replace(/<BR>/g,"\n");
try{
if(gCurrentIdentity){
prefBranch.setBoolPref("smimeinfomsg_on", gCurrentIdentity.getBoolAttribute("secureheaders.smimeinfomsg"));
}
}catch(e){gConsole.logStringMessage("[msgHdrViewSMIMEOnLoad] smimeinfomsg error : " + e);}
+
+ // new folder selected : collapse gSMIMEInfoMsg container
+ try{
+ var el = document.getElementById("folderTree");
+ el.addEventListener("select", function(){
+ if(document.getElementById("singlemessage") != undefined)
+ document.getElementById("secureinfomsg").setAttribute("collapsed","true");},
+ false);
+ }catch(e){}
+
}
function msgHdrViewSMIMEOnUnload(event)
}
}
-function MsgHdrObj(){
- this._hdrName;
- this._hdrValue;
-}
-
-
-/**
-* Get the Message header list
-*/
-function getMsgHdr(){
- var _HdrArray = new Array;
- var msgURI = gFolderDisplay.selectedMessageUris[0];
- var cmessenger = Components.classes["@mozilla.org/messenger;1"].createInstance(Components.interfaces.nsIMessenger);
- var msgSvc = cmessenger.messageServiceFromURI(msgURI);
- var MsgStream = Components.classes["@mozilla.org/network/sync-stream-listener;1"].createInstance();
- var consumer = MsgStream.QueryInterface(Components.interfaces.nsIInputStream);
- var ScriptInput = Components.classes["@mozilla.org/scriptableinputstream;1"].createInstance();
- var ScriptInputStream = ScriptInput.QueryInterface(Components.interfaces.nsIScriptableInputStream);
- ScriptInputStream.init(consumer);
- try{
- msgSvc.streamMessage(msgURI, MsgStream, msgWindow, null, false, null);
- }catch (e){
- dump("Error line " + Error().lineNumber + " : "+ e + " - file "+ Error().fileName);
- return _HdrArray;
- }
-
- // analyse des donnees du message selectionne
- ScriptInputStream.available();
- var content = "";
- //var tmpBuf = "";
-
- // extrac headers
- // RFC 2822 : The body is simply a sequence of characters that
- // follows the header and is separated from the header by an empty line
- // (i.e., a line with nothing preceding the CRLF).
- // TCN: in nsImapProtocol.cpp is mentioned a conversion to native line feed
- var linefeedStr = ""; // native line feed in this message (used later while retrieving headers line by line)
- while (ScriptInputStream.available()) {
- content += ScriptInputStream.read(512);
- var p = content.indexOf("\r\n\r\n");
- if (p > 0) {
- linefeedStr = "\r\n";
- content = content.substring(0, p);
- break;
- }
- var p1 = content.indexOf("\r\r");
- if (p1 > 0) {
- linefeedStr = "\r";
- content = content.substring(0, p1);
- break;
- }
- var p2 = content.indexOf("\n\n");
- if (p2 > 0) {
- linefeedStr = "\n";
- content = content.substring(0, p2);
- break;
- }
- }
-
- // unfolding mime headers
- content = UnfoldingMimeValue(content);
-
- // create array oh MIME headers
- var cur_pos_CRLF = 0; //current position of line feed (CR, CRLF or LF)
- var cur_pos_str = 0; // current position of string
- var ligne_header = "";
- //gConsole.logStringMessage("Content: " + content);
- while((cur_pos_CRLF=content.indexOf(linefeedStr,cur_pos_str))!=-1)
- {
- ligne_header+=content.substring(cur_pos_str,cur_pos_CRLF);
- if(ligne_header.indexOf(":",0)!=-1){
- var msghdr = new MsgHdrObj();
- // header
- msghdr._hdrName = ligne_header.substring(0,ligne_header.indexOf(":",0));
- msghdr._hdrValue = ligne_header.substring(ligne_header.indexOf(":",0)+1);
- //gConsole.logStringMessage("msghdr._hdrName: " + msghdr._hdrName);
- //gConsole.logStringMessage("msghdr._hdrValue: " + msghdr._hdrValue);
- _HdrArray.push(msghdr);
- }
- ligne_header="";
- cur_pos_str=cur_pos_CRLF + linefeedStr.length;
- }
- return _HdrArray;
-}
-
function getMimeValueCharset(val)
{
var res="";
return val;
}
+/*
+ *
+ */
+function checkSignedDataMsg(){
+ //
+ var list="";
+ var headerName;
+ var regHdrName_contentype = new RegExp("content-type", "ig");
+ var regHdrValue_signed = new RegExp("multipart/signed", "ig");
+ for (headerName in currentHeaderData) {
+ //list += currentHeaderData[headerName].headerName +":"+currentHeaderData[headerName].headerValue + " $$ ";
+ if(regHdrName_contentype.test(currentHeaderData[headerName].headerName)){
+ if(regHdrValue_signed.test(currentHeaderData[headerName].headerValue)){
+ gConsole.logStringMessage("[checkSignedDataSmimeSelectedMsg] Msg Is Signed");
+ return true;
+ }
+ }
+ }
+ gConsole.logStringMessage("[checkSignedDataSmimeSelectedMsg] Msg Is Unsigned");
+ //dbg gConsole.logStringMessage("[checkSignedDataSmimeSelectedMsg] list : " + list);
+ return false;
+}
+
+ /**
+Get message source
+@param {nsIMsgDBHdr} header
+@param {function} callbackFunction Function to call when data are received: callbackFunction(header, receivedData, callbackParam)
+@param callbackParam Parameter of callbackFunction
+@return {string} Message source or <b>false</b> if an error occurs
+*/
+function getMessageSource(mailUri, callbackFunction, callbackParam){
+ if (!mailUri) return;
+ var streamListener = {
+ QueryInterface: function(aIID) {
+ if (aIID.equals(Components.interfaces.nsISupports)
+ || aIID.equals(Components.interfaces.nsIStreamListener))
+ return this;
+ throw Components.results.NS_NOINTERFACE;
+ },
+ data: "",
+ isDataComplete: false,
+ onStartRequest: function(request, context) {},
+ onDataAvailable: function(request, context, inputStream, offset, available) {
+ if(!this.isDataComplete ){
+ var stream = Components.classes["@mozilla.org/scriptableinputstream;1"].createInstance(Components.interfaces.nsIScriptableInputStream);
+ stream.init(inputStream);
+ this.data += stream.read(available);
+ stream.close();
+ stream = null;
+
+ // parse headers only
+ var idxEnd = this.data.indexOf("\r\n\r\n",0); // * CRLF DOS : "\r\n"
+ if(idxEnd == -1) idxEnd = this.data.indexOf("\n\n",0); // * CRLF UNIX : "\n"
+ if(idxEnd == -1) idxEnd = this.data.indexOf("\r\r",0); //CRLF OS : "\r"
+ if(idxEnd != -1) this.isDataComplete = true; // msgSrc = msgSrc.substr(0,idxEnd); //dbg gConsole.logStringMessage("[smime - MessageAnalyser - succes getting mime headers : ] \n" + msgSrc);
+ }
+ },
+ onStopRequest: function(request, context, status) {
+ if (Components.isSuccessCode(status)) {
+ callbackFunction(this.data, callbackParam);
+ } else {
+ srv.errorSrv("notifyListener.getMsgSrc - "+mailUri+" - Error: "+status);
+ }
+ }
+ }
+
+ var cmessenger = Components.classes["@mozilla.org/messenger;1"].createInstance(Components.interfaces.nsIMessenger);
+ var msgSvc = cmessenger.messageServiceFromURI(mailUri);
+ try { msgSvc.streamMessage(mailUri, streamListener, null, null, false, null); } catch (ex) { return false; }
+}
addEventListener('messagepane-loaded', msgHdrViewSMIMEOnLoad, true);
addEventListener('messagepane-unloaded', msgHdrViewSMIMEOnUnload, true);
addEventListener('messagepane-hide', msgHdrViewSMIMEOnMessagePaneHide, true);
EADS Defence and Security - 1 Boulevard Jean Moulin - ZAC de la Clef Saint Pierre - 78990 Elancourt - FRANCE (IDDN.FR.001.480012.002.S.P.2008.000.10000)
* ***** END LICENSE BLOCK ***** */
-var gSecureHeaders="";
-
const SECURE_HEADER_SEPARATOR = "###HEADER_SEPARATOR###";
const HEADER_VAL_SEPARATOR = "###HEADER_VAL###";
+/*
+gSecureHeadersArray[o.hdrName]={
+ o.hdrName = sHeader.headerName; // signed header
+ o.hdrSecureValue = sHeader.headerValue; // Value in the signature
+ o.hdrMimeValue = ""; // value in the MIME message
+ o.hdrSignedStatus = sHeader.headerStatus;
+ o.hdrCanonAlgo = aCanonAlgo;
+ o.hdrEncryptStatus = "";
+ o.hdrSignedRes = "valid";}
+*/
function onLoad()
{
var gSecureHeadersBundle = document.getElementById("bundle_secure_headers_view");
- gSecureHeaders = window.arguments[0];
+ var secureHeadersString = window.arguments[0];
- if(gSecureHeaders!=""){
- var treechild = document.getElementById("secHeader_treechild_id");
- var each_header_tab=gSecureHeaders.split(SECURE_HEADER_SEPARATOR);
- for(var i=0;i<each_header_tab.length;++i)
- {
- var each_value_tab=each_header_tab[i].split(HEADER_VAL_SEPARATOR);
- var label;
- if(each_value_tab.length>=3){
- //read the current header property
- var headerName = each_value_tab[0];
- var headerValue = each_value_tab[1];
- var headerStatus = each_value_tab[2];
- var headerSecStatus = each_value_tab[3];
- //var headerEncrypted = parseInt(each_value_tab[4]);
- var headerMime = each_value_tab[4];
- var headerCanoniz = each_value_tab[5];
+ if(secureHeadersString=="")return;
+ // split secureHeadersString to cSecureHeadersArray
+ var cSecureHeadersArray = {};
+ var each_header_tab=secureHeadersString.split(SECURE_HEADER_SEPARATOR);
+ for(var i=0;i<each_header_tab.length;++i){
+ var each_value_header_tab=each_header_tab[i].split(HEADER_VAL_SEPARATOR);
+ var oEntry = new Object;
+ var headerNameEntry = "";
+ for(var idxElt=0;idxElt<each_value_header_tab.length;++idxElt){
+ switch(idxElt){
+ case 0:
+ headerNameEntry = each_value_header_tab[idxElt];
+ oEntry.hdrName = each_value_header_tab[idxElt];
+ break;
+ case 1:
+ oEntry.hdrSecureValue = each_value_header_tab[idxElt];
+ break;
+ case 2:
+ oEntry.hdrMimeValue = each_value_header_tab[idxElt];
+ break;
+ case 3:
+ oEntry.hdrSignedStatus = each_value_header_tab[idxElt];
+ break;
+ case 4:
+ oEntry.hdrCanonAlgo = each_value_header_tab[idxElt];
+ break;
+ case 5:
+ oEntry.hdrSignedRes = each_value_header_tab[idxElt];
+ break;
+ }
+ }
+ oEntry.hdrEncryptStatus = "";
+ if(headerNameEntry!="") cSecureHeadersArray[headerNameEntry] = oEntry;
+ }
+ // create tree viewer
+ var treechild = document.getElementById("secHeader_treechild_id");
+ for (headerName in cSecureHeadersArray) {
+ var label="";
//create each element for the tree
var treeitem=document.createElement("treeitem");
var treerow=document.createElement("treerow");
//var encryptedcell=document.createElement("treecell");
//set the header name, value and status
- namecell.setAttribute("label",headerName);
- valuecell.setAttribute("label",headerValue); // signed value
- namecell.setAttribute("properties",headerSecStatus);
- valueMimecell.setAttribute("label",headerMime); // displayed value in message
+ namecell.setAttribute("label",cSecureHeadersArray[headerName].hdrName);
+ valuecell.setAttribute("label",cSecureHeadersArray[headerName].hdrSecureValue); // signed value
+ namecell.setAttribute("properties",cSecureHeadersArray[headerName].hdrSignedRes);
+ valueMimecell.setAttribute("label",cSecureHeadersArray[headerName].hdrMimeValue); // displayed value in message
//set the header status
- switch(headerStatus)
- {
+ switch(cSecureHeadersArray[headerName].hdrSignedStatus){
case "-1":
label=gSecureHeadersBundle.getString("notdefine.label");
break;
//set the canonization algo used
var sAlgo = "";
- switch(parseInt(headerCanoniz,10)){
+ switch(parseInt(cSecureHeadersArray[headerName].hdrCanonAlgo,10)){
case 0:
sAlgo = gSecureHeadersBundle.getString("headercanoniz.simple.label");
- break
+ break;
case 1:
sAlgo = gSecureHeadersBundle.getString("headercanoniz.relaxed.label");
break;
canonizcell.setAttribute("label",sAlgo);
//set the header encrypted
- /*switch(headerEncrypted)
- {
+ /*switch(gSecureHeadersArray[headerName].hdrEncryptStatus){
case -1:
label=gSecureHeadersBundle.getString("notdefine.label");
break;
//treerow.appendChild(encryptedcell);
treeitem.appendChild(treerow);
treechild.appendChild(treeitem);
- }
- }
}
}