home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / AIMP2 / aimp_2.61.583.exe / $TEMP / YandexPackSetup.msi / fil29C22BE0F48B01936B23C431C2391843 < prev    next >
Text File  |  2010-07-12  |  35KB  |  1,152 lines
  1. var gYaAuth = {
  2.   get PasswordManager() {
  3.     delete this.PasswordManager;
  4.     return (this.PasswordManager = Cc["@mozilla.org/autocomplete/search;1?name=YasearchPassComplete"].getService().wrappedJSObject);
  5.   },
  6.   
  7.   shutdown: function YaAuth_shutdown() {
  8.     this.Users.clear();
  9.   },
  10.   
  11.   normalizeUser: function(aUsername) {
  12.     return new this.NormalizedUsernameData(aUsername);
  13.   },
  14.   
  15.   Users: {
  16.     _users: {},
  17.     
  18.     __iterator__: function YaAuthUsers___iterator__() {
  19.       for (let [key, value] in Iterator(this._users))
  20.         yield [key, value];
  21.     },
  22.     
  23.     clear: function YaAuthUsers_clear() {
  24.       for each (let [username, data] in Iterator(this))
  25.         data.auth.destroy();
  26.     },
  27.     
  28.     addUser: function YaAuthUsers_addUser(aUsername, aUsernameTyped) {
  29.       if (!aUsername)
  30.         return null;
  31.       
  32.       let normalizedUserData = gYaAuth.normalizeUser(aUsername);
  33.       let username = normalizedUserData.name;
  34.       
  35.       let user = this._users[username] || (this._users[username] = {
  36.         username: username,
  37.         auth: new gYaAuth.AuthProcess(username),
  38.         type: normalizedUserData.type,
  39.         
  40.         _usernameTyped: null,
  41.         get usernameTyped() {
  42.           return this._usernameTyped || this.username;
  43.         }
  44.       });
  45.       
  46.       if (aUsernameTyped)
  47.         user._usernameTyped = aUsernameTyped;
  48.       
  49.       return user;
  50.     },
  51.     
  52.     getUser: function YaAuthUsers_getUser(aUsername) {
  53.       let username = gYaAuth.normalizeUser(aUsername).name;
  54.       return username ? (this._users[username] || null) : null;
  55.     }
  56.   },
  57.   
  58.   isLogin: false,
  59.   
  60.   _sessionId: false,
  61.   _sessionLogin: false,
  62.  
  63.   set session(aData) {
  64.     if (aData.name == "Id")
  65.       aData.val = this.Cookies.checkSessionCookieValue(aData.val);
  66.  
  67.     if (this.username && aData.name == "Login" &&
  68.         aData.val && aData.val.replace(/\./g, "-") !== this.username &&
  69.         this._sessionId)
  70.     {
  71.       aData.val = false;
  72.     }
  73.     
  74.     this["_session" + aData.name] = aData.val;
  75.  
  76.     if (!aData.val) {
  77.       this.fireAfterLogout();
  78.     } else {
  79.       if (this._sessionId && this._sessionLogin)
  80.         this.fireAfterLogin();
  81.     }
  82.   },
  83.  
  84.   get session() {
  85.     return {
  86.       id: this._sessionId,
  87.       login: this._sessionLogin
  88.     };
  89.   },
  90.  
  91.   _username: false,
  92.   
  93.   get username() {
  94.     return this._username;
  95.   },
  96.  
  97.   set username(val) {
  98.     if (!val)
  99.       val = false;
  100.  
  101.     this._username = val;
  102.  
  103.     if (val && "undefined" == typeof gYaSearchService.usersData[val])
  104.       gYaSearchService.usersData[val] = {};
  105.  
  106.     return val;
  107.   },
  108.   
  109.   fireAfterLogin: function YaAuth_fireAfterLogin() {
  110.     if (this.isLogin)
  111.       return;
  112.     
  113.     this._loginFailCounter = 0;
  114.  
  115.     this.isLogin = true;
  116.     
  117.     this.username = this.session.login.replace(/\./g, "-");
  118.     
  119.     let user = this.Users.addUser(this.username);
  120.     user.auth.loginState = this.LOGIN_STATES.AUTH;
  121.     
  122.     let loginProcessData = user.auth.loginProcessData;
  123.     
  124.     if (loginProcessData.manualLogin) {
  125.       this.PasswordManager.storeLoginDetails(user.usernameTyped,
  126.                                              loginProcessData.password,
  127.                                              loginProcessData.twoWeeks,
  128.                                              "yandex");
  129.     }
  130.     
  131.     if (loginProcessData.username)
  132.       this.Cookies.getAuthDinamicData("login");
  133.  
  134.     if (this.Cookies.yaAuthStaticData.needRefresh)
  135.       this.Cookies.getAuthStaticData();
  136.     
  137.     gYaSearchService.onYandexLogin();
  138.   },
  139.  
  140.   fireAfterLogout: function YaAuth_fireAfterLogout(aClearCookies, aForgetLogin) {
  141.     if (!this.isLogin)
  142.       return;
  143.     
  144.     this.isLogin = false;
  145.  
  146.     if (aForgetLogin)
  147.       this.PasswordManager.removeUserData(this.username);
  148.     
  149.     let username = this.username;
  150.     
  151.     this.username = false;
  152.  
  153.     this.session = {
  154.       name: "Login",
  155.       val: false
  156.     };
  157.     
  158.     let user = gYaAuth.Users.getUser(username);
  159.     if (user)
  160.       user.auth.loginState = this.LOGIN_STATES.NO_AUTH;
  161.     
  162.     if (aClearCookies)
  163.       new G_Timer(function() {
  164.         let user = gYaAuth.Users.getUser(username);
  165.         if (user)
  166.           user.auth.cancel();
  167.       }, 0);
  168.     
  169.     gYaSearchService.onYandexLogout();
  170.     
  171.     //OBSERVER_SERVICE.notifyObservers(null, "Ya-Refresh-Data", "login");
  172.   },
  173.   
  174.   dropAllAuth: function() {
  175.     gYaSearchService.yaMFD.dropAuthForAllLogins();
  176.     this.fireAfterLogout(true, false);
  177.   },
  178.   
  179.   dropAuth: function(aLogin, aClearCookies, aForgetLogin) {
  180.     if (this.isLogin && aLogin == this.username)
  181.       this.fireAfterLogout(aClearCookies, aForgetLogin);
  182.     else
  183.       gYaSearchService.yaMFD.dropAuthForLogin(aLogin, aForgetLogin);
  184.     
  185.     gYaSearchService.yaMFD.dropAuthForAllLogins();
  186.   },
  187.   
  188.   LOGIN_STATES: {
  189.     NO_AUTH: 0,
  190.     ERROR: 1,
  191.     CAPTCHA_ERROR: 2,
  192.     NET_ERROR: 3,
  193.     REQUEST: 4,
  194.     AUTH: 5
  195.   },
  196.   
  197.   _loginFailCounter: 0,
  198.  
  199.   get loginFail() {
  200.     return (this._loginFailCounter >= 3);
  201.   },
  202.   
  203.   _swapUsersData: null,
  204.   
  205.   get swapUsersData() {
  206.     return this._swapUsersData || null;
  207.   },
  208.   
  209.   initLoginSwapProcess: function(aNewUserLogin) {
  210.     if (!aNewUserLogin ||
  211.         this.normalizeUser(this.username).name == this.normalizeUser(aNewUserLogin).name ||
  212.         gYaSearchService.yaMFD.isLoginHasAuth(aNewUserLogin))
  213.       return;
  214.     
  215.     let loginSavedInfo = this.PasswordManager.getSavedLoginInfo(aNewUserLogin);
  216.     if (!loginSavedInfo || !loginSavedInfo.password)
  217.       return;
  218.     
  219.     this._swapUsersData = {
  220.       login: aNewUserLogin,
  221.       username: aNewUserLogin.split("@")[0],//.toLowerCase(), 
  222.       password: loginSavedInfo.password,
  223.       type: (loginSavedInfo.type == "mfd" ? "mfd" : null)
  224.     };
  225.     
  226.     if (gYaSearchService.yaMFD.dropAuthForDomain(aNewUserLogin, true))
  227.       return;
  228.     
  229.     if (this.isLogin) {
  230.       if (this._swapUsersData.type != "mfd") {
  231.         this.fireAfterLogout(true, false);
  232.         gYaSearchService.notifyBusyStateOfRequest(null, true, true, "yasearch-login");
  233.       } else {
  234.         this.checkSwapUsers();
  235.       }
  236.       
  237.     } else {
  238.       this.checkSwapUsers();
  239.     }
  240.   },
  241.   
  242.   checkSwapUsers: function() {
  243.     let swapUsersData = this._swapUsersData;
  244.     if (!swapUsersData)
  245.       return;
  246.     
  247.     if (this.initLoginProcess(swapUsersData.login, swapUsersData.password, true, true)) {
  248.       gYaSearchService.notifyBusyStateOfRequest(null, true, true, "yasearch-login");
  249.     } else {
  250.       this._swapUsersData = null;
  251.       gYaSearchService.notifyBusyStateOfRequest(null, false, true, "yasearch-login");
  252.     }
  253.   },
  254.   
  255.   initLoginProcess: function(aName, aPassword, aTwoWeeks, aManualLogin) {
  256.     if (!aName || !aPassword)
  257.       return false;
  258.     
  259.     if ((this.isLogin && this.normalizeUser(this.username).name == this.normalizeUser(aName).name) ||
  260.         gYaSearchService.yaMFD.isLoginHasAuth(aName))
  261.       return false;
  262.     
  263.     let user = this.Users.addUser(aName, aManualLogin ? aName : null);
  264.     
  265.     if (user.type == "mfd")
  266.       gYaSearchService.yaMFD.dropAuthForDomain(aName);
  267.     
  268.     user.auth.start(aPassword, aTwoWeeks, aManualLogin, user.type);
  269.     
  270.     return true;
  271.   },
  272.   
  273.   onLogoutCallback: function() {
  274.     this.checkSwapUsers();
  275.   },
  276.   
  277.   Cookies: {
  278.     get rootDomain() {
  279.       return this.yaAuthStaticData.rootDomain;
  280.     },
  281.     
  282.     __yaAuthStaticData: null,
  283.  
  284.     set yaAuthStaticData(aVal) {
  285.       gYaSearchService.setCharPref("yasearch.auth.static", aVal);
  286.       this.__yaAuthStaticData = null;
  287.       return aVal;
  288.     },
  289.  
  290.     get yaAuthStaticData() {
  291.       if (this.__yaAuthStaticData === null) {
  292.         let staticData = {
  293.           ts: 0,
  294.           get needRefresh() {
  295.             let timeNow = Date.now();
  296.             return ((timeNow - this.ts > 1 * DAY_SECS) || this.ts > timeNow) ? true : false;
  297.           },
  298.  
  299.           rootDomain: false,
  300.           rootPass: false,
  301.           rootPasslogin: false,
  302.           rootPasslogout: false,
  303.           allHostsRegExp: false,
  304.           hosts: {}
  305.         };
  306.  
  307.         let data = (gYaSearchService.getCharPref("yasearch.auth.static") || "").split("~~~");
  308.  
  309.         if (data.length > 1 && /^\d+$/.test(data[0])) {
  310.           let lastTime = +data[0];
  311.           let uri;
  312.           
  313.           try {
  314.             let hostStr = data[1];
  315.             uri = hostStr && /^\/:/.test(hostStr) ? gYaSearchService.makeURI(hostStr.replace(/^\/:/,"")) : null;
  316.           } catch(e){}
  317.           
  318.           if (uri && /https?/.test(uri.scheme)) {
  319.             let allHostsRegExp = [];
  320.             
  321.             staticData.ts = lastTime;
  322.             
  323.             let passUrl = uri.spec;
  324.             staticData.rootPass = passUrl;
  325.  
  326.             passUrl += (/\/$/.test(passUrl) ? "" : "/") + "xml/log";
  327.  
  328.             staticData.rootPasslogin = passUrl + "in";
  329.             staticData.rootPasslogout = passUrl + "out";
  330.  
  331.             let domainArr = uri.host.split(".").reverse();
  332.             staticData.rootDomain = domainArr.length > 1 ? ("." + domainArr[1] + "." + domainArr[0]) : false;
  333.  
  334.             let i = 2,
  335.                 cookies = data[i];
  336.             
  337.             while (cookies) {
  338.               let hostIndx = cookies.indexOf(":");
  339.  
  340.               if (hostIndx > 2) {
  341.                 let host = cookies.substring(0, hostIndx);
  342.  
  343.                 let hostReg = host.replace(/(\-|\.)/g,"\\\$1").replace(/^(\*\\\.)/,"(.*\\.)?");
  344.                 allHostsRegExp.push(hostReg);
  345.                 hostReg = new RegExp("^" + hostReg + "$", "i");
  346.  
  347.                 let cookiesArr = [];
  348.                 for each (var cook in cookies.substring(++hostIndx).split(","))
  349.                   if (cook > "")
  350.                     cookiesArr.push(cook);
  351.  
  352.                 if (cookiesArr.length)
  353.                   staticData.hosts[host] = {cookies: cookiesArr, hostReg: hostReg};
  354.               }
  355.  
  356.               cookies = data[++i];
  357.             }
  358.  
  359.             if (allHostsRegExp.length)
  360.               staticData.allHostsRegExp = new RegExp("^(" + allHostsRegExp.join("|") + ")$", "i");
  361.           }
  362.         }
  363.  
  364.         this.__yaAuthStaticData = staticData;
  365.       }
  366.  
  367.       return this.__yaAuthStaticData;
  368.     },
  369.     
  370.     checkAuthOnStart: function YaAuthCookies_checkAuthOnStart(aSkipGettingStaticData) {
  371.       if ((typeof aSkipGettingStaticData == "undefined") && !this.rootDomain)
  372.         return this.getAuthStaticData(this.checkAuthOnStart.bind(this));
  373.  
  374.       if (this.rootDomain)
  375.         gYaAuth.setSessionFromCookies(true);
  376.     },
  377.     
  378.     getAuthStaticData: function YaAuthCookies_getAuthStaticData(aCallback) {
  379.       gYaSearchService.xmlHttpRequest("https://passport.yandex.ru/bar.txt?" + getNCRndStr(),
  380.                                       { callbackFunc: this.getAuthStaticDataCallback.bind(this, aCallback) });
  381.     },
  382.  
  383.     getAuthStaticDataCallback: function YaAuthCookies_getAuthStaticDataCallback(aReq, aCallback) {
  384.       let res = false;
  385.  
  386.       if (!gYaSearchService.isReqError(aReq)) {
  387.         let staticDataArray = aReq.target.responseText.split(/\r?\n/);
  388.         let rootPass = false;
  389.         let resArray = [];
  390.  
  391.         for (let i = 0, len = staticDataArray.length; i < len; i++) {
  392.           let item = staticDataArray[i].split("#")[0];
  393.           if (/^\/:/.test(item)) {
  394.             if (!rootPass)
  395.               rootPass = item;
  396.           } else if (item.indexOf(":") > 0) {
  397.             resArray.push(item);
  398.           }
  399.         }
  400.  
  401.         if (rootPass) {
  402.           resArray.unshift(Date.now(), rootPass);
  403.           this.yaAuthStaticData = resArray.join("~~~");
  404.         }
  405.  
  406.         res = !!this.rootDomain;
  407.       }
  408.  
  409.       if (aCallback)
  410.         aCallback(res);
  411.     },
  412.     
  413.     getAuthDinamicData: function YaAuthCookies_getAuthDinamicData(aType) {
  414.       let url = this.yaAuthStaticData["rootPass" + aType];
  415.  
  416.       if (url) {
  417.         url = gYaSearchService.appendStatData2Url(url + "?" + getNCRndStr(), {});
  418.         return gYaSearchService.xmlHttpRequest(url, {callbackFunc: this.getAuthDinamicDataCallback.bind(this, aType)});
  419.       }
  420.  
  421.       if (aType === "logout")
  422.         gYaAuth.onLogoutCallback();
  423.     },
  424.  
  425.     getAuthDinamicDataCallback: function YaAuthCookies_getAuthDinamicDataCallback(aReq, aType) {
  426.       let res = false;
  427.  
  428.       if ((aType === "logout" && !gYaAuth.isLogin) || (aType === "login" && gYaAuth.isLogin))
  429.         res = this.manageCookies(gYaSearchService.isReqError(aReq) ?
  430.                                  false : aReq.target.responseText.replace(/<\?xml .+\?>[\r\n]*/,""), aType);
  431.  
  432.       if (aType === "logout")
  433.         gYaAuth.onLogoutCallback();
  434.     },
  435.  
  436.     manageCookies: function YaAuthCookies_manageCookies(aXmlString, aType) {
  437.       const cookieManager = gYaSearchService.cookieManager;
  438.       
  439.       let res = false;
  440.       let presentHosts;
  441.       
  442.       let cookiesXml = gYaSearchService.safeE4Xml(aXmlString, "<mda/>", "mda");
  443.  
  444.       if (cookiesXml.domain.length()) {
  445.         const cookieService = Cc["@mozilla.org/cookieService;1"].getService().QueryInterface(Ci.nsICookieService);
  446.  
  447.         presentHosts = this.getBrowserHostCookies();
  448.  
  449.         let timeNow = Date.now();
  450.         let timeNowSec = parseInt(timeNow / 1000, 10);
  451.  
  452.         for (let i = 0, len_i = cookiesXml.domain.length(); i < len_i; i++) {
  453.           let domain = cookiesXml.domain[i];
  454.           let domainId = domain.@id.toString();
  455.  
  456.           for each (let actionTag in domain.*) {
  457.             let action = actionTag.name().toString();
  458.             
  459.             for (let j = 0, len_j = actionTag.cookie.length(); j < len_j; j++) {
  460.               let cookie = actionTag.cookie[j];
  461.               let cookieName = cookie.@id.toString();
  462.  
  463.               if (cookieName > "") {
  464.  
  465.                 let cookiePath = cookie.@path.toString() == "" ? "/" : cookie.@path.toString();
  466.  
  467.                 switch (action) {
  468.                   case "remove":
  469.                     cookieManager.remove(domainId, cookieName, cookiePath, false);
  470.                     break;
  471.  
  472.                   case "set":
  473.                     let maxAge = +(cookie["@max-age"].toString());
  474.  
  475.                     if (cookie.@override.toString() != "yes" && presentHosts[domainId]) {
  476.                       for each (let existCookie in presentHosts[domainId]) {
  477.                         if (existCookie.name === cookieName) {
  478.                           if ((existCookie.expires == 0 && maxAge == 0) ||
  479.                               (existCookie.expires > 0 && maxAge > 0 && timeNowSec < existCookie.expires))
  480.                             cookieName = false;
  481.                           break;
  482.                         }
  483.                       }
  484.                     }
  485.  
  486.                     if (cookieName) {
  487.                       let uri = Cc["@mozilla.org/network/standard-url;1"].createInstance(Ci.nsIURI);
  488.                       uri.spec = "http://" + domainId.replace(/^\./, "");
  489.                       
  490.                       let cookieStr = "" + cookieName + "=" + cookie.text().toString() + ";";
  491.                       
  492.                       if (domainId.charAt(0) == ".")
  493.                         cookieStr += "domain=" + domainId + ";";
  494.                       
  495.                       cookieStr += "path=" + cookiePath + ";";
  496.                       
  497.                       if (maxAge > 0)
  498.                         cookieStr += "expires=" + (new Date(timeNow + maxAge*1000).toGMTString()) + ";"
  499.                       
  500.                       cookieService.setCookieString(uri, null, cookieStr, null);
  501.                     }
  502.                     
  503.                     break;
  504.                   
  505.                   default:
  506.                     break;
  507.                 }
  508.               }
  509.             }
  510.           }
  511.         }
  512.  
  513.         res = true;
  514.  
  515.       } else if (aType == "logout") {
  516.         
  517.         presentHosts = this.getBrowserHostCookies(true);
  518.         
  519.         for each (let staticHost in this.yaAuthStaticData.hosts) {
  520.           for (let presentHost in presentHosts) {
  521.             if (staticHost.hostReg.test(presentHost)) {
  522.               let presentCookies = presentHosts[presentHost];
  523.               for each (let staticName in staticHost.cookies) {
  524.                 let i = presentCookies.length;
  525.                 while (--i > -1) {
  526.                   let presentCookie = presentCookies[i];
  527.                   if (staticName == presentCookie.name) {
  528.                     cookieManager.remove(presentCookie.host, presentCookie.name, presentCookie.path, false);
  529.                     presentCookies.splice(i,1);
  530.                   }
  531.                 }
  532.               }
  533.             }
  534.           }
  535.         }
  536.  
  537.         res = true;
  538.  
  539.       }
  540.  
  541.       return res;
  542.     },
  543.     
  544.     checkSessionCookieValue: function YaAuthCookies_checkSessionCookieValue(aValue) {
  545.       return (aValue && aValue.length) ? aValue : false;
  546.     },
  547.     
  548.     getYandexCookie: function YaAuthCookies_getYandexCookie(aCookieName, aCheckExpired, aCookiePath) {
  549.       let rootDomain = this.rootDomain;
  550.       if (!rootDomain)
  551.         return false;
  552.       
  553.       const nsICookie = Ci.nsICookie;
  554.       let cookEnum = gYaSearchService.cookieManager.enumerator;
  555.       let timeNow = parseInt(Date.now() / 1000, 10);
  556.       let path = aCookiePath ? aCookiePath : "/";
  557.       
  558.       while (cookEnum.hasMoreElements()) {
  559.         let cookie = cookEnum.getNext();
  560.         if (cookie && cookie instanceof nsICookie && cookie.host == rootDomain &&
  561.             cookie.name == aCookieName && cookie.path == path && cookie.value.toString() != "" &&
  562.             (aCheckExpired ? !!(cookie.expires == 0 || timeNow < cookie.expires) : true))
  563.         {
  564.           let res = cookie.value.toString();
  565.           return aCookieName == "Session_id" ? this.checkSessionCookieValue(res) : res;
  566.         }
  567.       }
  568.  
  569.       return false;
  570.     },
  571.     
  572.     _getHostURIFromURL: function YaAuthCookies__getHostURIFromURL(aURL) {
  573.       let host = aURL.replace(/^\s*([-\w]*:\/+)?/, "");
  574.       return gYaSearchService.makeURI("http://" + host);
  575.     },
  576.  
  577.     isCookiesAllowedForHost: function YaAuthCookies_isCookiesAllowedForHost(aURL) {
  578.       let res = null;
  579.  
  580.       let uri = this._getHostURIFromURL(aURL);
  581.       if (!uri)
  582.         return res;
  583.  
  584.       const permissionManager = Cc["@mozilla.org/permissionmanager;1"].getService(Ci.nsIPermissionManager);
  585.  
  586.       switch (permissionManager.testPermission(uri, "cookie")) {
  587.         case permissionManager.ALLOW_ACTION:
  588.           res = true;
  589.           break;
  590.  
  591.         case permissionManager.DENY_ACTION:
  592.           res = null;
  593.           break;
  594.  
  595.         case permissionManager.UNKNOWN_ACTION:
  596.         default:
  597.           let cookieBehaviorValue = gYaSearchService.getIntPref("network.cookie.cookieBehavior");
  598.           res = (cookieBehaviorValue === 0);
  599.           break;
  600.       }
  601.  
  602.       return res;
  603.     },
  604.  
  605.     allowCookiesForHost: function YaAuthCookies_allowCookiesForHost(aURL) {
  606.       if (this.isCookiesAllowedForHost(aURL))
  607.         return true;
  608.  
  609.       let uri = this._getHostURIFromURL(aURL);
  610.       if (uri) {
  611.         const permissionManager = Cc["@mozilla.org/permissionmanager;1"].getService(Ci.nsIPermissionManager);
  612.         permissionManager.add(uri, "cookie", permissionManager.ALLOW_ACTION);
  613.       }
  614.  
  615.       return this.isCookiesAllowedForHost(aURL);
  616.     },
  617.  
  618.     getBrowserHostCookies: function YaAuthCookies_getBrowserHostCookies(aOnlyYandexList) {
  619.       let res = {};
  620.       let allHostsRegExp = aOnlyYandexList ? this.yaAuthStaticData.allHostsRegExp : false;
  621.  
  622.       if (!aOnlyYandexList || allHostsRegExp) {
  623.         const nsICookie = Ci.nsICookie;
  624.  
  625.         let cookEnum = gYaSearchService.cookieManager.enumerator;
  626.         
  627.         while (cookEnum.hasMoreElements()) {
  628.           let cookie = cookEnum.getNext();
  629.           
  630.           if (cookie && cookie instanceof nsICookie) {
  631.             let host = cookie.host;
  632.             
  633.             if (!aOnlyYandexList || allHostsRegExp.test(host)) {
  634.               let newCookie = {};
  635.               
  636.               for each (var prop in ["name", "value", "host", "path", "expires"])
  637.                 newCookie[prop] = cookie[prop];
  638.               
  639.               if (!res[host])
  640.                 res[host] = [];
  641.               
  642.               res[host].push(newCookie);
  643.             }
  644.             
  645.           } else {
  646.             break;
  647.           }
  648.         }
  649.       }
  650.  
  651.       return res;
  652.     }
  653.   },
  654.   
  655.   onCookieChanged: function(aSubject, aTopic, aData) {
  656.     let rootDomain = this.Cookies.rootDomain;
  657.     if (!rootDomain)
  658.       return;
  659.     
  660.     try {
  661.       aSubject.QueryInterface(Ci.nsICookie);
  662.     } catch(e) {}
  663.     
  664.     if (!(aSubject && aSubject instanceof Ci.nsICookie))
  665.       return;
  666.     
  667.     if (aSubject.host == rootDomain) {
  668.       if (aSubject.path == "/") {
  669.         let name = aSubject.name;
  670.         
  671.         if (name == "Session_id" || name == "yandex_login") {
  672.           let val = "";
  673.           try {
  674.             val = aSubject.value.toString();
  675.           } catch(e) {}
  676.           
  677.           if (aData == "deleted" || !val)
  678.             val = false;
  679.           
  680.           let needRecheckAuth = !!(aData == "changed" && !this.isLogin);
  681.           
  682.           this.session = {
  683.             val: val,
  684.             name: (name == "Session_id" ? "Id" : "Login")
  685.           };
  686.           
  687.           if (needRecheckAuth && (this.session.id || this.session.login))
  688.             this.setSessionFromCookies(false);
  689.         }
  690.       
  691.       }
  692.     }
  693.   },
  694.   
  695.   setSessionFromCookies: function(aCheckExpired) {
  696.     if (!this.isLogin) {
  697.       let loginCookieValue = this.Cookies.getYandexCookie("yandex_login", aCheckExpired);
  698.       let sessionCookieValue = this.Cookies.getYandexCookie("Session_id", aCheckExpired);
  699.  
  700.       if (loginCookieValue && sessionCookieValue) {
  701.         this.session = {
  702.           name: "Id",
  703.           val: sessionCookieValue
  704.         };
  705.         
  706.         this.session = {
  707.           name: "Login",
  708.           val: loginCookieValue
  709.         };
  710.         
  711.         return true;
  712.       }
  713.     }
  714.     
  715.     return false;
  716.   },
  717.   
  718.   getAllLoginsInfo: function() {
  719.     let currentAuthUsername = this.isLogin ? this.username.split("@")[0].toLowerCase() : "";
  720.     
  721.     if (!currentAuthUsername && this._swapUsersData)
  722.       currentAuthUsername = this._swapUsersData.login.split("@")[0].toLowerCase();
  723.     
  724.     let currentAuthMFDData = gYaSearchService.yaMFD.getAllAuthUsers()
  725.                                              .map(function(aAuthUser) aAuthUser.boxname);
  726.     
  727.     let addYaAuthToList = !!currentAuthUsername;
  728.     let loginsInfo = this.PasswordManager.getSavedLoginsInfo();
  729.     
  730.     for each (let [index, loginInfo] in Iterator(loginsInfo)) {
  731.       let username = loginInfo.username;
  732.       
  733.       if (loginInfo.type == "yandex") {
  734.         let hasAuth = !!(currentAuthUsername &&
  735.                          currentAuthUsername == username.split("@")[0].replace(/\./g, "-").toLowerCase())
  736.         
  737.         if (addYaAuthToList && hasAuth)
  738.           addYaAuthToList = false;
  739.         
  740.         loginInfo.hasAuth = hasAuth;
  741.         
  742.       } else {
  743.         let indx = currentAuthMFDData.indexOf(username);
  744.         if (indx != -1) {
  745.           loginInfo.hasAuth = true;
  746.           currentAuthMFDData.splice(indx, 1);
  747.         } else {
  748.           loginInfo.hasAuth = false;
  749.         }
  750.       }
  751.     }
  752.     
  753.     if (addYaAuthToList) {
  754.       loginsInfo.push({
  755.         username: this.session.login,
  756.         password: null,
  757.         hasAuth: true,
  758.         type: "yandex"
  759.       });
  760.     }
  761.     
  762.     currentAuthMFDData.forEach(function(aMFDBoxname) {
  763.       loginsInfo.push({
  764.         username: aMFDBoxname,
  765.         password: null,
  766.         hasAuth: true,
  767.         type: "mfd"
  768.       });
  769.     });
  770.     
  771.     return loginsInfo;
  772.   }
  773. };
  774.  
  775. (function() {
  776.   function AuthProcess(aUsername) {
  777.     this.userData = gYaAuth.normalizeUser(aUsername);
  778.     
  779.     this._username = aUsername;
  780.     
  781.     this._loginProcessData = {};
  782.     
  783.     this._connections = {
  784.       login: null,
  785.       logout: null
  786.     };
  787.     
  788.     this._loginState = 0;
  789.   }
  790.   
  791.   AuthProcess.prototype = {
  792.     get mfdAppendString() {
  793.       return this.userData.domain ? ("/for/" + this.userData.domain) : "";
  794.     },
  795.     
  796.     getPassURL: function AuthProcess_getPassURL(aMode) {
  797.       if (aMode == "auth" && this.userData.type == "mfd")
  798.         aMode = "mdauth";
  799.       
  800.       let url = "https://passport.yandex.ru" + this.mfdAppendString + "/passport?mode=" + aMode + "&target=bar";
  801.       
  802.       if (aMode == "logout")
  803.         url += "&yu=" + encodeURIComponent(gYaAuth.Cookies.getYandexCookie("yandexuid", false) || "");
  804.       
  805.       return url;
  806.     },
  807.     
  808.     get loginProcessData() {
  809.       return this._loginProcessData;
  810.     },
  811.     
  812.     get loginState() {
  813.       return this._loginState;
  814.     },
  815.  
  816.     set loginState(val) {
  817.       let newLoginStateValue = parseInt(val, 10);
  818.       
  819.       if (this._loginState !== newLoginStateValue) {
  820.         if (newLoginStateValue < gYaAuth.LOGIN_STATES.NO_AUTH || newLoginStateValue > gYaAuth.LOGIN_STATES.AUTH) {
  821.           gYaSearchService.log("loginState: bad value (" + val + ")");
  822.           return this._loginState;
  823.         }
  824.  
  825.         this._loginState = newLoginStateValue;
  826.  
  827.         OBSERVER_SERVICE.notifyObservers(null, "Ya-Login-State-Changed", this.userData.name);
  828.  
  829.         switch (newLoginStateValue) {
  830.           case gYaAuth.LOGIN_STATES.AUTH:
  831.           case gYaAuth.LOGIN_STATES.NO_AUTH:
  832.             OBSERVER_SERVICE.notifyObservers(null, "Ya-Refresh-Login-Status", false);
  833.             break;
  834.  
  835.           default:
  836.             break;
  837.         }
  838.         
  839.         OBSERVER_SERVICE.notifyObservers(null, "Ya-Refresh-Data", "login");
  840.       }
  841.       
  842.       return this._loginState;
  843.     },
  844.     
  845.     destroy: function AuthProcess_destroy() {
  846.       this._abortConnection("login");
  847.       this._abortConnection("logout");
  848.     },
  849.     
  850.     start: function AuthProcess_start(aPassword, aTwoWeeks, aManualLogin, aAuthType) {
  851.       this._abortConnection("logout");
  852.       
  853.       this.loginState = gYaAuth.LOGIN_STATES.REQUEST;
  854.       
  855.       this._loginProcessData = {
  856.         username: this._username,
  857.         password: aPassword,
  858.         twoWeeks: aTwoWeeks,
  859.         manualLogin: aManualLogin,
  860.         type: aAuthType
  861.       };
  862.       
  863.       if (!gYaAuth.Cookies.rootDomain)
  864.         gYaAuth.Cookies.getAuthStaticData(this._startLoginProcess.bind(this));
  865.       else
  866.         this._startLoginProcess();
  867.     },
  868.     
  869.     cancel: function AuthProcess_cancel() {
  870.       this._startLogoutConnection();
  871.     },
  872.     
  873.     _abortConnection: function AuthProcess__abortConnection(aConnectionType) {
  874.       let connection = this._connections[aConnectionType];
  875.       
  876.       try {
  877.         if (connection && connection.channel && connection.channel.isPending())
  878.           connection.channel.cancel(Components.results.NS_BINDING_ABORTED);
  879.       } catch (ex) {}
  880.       
  881.       this._connections[aConnectionType] = null;
  882.     },
  883.     
  884.     _startLogoutConnection: function AuthProcess__startLogoutConnection() {
  885.       this._abortConnection("logout");
  886.       
  887.       this._connections.logout =
  888.           gYaSearchService.xmlHttpRequest(this.getPassURL("logout"), {
  889.             callbackFunc: this._startLogoutConnectionCallback.bind(this)
  890.           });
  891.     },
  892.  
  893.     _startLogoutConnectionCallback: function AuthProcess__startLogoutConnectionCallback(aReq) {
  894.       if (gYaSearchService.isReqError(aReq)) {
  895.         this._abortConnection("logout");
  896.         
  897.         if (this.loginProcessData.type != "mfd") {
  898.           gYaAuth.Cookies.manageCookies(false, "logout");
  899.           gYaAuth.onLogoutCallback();
  900.         }
  901.         
  902.       } else {
  903.         if (this.loginProcessData.type != "mfd") {
  904.           this._connections.logout = gYaAuth.Cookies.getAuthDinamicData("logout");
  905.         }
  906.       }
  907.     },
  908.     
  909.     _startLoginProcess: function AuthProcess__startLoginProcess() {
  910.       if (!gYaAuth.Cookies.rootDomain)
  911.         this.loginState = gYaAuth.LOGIN_STATES.NET_ERROR;
  912.       else
  913.         this._startLoginConnection();
  914.     },
  915.     
  916.     _startLoginConnection: function AuthProcess__startLoginConnection() {
  917.       this._abortConnection("logout");
  918.  
  919.       let data = "login=" + encodeURIComponent(this.loginProcessData.username)
  920.                + "&passwd=" + encodeURIComponent(this.loginProcessData.password)
  921.                + "&retpath=https%3A%2F%2Fpassport.yandex.ru%2Fpassport%3Fmode%3Dpassport%26target%3Dbar"
  922.                + "×tamp=" + Date.now();
  923.       
  924.       if (this.loginProcessData.twoWeeks)
  925.         data += "&twoweeks=yes";
  926.       
  927.       this._talkToServer(this.getPassURL("auth"),
  928.                          data, null, "https://passport.yandex.ru/passport?mode=passport&target=bar",
  929.                          this._talkToServerCallback.bind(this));
  930.     },
  931.     
  932.     _talkToServer: function AuthProcess__talkToServer(aURL, aPostData, aCookieData, aReferrer, aCallbackFunc) {
  933.       let uri = gYaSearchService.makeURI(aURL);
  934.  
  935.       let uploadStream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance(Ci.nsIStringInputStream);
  936.       if (aPostData)
  937.         uploadStream.setData(aPostData, aPostData.length);
  938.  
  939.       let channel = IO_SERVICE.newChannelFromURI(uri);
  940.  
  941.       this._connections.login = channel;
  942.  
  943.       let httpChannel = channel.QueryInterface(Ci.nsIHttpChannel);
  944.  
  945.       if (aReferrer)
  946.         httpChannel.referrer = gYaSearchService.makeURI(aReferrer);
  947.  
  948.       if (aPostData) {
  949.         let uploadChannel = channel.QueryInterface(Ci.nsIUploadChannel);
  950.         uploadChannel.setUploadStream(uploadStream, "application/x-www-form-urlencoded", -1);
  951.         httpChannel.requestMethod = "POST";
  952.       }
  953.  
  954.       if (aCookieData)
  955.         for (let run = 0; run < aCookieData.length; run++)
  956.           httpChannel.setRequestHeader("Cookie", aCookieData[run], true);
  957.  
  958.       let observer = new this._talkToServerObserver(aCallbackFunc);
  959.       channel.notificationCallbacks = observer;
  960.       channel.asyncOpen(observer, null);
  961.     },
  962.     
  963.     _talkToServerCallback: function AuthProcess__talkToServerCallback(aData) {
  964.       gYaAuth._swapUsersData = null;
  965.       
  966.       gYaSearchService.notifyBusyStateOfRequest(null, false, true, "yasearch-login");
  967.       
  968.       let aRequest = aData.request,
  969.           status = null,
  970.           warningText = "";
  971.  
  972.       try {
  973.         aRequest.QueryInterface(Ci.nsIHttpChannel);
  974.         status = aRequest.responseStatus;
  975.         warningText = aRequest.getResponseHeader("Warning");
  976.       } catch(e) {}
  977.       
  978.       if (!status || (status != 200 && status != 302)) {
  979.         this.loginState = gYaAuth.LOGIN_STATES.NET_ERROR;
  980.       } else {
  981.         
  982.         let successLogin = false;
  983.         
  984.         let loginProcessData = this.loginProcessData;
  985.         
  986.         if (this.loginProcessData.type == "mfd") {
  987.           let mfdAuth = gYaSearchService.yaMFD.isLoginHasAuth(loginProcessData.username);
  988.  
  989.           if (mfdAuth) {
  990.             if (loginProcessData.manualLogin)
  991.               gYaAuth.PasswordManager.storeLoginDetails(loginProcessData.username,
  992.                                                         loginProcessData.password,
  993.                                                         loginProcessData.twoWeeks,
  994.                                                         "mfd");
  995.  
  996.             this.loginState = gYaAuth.LOGIN_STATES.AUTH;
  997.             successLogin = true;
  998.           }
  999.           
  1000.         } else {
  1001.           successLogin = !!gYaAuth.isLogin;
  1002.         }
  1003.         
  1004.         if (!successLogin) {
  1005.           gYaAuth._loginFailCounter++;
  1006.           
  1007.           if (/showcaptcha/.test(warningText)) {
  1008.             gYaAuth._loginFailCounter += 3;
  1009.             this.loginState = gYaAuth.LOGIN_STATES.CAPTCHA_ERROR;
  1010.           } else {
  1011.             this.loginState = gYaAuth.LOGIN_STATES.ERROR;
  1012.           }
  1013.         }
  1014.         
  1015.         loginProcessData.manualLogin = false;
  1016.       }
  1017.       
  1018.       OBSERVER_SERVICE.notifyObservers(null, "Ya-Refresh-Data", "login");
  1019.     },
  1020.  
  1021.     _talkToServerObserver: function AuthProcess__talkToServerObserver(aCallbackFunc) {
  1022.       return ({
  1023.         data: "",
  1024.  
  1025.         onStartRequest: function (aRequest, aContext) {
  1026.           this.data = "";
  1027.         },
  1028.  
  1029.         onDataAvailable: function (aRequest, aContext, aStream, aSourceOffset, aLength) {
  1030.           let scriptableInputStream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(Ci.nsIScriptableInputStream);
  1031.           scriptableInputStream.init(aStream);
  1032.           this.data += scriptableInputStream.read(aLength);
  1033.         },
  1034.  
  1035.         onStopRequest: function (aRequest, aContext, aStatus) {
  1036.           aCallbackFunc({
  1037.             "data": this.data,
  1038.             "request": aRequest
  1039.           });
  1040.         },
  1041.  
  1042.         onStatus: function(aRequest, aContext, aStatus, aStatusArg) {},
  1043.         onProgress: function(aRequest, aContext, aProgress, aProgressMax) {},
  1044.         onChannelRedirect: function (aOldChannel, aNewChannel, aFlags) {},
  1045.         onRedirect : function (aOldChannel, aNewChannel) {},
  1046.  
  1047.         getAuthPrompt: function(aPromptReason, iid) {
  1048.           const ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].getService(Ci.nsIWindowWatcher);
  1049.           return ww.getNewAuthPrompter(null);
  1050.         },
  1051.  
  1052.         interfaces: [ Ci.nsISupports,
  1053.                       Ci.nsIStreamListener,
  1054.                       Ci.nsISupportsWeakReference,
  1055.                       Ci.nsIPrompt,
  1056.                       Ci.nsIAuthPrompt,
  1057.                       Ci.nsIAuthPromptProvider,
  1058.                       Ci.nsIProgressEventSink,
  1059.                       Ci.nsIInterfaceRequestor,
  1060.                       Ci.nsIChannelEventSink,
  1061.                       Ci.nsIHttpEventSink,
  1062.                       Ci.nsIWebProgress ],
  1063.  
  1064.         QueryInterface: function(iid) {
  1065.           if (!this.interfaces.some( function(v) { return iid.equals(v) } ))
  1066.             throw Cr.NS_ERROR_NO_INTERFACE;
  1067.  
  1068.           if (iid.equals(Ci.nsIPrompt)) {
  1069.             let prompt = Cc["@mozilla.org/network/default-prompt;1"].createInstance();
  1070.             return prompt.QueryInterface(iid);
  1071.           }
  1072.  
  1073.           if (iid.equals(Ci.nsIAuthPrompt)) {
  1074.             let prompt = Cc["@mozilla.org/network/default-auth-prompt;1"].createInstance();
  1075.             return prompt.QueryInterface(iid);
  1076.           }
  1077.  
  1078.           return this;
  1079.         },
  1080.  
  1081.         getInterface: function(iid) {
  1082.           try {
  1083.             return this.QueryInterface(iid);
  1084.           } catch(e) {
  1085.             return null;
  1086.           }
  1087.         }
  1088.       });
  1089.     },
  1090.   };
  1091.   
  1092.   
  1093.   gYaAuth.AuthProcess = AuthProcess;
  1094.   
  1095.   function NormalizedUsernameData(aUsername) {
  1096.     this._type = "yandex";
  1097.     this._username = aUsername || "";
  1098.     this._domain = null;
  1099.     
  1100.     this._init();
  1101.   }
  1102.   
  1103.   NormalizedUsernameData.prototype = {
  1104.     _init: function NUData__init() {
  1105.       let username = this._username;
  1106.       
  1107.       if (!username)
  1108.         return;
  1109.       
  1110.       if (this.domain) {
  1111.         this._type = "mfd";
  1112.       } else {
  1113.         username = username.split("@")[0].replace(/\./g, "-");
  1114.       }
  1115.       
  1116.       this._username = username.toLowerCase();
  1117.     },
  1118.     
  1119.     get name() {
  1120.       return this._username;
  1121.     },
  1122.     
  1123.     get type() {
  1124.       return this._type;
  1125.     },
  1126.     
  1127.     get domain() {
  1128.       if (this._domain === null) {
  1129.         let domain = false;
  1130.         
  1131.         let chkString = this._username.split("@")[1];
  1132.         
  1133.         if (chkString &&
  1134.             /.+\.[a-z]+$/i.test(chkString) &&
  1135.             !(/^(yandex|narod|ya)\.[a-z]{2,5}$/i.test(chkString)))
  1136.           domain = chkString;
  1137.         
  1138.         this._domain = domain || false;
  1139.       }
  1140.       
  1141.       return this._domain;
  1142.     },
  1143.     
  1144.     toString: function NUData_toString() {
  1145.       return this.name;
  1146.     }
  1147.   }
  1148.   
  1149.   gYaAuth.NormalizedUsernameData = NormalizedUsernameData;
  1150.   
  1151. }());
  1152.