Ejemplo n.º 1
0
        private static bool WriteIpcInfoFile(int nId, IpcParamEx ipcMsg)
        {
            string strPath = GetIpcFilePath(nId);

            if (string.IsNullOrEmpty(strPath))
            {
                return(false);
            }

            try
            {
                XmlSerializer xml = new XmlSerializer(typeof(IpcParamEx));
                FileStream    fs  = new FileStream(strPath, FileMode.Create, FileAccess.Write,
                                                   FileShare.None);

                try { xml.Serialize(fs, ipcMsg); }
                catch (Exception) { Debug.Assert(false); }

                fs.Close();
                return(true);
            }
            catch (Exception) { Debug.Assert(false); }

            return(false);
        }
Ejemplo n.º 2
0
        public static void ProcessGlobalMessage(int nId, MainForm mf)
        {
            if (mf == null)
            {
                throw new ArgumentNullException("mf");
            }

            IpcParamEx ipcMsg = LoadIpcInfoFile(nId);

            if (ipcMsg == null)
            {
                return;
            }

            if (ipcMsg.Message == CmdOpenDatabase)
            {
                mf.EnsureVisibleForegroundWindow();

                string[] vArgs = CommandLineArgs.SafeDeserialize(ipcMsg.Param0);
                if (vArgs == null)
                {
                    Debug.Assert(false); return;
                }

                CommandLineArgs args = new CommandLineArgs(vArgs);
                Program.CommandLineArgs.CopyFrom(args);

                mf.OpenDatabase(IOConnectionInfo.FromPath(args.FileName),
                                KeyUtil.KeyFromCommandLine(args), true);
            }
            else
            {
                Debug.Assert(false);
            }
        }
Ejemplo n.º 3
0
		public static void SendGlobalMessage(IpcParamEx ipcMsg)
		{
			if(ipcMsg == null) throw new ArgumentNullException("ipcMsg");

			int nId = (int)(MemUtil.BytesToUInt32(CryptoRandom.Instance.GetRandomBytes(
				4)) & 0x7FFFFFFF);

			if(WriteIpcInfoFile(nId, ipcMsg) == false) return;

			try
			{
				// NativeMethods.SendMessage((IntPtr)NativeMethods.HWND_BROADCAST,
				//	Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
				//	(IntPtr)nId);

				// IntPtr pResult = new IntPtr(0);
				// NativeMethods.SendMessageTimeout((IntPtr)NativeMethods.HWND_BROADCAST,
				//	Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
				//	(IntPtr)nId, NativeMethods.SMTO_ABORTIFHUNG, 5000, ref pResult);

				IpcBroadcast.Send(Program.AppMessage.IpcByFile, nId, true);
			}
			catch(Exception) { Debug.Assert(false); }

			RemoveIpcInfoFile(nId);
		}
Ejemplo n.º 4
0
        public static void SendGlobalMessage(IpcParamEx ipcMsg)
        {
            if (ipcMsg == null)
            {
                throw new ArgumentNullException("ipcMsg");
            }

            int nId = (int)(MemUtil.BytesToUInt32(CryptoRandom.Instance.GetRandomBytes(
                                                      4)) & 0x7FFFFFFF);

            if (WriteIpcInfoFile(nId, ipcMsg) == false)
            {
                return;
            }

            try
            {
                NativeMethods.SendMessage((IntPtr)NativeMethods.HWND_BROADCAST,
                                          Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
                                          (IntPtr)nId);
            }
            catch (Exception) { Debug.Assert(false); }

            RemoveIpcInfoFile(nId);
        }
Ejemplo n.º 5
0
        public static void SendGlobalMessage(IpcParamEx ipcMsg)
        {
            if (ipcMsg == null)
            {
                throw new ArgumentNullException("ipcMsg");
            }

            int nId = (int)(MemUtil.BytesToUInt32(CryptoRandom.Instance.GetRandomBytes(
                                                      4)) & 0x7FFFFFFF);

            if (WriteIpcInfoFile(nId, ipcMsg) == false)
            {
                return;
            }

            try
            {
                // NativeMethods.SendMessage((IntPtr)NativeMethods.HWND_BROADCAST,
                //	Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
                //	(IntPtr)nId);

                // IntPtr pResult = new IntPtr(0);
                // NativeMethods.SendMessageTimeout((IntPtr)NativeMethods.HWND_BROADCAST,
                //	Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
                //	(IntPtr)nId, NativeMethods.SMTO_ABORTIFHUNG, 5000, ref pResult);

                IpcBroadcast.Send(Program.AppMessage.IpcByFile, nId, true);
            }
            catch (Exception) { Debug.Assert(false); }

            RemoveIpcInfoFile(nId);
        }
Ejemplo n.º 6
0
        private static void OpenEntryUrl(IpcParamEx ip, MainForm mf)
        {
            string strUuid = ip.Param0;

            if (string.IsNullOrEmpty(strUuid))
            {
                return;                                           // No assert (user data)
            }
            byte[] pbUuid = MemUtil.HexStringToByteArray(strUuid);
            if ((pbUuid == null) || (pbUuid.Length != PwUuid.UuidSize))
            {
                return;
            }

            PwDatabase pdb = mf.ActiveDatabase;

            if ((pdb == null) || !pdb.IsOpen)
            {
                return;
            }

            PwEntry pe = pdb.RootGroup.FindEntry(new PwUuid(pbUuid), true);

            if (pe == null)
            {
                return;
            }

            mf.PerformDefaultUrlAction(new PwEntry[] { pe }, true);
        }
Ejemplo n.º 7
0
        private static bool WriteIpcInfoFile(int nId, IpcParamEx ipcMsg)
        {
            string strPath = GetIpcFilePath(nId);

            if (string.IsNullOrEmpty(strPath))
            {
                return(false);
            }

            try
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    XmlUtilEx.Serialize <IpcParamEx>(ms, ipcMsg);

                    byte[] pb    = ms.ToArray();
                    byte[] pbCmp = MemUtil.Compress(pb);
                    byte[] pbEnc = CryptoUtil.ProtectData(pbCmp, IpcOptEnt,
                                                          DataProtectionScope.CurrentUser);

                    File.WriteAllBytes(strPath, pbEnc);
                }

                return(true);
            }
            catch (Exception) { Debug.Assert(false); }

            return(false);
        }
Ejemplo n.º 8
0
        public static void SendGlobalMessage(IpcParamEx ipcMsg, bool bOneInstance)
        {
            if (ipcMsg == null)
            {
                throw new ArgumentNullException("ipcMsg");
            }

            int nId = (int)(MemUtil.BytesToUInt32(CryptoRandom.Instance.GetRandomBytes(
                                                      4)) & 0x7FFFFFFF);

            if (!WriteIpcInfoFile(nId, ipcMsg))
            {
                return;
            }

            try
            {
                // NativeMethods.SendMessage((IntPtr)NativeMethods.HWND_BROADCAST,
                //	Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
                //	(IntPtr)nId);

                // IntPtr pResult = new IntPtr(0);
                // NativeMethods.SendMessageTimeout((IntPtr)NativeMethods.HWND_BROADCAST,
                //	Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
                //	(IntPtr)nId, NativeMethods.SMTO_ABORTIFHUNG, 5000, ref pResult);

                IpcBroadcast.Send(bOneInstance ? Program.AppMessage.IpcByFile1 :
                                  Program.AppMessage.IpcByFile, nId, true);
            }
            catch (Exception) { Debug.Assert(false); }

            if (bOneInstance)
            {
                string strIpcFile = GetIpcFilePath(nId);
                for (int r = 0; r < 50; ++r)
                {
                    try { if (!File.Exists(strIpcFile))
                          {
                              break;
                          }
                    }
                    catch (Exception) { Debug.Assert(false); }
                    Thread.Sleep(20);
                }
            }
            else
            {
                Thread.Sleep(1000);
            }

            RemoveIpcInfoFile(nId);
        }
Ejemplo n.º 9
0
        public static void ProcessGlobalMessage(int nId, MainForm mf)
        {
            if (mf == null)
            {
                throw new ArgumentNullException("mf");
            }

            IpcParamEx ipcMsg = LoadIpcInfoFile(nId);

            if (ipcMsg == null)
            {
                return;
            }

            if (ipcMsg.Message == CmdOpenDatabase)
            {
                mf.UIBlockAutoUnlock(true);
                mf.EnsureVisibleForegroundWindow(true, true);
                mf.UIBlockAutoUnlock(false);

                // Don't try to open another database while a dialog
                // is displayed (3489098)
                if (GlobalWindowManager.WindowCount > 0)
                {
                    return;
                }

                string[] vArgs = CommandLineArgs.SafeDeserialize(ipcMsg.Param0);
                if (vArgs == null)
                {
                    Debug.Assert(false); return;
                }

                CommandLineArgs args = new CommandLineArgs(vArgs);
                Program.CommandLineArgs.CopyFrom(args);

                mf.OpenDatabase(mf.IocFromCommandLine(), KeyUtil.KeyFromCommandLine(
                                    Program.CommandLineArgs), true);
            }
            else if (ipcMsg.Message == CmdOpenEntryUrl)
            {
                OpenEntryUrl(ipcMsg, mf);
            }
            else
            {
                Debug.Assert(false);
            }
        }
Ejemplo n.º 10
0
        private static IpcParamEx LoadIpcInfoFile(int nId, bool bOneInstance)
        {
            string strPath = GetIpcFilePath(nId);

            if (string.IsNullOrEmpty(strPath))
            {
                return(null);
            }

            string strMtxName = null;

            if (bOneInstance)
            {
                strMtxName = IpcMsgFilePreID + nId.ToString();
                if (!GlobalMutexPool.CreateMutex(strMtxName, true))
                {
                    return(null);
                }
            }

            IpcParamEx ipcParam = null;

            try
            {
                byte[] pbEnc = File.ReadAllBytes(strPath);
                byte[] pbCmp = CryptoUtil.UnprotectData(pbEnc, IpcOptEnt,
                                                        DataProtectionScope.CurrentUser);
                byte[] pb = MemUtil.Decompress(pbCmp);

                using (MemoryStream ms = new MemoryStream(pb, false))
                {
                    ipcParam = XmlUtilEx.Deserialize <IpcParamEx>(ms);
                }
            }
            catch (Exception) { Debug.Assert(!File.Exists(strPath)); }

            if (bOneInstance)
            {
                RemoveIpcInfoFile(nId);
                if (!GlobalMutexPool.ReleaseMutex(strMtxName))
                {
                    Debug.Assert(false);
                }
            }

            return(ipcParam);
        }
Ejemplo n.º 11
0
        private static IpcParamEx LoadIpcInfoFile(int nId)
        {
            string strPath = GetIpcFilePath(nId);

            if (string.IsNullOrEmpty(strPath))
            {
                return(null);
            }

            string strMtxName = (IpcMsgFilePreID + nId.ToString());
            // Mutex m = Program.TrySingleInstanceLock(strMtxName, true);
            bool bMutex = GlobalMutexPool.CreateMutex(strMtxName, true);

            // if(m == null) return null;
            if (!bMutex)
            {
                return(null);
            }

            IpcParamEx ipcParam = null;

            try
            {
                XmlSerializer xml = new XmlSerializer(typeof(IpcParamEx));
                FileStream    fs  = new FileStream(strPath, FileMode.Open,
                                                   FileAccess.Read, FileShare.Read);

                try { ipcParam = (IpcParamEx)xml.Deserialize(fs); }
                catch (Exception) { Debug.Assert(false); }

                fs.Close();
            }
            catch (Exception) { }

            RemoveIpcInfoFile(nId);

            // Program.DestroyMutex(m, true);
            if (!GlobalMutexPool.ReleaseMutex(strMtxName))
            {
                Debug.Assert(false);
            }
            return(ipcParam);
        }
Ejemplo n.º 12
0
        private static void OpenEntryUrl(IpcParamEx ip, MainForm mf)
        {
            string strUuid = ip.Param0;

            if (string.IsNullOrEmpty(strUuid))
            {
                return;                                           // No assert (user data)
            }
            byte[] pbUuid = MemUtil.HexStringToByteArray(strUuid);
            if ((pbUuid == null) || (pbUuid.Length != PwUuid.UuidSize))
            {
                return;
            }
            PwUuid pwUuid = new PwUuid(pbUuid);

            List <PwDocument> lDocs = mf.DocumentManager.GetDocuments(int.MinValue);

            foreach (PwDocument pwDoc in lDocs)
            {
                if (pwDoc == null)
                {
                    Debug.Assert(false); continue;
                }

                PwDatabase pdb = pwDoc.Database;
                if ((pdb == null) || !pdb.IsOpen)
                {
                    continue;
                }

                PwEntry pe = pdb.RootGroup.FindEntry(pwUuid, true);
                if (pe == null)
                {
                    continue;
                }

                mf.PerformDefaultUrlAction(new PwEntry[] { pe }, true);
                break;
            }
        }
Ejemplo n.º 13
0
        private static bool WriteIpcInfoFile(int nId, IpcParamEx ipcMsg)
        {
            string strPath = GetIpcFilePath(nId);

            if (string.IsNullOrEmpty(strPath))
            {
                return(false);
            }

            try
            {
                using (FileStream fs = new FileStream(strPath, FileMode.Create,
                                                      FileAccess.Write, FileShare.None))
                {
                    XmlUtilEx.Serialize <IpcParamEx>(fs, ipcMsg);
                }

                return(true);
            }
            catch (Exception) { Debug.Assert(false); }

            return(false);
        }
Ejemplo n.º 14
0
        public static void ProcessGlobalMessage(int nId, MainForm mf, bool bOneInstance)
        {
            if (mf == null)
            {
                throw new ArgumentNullException("mf");
            }

            IpcParamEx ipcMsg = LoadIpcInfoFile(nId, bOneInstance);

            if (ipcMsg == null)
            {
                return;
            }

            if (ipcMsg.Message == CmdOpenDatabase)
            {
                mf.UIBlockAutoUnlock(true);
                mf.EnsureVisibleForegroundWindow(true, true);
                mf.UIBlockAutoUnlock(false);

                string[] vArgs = CommandLineArgs.SafeDeserialize(ipcMsg.Param0);
                if (vArgs == null)
                {
                    Debug.Assert(false); return;
                }

                CommandLineArgs args = new CommandLineArgs(vArgs);
                Program.CommandLineArgs.CopyFrom(args);

                mf.OpenDatabase(mf.IocFromCommandLine(), KeyUtil.KeyFromCommandLine(
                                    Program.CommandLineArgs), true);
            }
            else if (ipcMsg.Message == CmdOpenEntryUrl)
            {
                OpenEntryUrl(ipcMsg, mf);
            }
            else if (ipcMsg.Message == CmdIpcEvent)
            {
                try
                {
                    if (IpcUtilEx.IpcEvent == null)
                    {
                        return;
                    }

                    string strName = ipcMsg.Param0;
                    if (string.IsNullOrEmpty(strName))
                    {
                        Debug.Assert(false); return;
                    }

                    string[] vArgs = CommandLineArgs.SafeDeserialize(ipcMsg.Param1);
                    if (vArgs == null)
                    {
                        Debug.Assert(false); return;
                    }

                    CommandLineArgs clArgs = new CommandLineArgs(vArgs);

                    IpcEventArgs e = new IpcEventArgs(strName, clArgs);
                    IpcUtilEx.IpcEvent(null, e);
                }
                catch (Exception) { Debug.Assert(false); }
            }
            else
            {
                Debug.Assert(false);
            }
        }
Ejemplo n.º 15
0
        private static void OpenEntryUrl(IpcParamEx ip, MainForm mf)
        {
            string strUuid = ip.Param0;
            if(string.IsNullOrEmpty(strUuid)) return; // No assert (user data)

            byte[] pbUuid = MemUtil.HexStringToByteArray(strUuid);
            if((pbUuid == null) || (pbUuid.Length != PwUuid.UuidSize)) return;
            PwUuid pwUuid = new PwUuid(pbUuid);

            List<PwDocument> lDocs = mf.DocumentManager.GetDocuments(int.MinValue);
            foreach(PwDocument pwDoc in lDocs)
            {
                if(pwDoc == null) { Debug.Assert(false); continue; }

                PwDatabase pdb = pwDoc.Database;
                if((pdb == null) || !pdb.IsOpen) continue;

                PwEntry pe = pdb.RootGroup.FindEntry(pwUuid, true);
                if(pe == null) continue;

                mf.PerformDefaultUrlAction(new PwEntry[]{ pe }, true);
                break;
            }
        }
Ejemplo n.º 16
0
 public static void SendGlobalMessage(IpcParamEx ipcMsg)
 {
     SendGlobalMessage(ipcMsg, true);             // Backward compatibility
 }
Ejemplo n.º 17
0
        private static void OpenEntryUrl(IpcParamEx ip, MainForm mf)
        {
            string strUuid = ip.Param0;
            if(string.IsNullOrEmpty(strUuid)) return; // No assert (user data)

            byte[] pbUuid = MemUtil.HexStringToByteArray(strUuid);
            if((pbUuid == null) || (pbUuid.Length != PwUuid.UuidSize)) return;
            PwUuid pwUuid = new PwUuid(pbUuid);

            List<PwDocument> lDocs = new List<PwDocument>(mf.DocumentManager.Documents);
            PwDocument pwDocActive = mf.DocumentManager.ActiveDocument;
            for(int i = 1; i < lDocs.Count; ++i)
            {
                if(object.ReferenceEquals(lDocs[i], pwDocActive))
                {
                    lDocs.RemoveAt(i);
                    lDocs.Insert(0, pwDocActive);
                    break;
                }
            }

            foreach(PwDocument pwDoc in lDocs)
            {
                if(pwDoc == null) { Debug.Assert(false); continue; }

                PwDatabase pdb = pwDoc.Database;
                if((pdb == null) || !pdb.IsOpen) continue;

                PwEntry pe = pdb.RootGroup.FindEntry(pwUuid, true);
                if(pe == null) continue;

                mf.PerformDefaultUrlAction(new PwEntry[]{ pe }, true);
                break;
            }
        }
Ejemplo n.º 18
0
        // internal static void DestroyMutex(Mutex m, bool bReleaseFirst)
        // {
        //    if(m == null) return;
        //    if(bReleaseFirst)
        //    {
        //        try { m.ReleaseMutex(); }
        //        catch(Exception) { Debug.Assert(false); }
        //    }
        //    try { m.Close(); }
        //    catch(Exception) { Debug.Assert(false); }
        // }
        private static void ActivatePreviousInstance(string[] args)
        {
            if((m_nAppMessage == 0) && !KeePassLib.Native.NativeLib.IsUnix())
            {
                Debug.Assert(false);
                return;
            }

            try
            {
                if(string.IsNullOrEmpty(m_cmdLineArgs.FileName))
                {
                    // NativeMethods.PostMessage((IntPtr)NativeMethods.HWND_BROADCAST,
                    //	m_nAppMessage, (IntPtr)AppMessage.RestoreWindow, IntPtr.Zero);
                    IpcBroadcast.Send(AppMessage.RestoreWindow, 0, false);
                }
                else
                {
                    string[] vFlt = KeyUtil.MakeCtxIndependent(args);

                    IpcParamEx ipcMsg = new IpcParamEx(IpcUtilEx.CmdOpenDatabase,
                        CommandLineArgs.SafeSerialize(vFlt), null, null, null, null);

                    IpcUtilEx.SendGlobalMessage(ipcMsg);
                }
            }
            catch(Exception) { Debug.Assert(false); }
        }
Ejemplo n.º 19
0
        public static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.DoEvents(); // Required

            #if DEBUG
            string strInitialWorkDir = WinUtil.GetWorkingDirectory();
            #endif

            if(!CommonInit()) { CommonTerminate(); return; }

            if(m_appConfig.Application.Start.PluginCacheClearOnce)
            {
                PlgxCache.Clear();
                m_appConfig.Application.Start.PluginCacheClearOnce = false;
                AppConfigSerializer.Save(Program.Config);
            }

            m_cmdLineArgs = new CommandLineArgs(args);

            if(m_cmdLineArgs[AppDefs.CommandLineOptions.FileExtRegister] != null)
            {
                ShellUtil.RegisterExtension(AppDefs.FileExtension.FileExt, AppDefs.FileExtension.ExtId,
                    KPRes.FileExtName, WinUtil.GetExecutable(), PwDefs.ShortProductName, false);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.FileExtUnregister] != null)
            {
                ShellUtil.UnregisterExtension(AppDefs.FileExtension.FileExt, AppDefs.FileExtension.ExtId);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoad] != null)
            {
                // All important .NET assemblies are in memory now already
                try { SelfTest.Perform(); }
                catch(Exception) { Debug.Assert(false); }
                MainCleanUp();
                return;
            }
            /* else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoadRegister] != null)
            {
                string strPreLoadPath = WinUtil.GetExecutable().Trim();
                if(strPreLoadPath.StartsWith("\"") == false)
                    strPreLoadPath = "\"" + strPreLoadPath + "\"";
                ShellUtil.RegisterPreLoad(AppDefs.PreLoadName, strPreLoadPath,
                    @"--" + AppDefs.CommandLineOptions.PreLoad, true);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoadUnregister] != null)
            {
                ShellUtil.RegisterPreLoad(AppDefs.PreLoadName, string.Empty,
                    string.Empty, false);
                MainCleanUp();
                return;
            } */
            else if((m_cmdLineArgs[AppDefs.CommandLineOptions.Help] != null) ||
                (m_cmdLineArgs[AppDefs.CommandLineOptions.HelpLong] != null))
            {
                AppHelp.ShowHelp(AppDefs.HelpTopics.CommandLine, null);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigSetUrlOverride] != null)
            {
                Program.Config.Integration.UrlOverride = m_cmdLineArgs[
                    AppDefs.CommandLineOptions.ConfigSetUrlOverride];
                AppConfigSerializer.Save(Program.Config);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigClearUrlOverride] != null)
            {
                Program.Config.Integration.UrlOverride = string.Empty;
                AppConfigSerializer.Save(Program.Config);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigGetUrlOverride] != null)
            {
                try
                {
                    string strFileOut = UrlUtil.EnsureTerminatingSeparator(
                        UrlUtil.GetTempPath(), false) + "KeePass_UrlOverride.tmp";
                    string strContent = ("[KeePass]\r\nKeeURLOverride=" +
                        Program.Config.Integration.UrlOverride + "\r\n");
                    File.WriteAllText(strFileOut, strContent);
                }
                catch(Exception) { Debug.Assert(false); }
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigSetLanguageFile] != null)
            {
                Program.Config.Application.LanguageFile = m_cmdLineArgs[
                    AppDefs.CommandLineOptions.ConfigSetLanguageFile];
                AppConfigSerializer.Save(Program.Config);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PlgxCreate] != null)
            {
                PlgxPlugin.CreateFromCommandLine();
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PlgxCreateInfo] != null)
            {
                PlgxPlugin.CreateInfoFile(m_cmdLineArgs.FileName);
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ShowAssemblyInfo] != null)
            {
                MessageService.ShowInfo(Assembly.GetExecutingAssembly().ToString());
                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.MakeXmlSerializerEx] != null)
            {
                XmlSerializerEx.GenerateSerializers(m_cmdLineArgs);
                MainCleanUp();
                return;
            }
            #if (DEBUG && !KeePassLibSD)
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.MakePopularPasswordTable] != null)
            {
                PopularPasswords.MakeList();
                MainCleanUp();
                return;
            }
            #endif

            try { m_nAppMessage = NativeMethods.RegisterWindowMessage(m_strWndMsgID); }
            catch(Exception) { Debug.Assert(KeePassLib.Native.NativeLib.IsUnix()); }

            if(m_cmdLineArgs[AppDefs.CommandLineOptions.ExitAll] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.Exit);
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.AutoType] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.AutoType);
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.OpenEntryUrl] != null)
            {
                string strEntryUuid = m_cmdLineArgs[AppDefs.CommandLineOptions.Uuid];
                if(!string.IsNullOrEmpty(strEntryUuid))
                {
                    IpcParamEx ipUrl = new IpcParamEx(IpcUtilEx.CmdOpenEntryUrl,
                        strEntryUuid, null, null, null, null);
                    IpcUtilEx.SendGlobalMessage(ipUrl);
                }

                MainCleanUp();
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.LockAll] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.Lock);
                return;
            }
            else if(m_cmdLineArgs[AppDefs.CommandLineOptions.UnlockAll] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.Unlock);
                return;
            }

            // Mutex mSingleLock = TrySingleInstanceLock(AppDefs.MutexName, true);
            bool bSingleLock = GlobalMutexPool.CreateMutex(AppDefs.MutexName, true);
            // if((mSingleLock == null) && m_appConfig.Integration.LimitToSingleInstance)
            if(!bSingleLock && m_appConfig.Integration.LimitToSingleInstance)
            {
                ActivatePreviousInstance(args);
                MainCleanUp();
                return;
            }

            Mutex mGlobalNotify = TryGlobalInstanceNotify(AppDefs.MutexNameGlobal);

            AutoType.InitStatic();

            UserActivityNotifyFilter nfActivity = new UserActivityNotifyFilter();
            Application.AddMessageFilter(nfActivity);

            #if DEBUG
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.DebugThrowException] != null)
                throw new Exception(AppDefs.CommandLineOptions.DebugThrowException);

            m_formMain = new MainForm();
            Application.Run(m_formMain);
            #else
            try
            {
                if(m_cmdLineArgs[AppDefs.CommandLineOptions.DebugThrowException] != null)
                    throw new Exception(AppDefs.CommandLineOptions.DebugThrowException);

                m_formMain = new MainForm();
                Application.Run(m_formMain);
            }
            catch(Exception exPrg) { MessageService.ShowFatal(exPrg); }
            #endif

            Application.RemoveMessageFilter(nfActivity);

            Debug.Assert(GlobalWindowManager.WindowCount == 0);
            Debug.Assert(MessageService.CurrentMessageCount == 0);

            MainCleanUp();

            #if DEBUG
            string strEndWorkDir = WinUtil.GetWorkingDirectory();
            Debug.Assert(strEndWorkDir.Equals(strInitialWorkDir, StrUtil.CaseIgnoreCmp));
            #endif

            if(mGlobalNotify != null) { GC.KeepAlive(mGlobalNotify); }
            // if(mSingleLock != null) { GC.KeepAlive(mSingleLock); }
        }
Ejemplo n.º 20
0
		private static void OnFormLoadParallelAsync(object stateInfo)
		{
			try
			{
				PopularPasswords.Add(Properties.Resources.MostPopularPasswords, true);

				string strShInstUtil = UrlUtil.GetFileDirectory(
					WinUtil.GetExecutable(), true, false) + AppDefs.ShInstUtil;

				// Unblock the application such that the user isn't
				// prompted next time anymore
				WinUtil.RemoveZoneIdentifier(WinUtil.GetExecutable());
				WinUtil.RemoveZoneIdentifier(AppHelp.LocalHelpFile);
				WinUtil.RemoveZoneIdentifier(strShInstUtil);

				// http://stackoverflow.com/questions/26256917/how-can-i-prevent-my-application-from-causing-a-0xc0000142-error-in-csc-exe
				XmlSerializer xs = new XmlSerializer(typeof(IpcParamEx));
				IpcParamEx ipc = new IpcParamEx();
				MemoryStream ms = new MemoryStream();
				xs.Serialize(ms, ipc);
				ms.Close();
			}
			catch(Exception) { Debug.Assert(false); }
		}
Ejemplo n.º 21
0
        private static void ActivatePreviousInstance(string[] args)
        {
            if(m_nAppMessage == 0) { Debug.Assert(false); return; }

            try
            {
                if(string.IsNullOrEmpty(m_cmdLineArgs.FileName))
                    NativeMethods.SendMessage((IntPtr)NativeMethods.HWND_BROADCAST,
                        m_nAppMessage, (IntPtr)AppMessage.RestoreWindow, IntPtr.Zero);
                else
                {
                    IpcParamEx ipcMsg = new IpcParamEx(IpcUtilEx.CmdOpenDatabase,
                        CommandLineArgs.SafeSerialize(args), null, null, null, null);

                    IpcUtilEx.SendGlobalMessage(ipcMsg);
                }
            }
            catch(Exception) { Debug.Assert(false); }
        }
Ejemplo n.º 22
0
		public static void Main(string[] args)
		{
			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);
			Application.DoEvents(); // Required

			InitEnvSecurity();

			int nRandomSeed = (int)DateTime.Now.Ticks;
			// Prevent overflow (see Random class constructor)
			if(nRandomSeed == int.MinValue) nRandomSeed = 17;
			m_rndGlobal = new Random(nRandomSeed);

			// Set global localized strings
			PwDatabase.LocalizedAppName = PwDefs.ShortProductName;
			Kdb4File.DetermineLanguageId();

			m_appConfig = AppConfigSerializer.Load();
			if(m_appConfig.Logging.Enabled)
				AppLogEx.Open(PwDefs.ShortProductName);

			AppPolicy.Current = m_appConfig.Security.Policy.CloneDeep();

			m_ecasTriggers = m_appConfig.Application.TriggerSystem;
			m_ecasTriggers.SetToInitialState();

			string strHelpFile = UrlUtil.StripExtension(WinUtil.GetExecutable()) + ".chm";
			AppHelp.LocalHelpFile = strHelpFile;

			string strLangFile = m_appConfig.Application.LanguageFile;
			if((strLangFile != null) && (strLangFile.Length > 0))
			{
				strLangFile = UrlUtil.GetFileDirectory(WinUtil.GetExecutable(), true,
					false) + strLangFile;

				try
				{
					m_kpTranslation = KPTranslation.LoadFromFile(strLangFile);

					KPRes.SetTranslatedStrings(
						m_kpTranslation.SafeGetStringTableDictionary(
						"KeePass.Resources.KPRes"));
					KLRes.SetTranslatedStrings(
						m_kpTranslation.SafeGetStringTableDictionary(
						"KeePassLib.Resources.KLRes"));

					StrUtil.RightToLeft = m_kpTranslation.Properties.RightToLeft;
				}
				catch(FileNotFoundException) { } // Ignore
				catch(Exception) { Debug.Assert(false); }
			}

			if(m_appConfig.Application.Start.PluginCacheClearOnce)
			{
				PlgxCache.Clear();
				m_appConfig.Application.Start.PluginCacheClearOnce = false;
				AppConfigSerializer.Save(Program.Config);
			}

			m_cmdLineArgs = new CommandLineArgs(args);

			if(m_cmdLineArgs[AppDefs.CommandLineOptions.FileExtRegister] != null)
			{
				ShellUtil.RegisterExtension(AppDefs.FileExtension.FileExt, AppDefs.FileExtension.ExtId,
					KPRes.FileExtName, WinUtil.GetExecutable(), PwDefs.ShortProductName, false);
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.FileExtUnregister] != null)
			{
				ShellUtil.UnregisterExtension(AppDefs.FileExtension.FileExt, AppDefs.FileExtension.ExtId);
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoad] != null)
			{
				// All important .NET assemblies are in memory now already
				try { SelfTest.Perform(); }
				catch(Exception) { Debug.Assert(false); }
				MainCleanUp();
				return;
			}
			/* else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoadRegister] != null)
			{
				string strPreLoadPath = WinUtil.GetExecutable().Trim();
				if(strPreLoadPath.StartsWith("\"") == false)
					strPreLoadPath = "\"" + strPreLoadPath + "\"";
				ShellUtil.RegisterPreLoad(AppDefs.PreLoadName, strPreLoadPath,
					@"--" + AppDefs.CommandLineOptions.PreLoad, true);
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoadUnregister] != null)
			{
				ShellUtil.RegisterPreLoad(AppDefs.PreLoadName, string.Empty,
					string.Empty, false);
				MainCleanUp();
				return;
			} */
			else if((m_cmdLineArgs[AppDefs.CommandLineOptions.Help] != null) ||
				(m_cmdLineArgs[AppDefs.CommandLineOptions.HelpLong] != null))
			{
				AppHelp.ShowHelp(AppDefs.HelpTopics.CommandLine, null);
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigSetUrlOverride] != null)
			{
				Program.Config.Integration.UrlOverride = m_cmdLineArgs[
					AppDefs.CommandLineOptions.ConfigSetUrlOverride];
				AppConfigSerializer.Save(Program.Config);
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigClearUrlOverride] != null)
			{
				Program.Config.Integration.UrlOverride = string.Empty;
				AppConfigSerializer.Save(Program.Config);
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigGetUrlOverride] != null)
			{
				try
				{
					string strFileOut = UrlUtil.EnsureTerminatingSeparator(
						Path.GetTempPath(), false) + "KeePass_UrlOverride.tmp";
					string strContent = ("[KeePass]\r\nKeeURLOverride=" +
						Program.Config.Integration.UrlOverride + "\r\n");
					File.WriteAllText(strFileOut, strContent);
				}
				catch(Exception) { Debug.Assert(false); }
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigSetLanguageFile] != null)
			{
				Program.Config.Application.LanguageFile = m_cmdLineArgs[
					AppDefs.CommandLineOptions.ConfigSetLanguageFile];
				AppConfigSerializer.Save(Program.Config);
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PlgxCreate] != null)
			{
				PlgxPlugin.CreateFromCommandLine();
				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.PlgxCreateInfo] != null)
			{
				PlgxPlugin.CreateInfoFile(m_cmdLineArgs.FileName);
				MainCleanUp();
				return;
			}
#if (DEBUG && !KeePassLibSD)
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.MakePopularPasswordTable] != null)
			{
				PopularPasswords.MakeList();
				MainCleanUp();
				return;
			}
#endif

			try { m_nAppMessage = NativeMethods.RegisterWindowMessage(m_strWndMsgID); }
			catch(Exception) { Debug.Assert(false); }

			if(m_cmdLineArgs[AppDefs.CommandLineOptions.ExitAll] != null)
			{
				BroadcastAppMessageAndCleanUp(AppMessage.Exit);
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.AutoType] != null)
			{
				BroadcastAppMessageAndCleanUp(AppMessage.AutoType);
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.OpenEntryUrl] != null)
			{
				string strEntryUuid = m_cmdLineArgs[AppDefs.CommandLineOptions.Uuid];
				if(!string.IsNullOrEmpty(strEntryUuid))
				{
					IpcParamEx ipUrl = new IpcParamEx(IpcUtilEx.CmdOpenEntryUrl,
						strEntryUuid, null, null, null, null);
					IpcUtilEx.SendGlobalMessage(ipUrl);
				}

				MainCleanUp();
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.LockAll] != null)
			{
				BroadcastAppMessageAndCleanUp(AppMessage.Lock);
				return;
			}
			else if(m_cmdLineArgs[AppDefs.CommandLineOptions.UnlockAll] != null)
			{
				BroadcastAppMessageAndCleanUp(AppMessage.Unlock);
				return;
			}

			Mutex mSingleLock = TrySingleInstanceLock(AppDefs.MutexName, true);
			if((mSingleLock == null) && m_appConfig.Integration.LimitToSingleInstance)
			{
				ActivatePreviousInstance(args);
				MainCleanUp();
				return;
			}

			Mutex mGlobalNotify = TryGlobalInstanceNotify(AppDefs.MutexNameGlobal);

			AutoType.InitStatic();

			UserActivityNotifyFilter nfActivity = new UserActivityNotifyFilter();
			Application.AddMessageFilter(nfActivity);

#if DEBUG
			m_formMain = new MainForm();
			Application.Run(m_formMain);
#else
			try
			{
				m_formMain = new MainForm();
				Application.Run(m_formMain);
			}
			catch(Exception exPrg) { MessageService.ShowFatal(exPrg); }
#endif

			Application.RemoveMessageFilter(nfActivity);

			Debug.Assert(GlobalWindowManager.WindowCount == 0);
			Debug.Assert(MessageService.CurrentMessageCount == 0);

			MainCleanUp();

			if(mGlobalNotify != null) { GC.KeepAlive(mGlobalNotify); }
			if(mSingleLock != null) { GC.KeepAlive(mSingleLock); }
		}
Ejemplo n.º 23
0
        public static void Main(string[] args)
        {
            #if DEBUG
            // Program.DesignMode should not be queried before executing
            // Main (e.g. by a static Control) when running the program
            // normally
            Debug.Assert(!m_bDesignModeQueried);
            #endif
            m_bDesignMode = false; // Designer doesn't call Main method

            m_cmdLineArgs = new CommandLineArgs(args);

            // Before loading the configuration
            string strWaDisable = m_cmdLineArgs[
                AppDefs.CommandLineOptions.WorkaroundDisable];
            if(!string.IsNullOrEmpty(strWaDisable))
                MonoWorkarounds.SetEnabled(strWaDisable, false);

            DpiUtil.ConfigureProcess();
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.DoEvents(); // Required

            #if DEBUG
            string strInitialWorkDir = WinUtil.GetWorkingDirectory();
            #endif

            if(!CommonInit()) { CommonTerminate(); return; }

            if(m_appConfig.Application.Start.PluginCacheClearOnce)
            {
                PlgxCache.Clear();
                m_appConfig.Application.Start.PluginCacheClearOnce = false;
                AppConfigSerializer.Save(Program.Config);
            }

            if(m_cmdLineArgs[AppDefs.CommandLineOptions.FileExtRegister] != null)
            {
                ShellUtil.RegisterExtension(AppDefs.FileExtension.FileExt, AppDefs.FileExtension.ExtId,
                    KPRes.FileExtName, WinUtil.GetExecutable(), PwDefs.ShortProductName, false);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.FileExtUnregister] != null)
            {
                ShellUtil.UnregisterExtension(AppDefs.FileExtension.FileExt, AppDefs.FileExtension.ExtId);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoad] != null)
            {
                // All important .NET assemblies are in memory now already
                try { SelfTest.Perform(); }
                catch(Exception) { Debug.Assert(false); }
                MainCleanUp();
                return;
            }
            /* if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoadRegister] != null)
            {
                string strPreLoadPath = WinUtil.GetExecutable().Trim();
                if(strPreLoadPath.StartsWith("\"") == false)
                    strPreLoadPath = "\"" + strPreLoadPath + "\"";
                ShellUtil.RegisterPreLoad(AppDefs.PreLoadName, strPreLoadPath,
                    @"--" + AppDefs.CommandLineOptions.PreLoad, true);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.PreLoadUnregister] != null)
            {
                ShellUtil.RegisterPreLoad(AppDefs.PreLoadName, string.Empty,
                    string.Empty, false);
                MainCleanUp();
                return;
            } */
            if((m_cmdLineArgs[AppDefs.CommandLineOptions.Help] != null) ||
                (m_cmdLineArgs[AppDefs.CommandLineOptions.HelpLong] != null))
            {
                AppHelp.ShowHelp(AppDefs.HelpTopics.CommandLine, null);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigSetUrlOverride] != null)
            {
                Program.Config.Integration.UrlOverride = m_cmdLineArgs[
                    AppDefs.CommandLineOptions.ConfigSetUrlOverride];
                AppConfigSerializer.Save(Program.Config);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigClearUrlOverride] != null)
            {
                Program.Config.Integration.UrlOverride = string.Empty;
                AppConfigSerializer.Save(Program.Config);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigGetUrlOverride] != null)
            {
                try
                {
                    string strFileOut = UrlUtil.EnsureTerminatingSeparator(
                        UrlUtil.GetTempPath(), false) + "KeePass_UrlOverride.tmp";
                    string strContent = ("[KeePass]\r\nKeeURLOverride=" +
                        Program.Config.Integration.UrlOverride + "\r\n");
                    File.WriteAllText(strFileOut, strContent);
                }
                catch(Exception) { Debug.Assert(false); }
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.ConfigSetLanguageFile] != null)
            {
                Program.Config.Application.LanguageFile = m_cmdLineArgs[
                    AppDefs.CommandLineOptions.ConfigSetLanguageFile];
                AppConfigSerializer.Save(Program.Config);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.PlgxCreate] != null)
            {
                PlgxPlugin.CreateFromCommandLine();
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.PlgxCreateInfo] != null)
            {
                PlgxPlugin.CreateInfoFile(m_cmdLineArgs.FileName);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.ShowAssemblyInfo] != null)
            {
                MessageService.ShowInfo(Assembly.GetExecutingAssembly().ToString());
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.MakeXmlSerializerEx] != null)
            {
                XmlSerializerEx.GenerateSerializers(m_cmdLineArgs);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.MakeXspFile] != null)
            {
                XspArchive.CreateFile(m_cmdLineArgs.FileName, m_cmdLineArgs["d"]);
                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.Version] != null)
            {
                Console.WriteLine(PwDefs.ShortProductName + " " + PwDefs.VersionString);
                Console.WriteLine(PwDefs.Copyright);
                MainCleanUp();
                return;
            }
            #if DEBUG
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.TestGfx] != null)
            {
                List<Image> lImg = new List<Image>();
                lImg.Add(Properties.Resources.B16x16_Browser);
                lImg.Add(Properties.Resources.B48x48_Keyboard_Layout);
                ImageArchive aHighRes = new ImageArchive();
                aHighRes.Load(Properties.Resources.Images_Client_HighRes);
                lImg.Add(aHighRes.GetForObject("C12_IRKickFlash"));
                if(File.Exists("Test.png"))
                    lImg.Add(Image.FromFile("Test.png"));
                Image img = GfxUtil.ScaleTest(lImg.ToArray());
                img.Save("GfxScaleTest.png", ImageFormat.Png);
                return;
            }
            #endif
            // #if (DEBUG && !KeePassLibSD)
            // if(m_cmdLineArgs[AppDefs.CommandLineOptions.MakePopularPasswordTable] != null)
            // {
            //	PopularPasswords.MakeList();
            //	MainCleanUp();
            //	return;
            // }
            // #endif

            try { m_nAppMessage = NativeMethods.RegisterWindowMessage(m_strWndMsgID); }
            catch(Exception) { Debug.Assert(NativeLib.IsUnix()); }

            if(m_cmdLineArgs[AppDefs.CommandLineOptions.ExitAll] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.Exit);
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.AutoType] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.AutoType);
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.AutoTypeSelected] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.AutoTypeSelected);
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.OpenEntryUrl] != null)
            {
                string strEntryUuid = m_cmdLineArgs[AppDefs.CommandLineOptions.Uuid];
                if(!string.IsNullOrEmpty(strEntryUuid))
                {
                    IpcParamEx ipUrl = new IpcParamEx(IpcUtilEx.CmdOpenEntryUrl,
                        strEntryUuid, null, null, null, null);
                    IpcUtilEx.SendGlobalMessage(ipUrl);
                }

                MainCleanUp();
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.LockAll] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.Lock);
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.UnlockAll] != null)
            {
                BroadcastAppMessageAndCleanUp(AppMessage.Unlock);
                return;
            }
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.IpcEvent] != null)
            {
                string strName = m_cmdLineArgs[AppDefs.CommandLineOptions.IpcEvent];
                if(!string.IsNullOrEmpty(strName))
                {
                    string[] vFlt = KeyUtil.MakeCtxIndependent(args);

                    IpcParamEx ipEvent = new IpcParamEx(IpcUtilEx.CmdIpcEvent, strName,
                        CommandLineArgs.SafeSerialize(vFlt), null, null, null);
                    IpcUtilEx.SendGlobalMessage(ipEvent);
                }

                MainCleanUp();
                return;
            }

            // Mutex mSingleLock = TrySingleInstanceLock(AppDefs.MutexName, true);
            bool bSingleLock = GlobalMutexPool.CreateMutex(AppDefs.MutexName, true);
            // if((mSingleLock == null) && m_appConfig.Integration.LimitToSingleInstance)
            if(!bSingleLock && m_appConfig.Integration.LimitToSingleInstance)
            {
                ActivatePreviousInstance(args);
                MainCleanUp();
                return;
            }

            Mutex mGlobalNotify = TryGlobalInstanceNotify(AppDefs.MutexNameGlobal);

            AutoType.InitStatic();

            UserActivityNotifyFilter nfActivity = new UserActivityNotifyFilter();
            Application.AddMessageFilter(nfActivity);

            #if DEBUG
            if(m_cmdLineArgs[AppDefs.CommandLineOptions.DebugThrowException] != null)
                throw new Exception(AppDefs.CommandLineOptions.DebugThrowException);

            m_formMain = new MainForm();
            Application.Run(m_formMain);
            #else
            try
            {
                if(m_cmdLineArgs[AppDefs.CommandLineOptions.DebugThrowException] != null)
                    throw new Exception(AppDefs.CommandLineOptions.DebugThrowException);

                m_formMain = new MainForm();
                Application.Run(m_formMain);
            }
            catch(Exception exPrg)
            {
                // Catch message box exception;
                // https://sourceforge.net/p/keepass/patches/86/
                try { MessageService.ShowFatal(exPrg); }
                catch(Exception) { Console.Error.WriteLine(exPrg.ToString()); }
            }
            #endif

            Application.RemoveMessageFilter(nfActivity);

            Debug.Assert(GlobalWindowManager.WindowCount == 0);
            Debug.Assert(MessageService.CurrentMessageCount == 0);

            MainCleanUp();

            #if DEBUG
            string strEndWorkDir = WinUtil.GetWorkingDirectory();
            Debug.Assert(strEndWorkDir.Equals(strInitialWorkDir, StrUtil.CaseIgnoreCmp));
            #endif

            if(mGlobalNotify != null) { GC.KeepAlive(mGlobalNotify); }
            // if(mSingleLock != null) { GC.KeepAlive(mSingleLock); }
        }
Ejemplo n.º 24
0
        private static void OpenEntryUrl(IpcParamEx ip, MainForm mf)
        {
            string strUuid = ip.Param0;
            if(string.IsNullOrEmpty(strUuid)) return; // No assert (user data)

            byte[] pbUuid = MemUtil.HexStringToByteArray(strUuid);
            if((pbUuid == null) || (pbUuid.Length != PwUuid.UuidSize)) return;

            PwDatabase pdb = mf.ActiveDatabase;
            if((pdb == null) || !pdb.IsOpen) return;

            PwEntry pe = pdb.RootGroup.FindEntry(new PwUuid(pbUuid), true);
            if(pe == null) return;

            mf.PerformDefaultUrlAction(new PwEntry[]{ pe }, true);
        }
Ejemplo n.º 25
0
        private static bool WriteIpcInfoFile(int nId, IpcParamEx ipcMsg)
        {
            string strPath = GetIpcFilePath(nId);
            if(string.IsNullOrEmpty(strPath)) return false;

            try
            {
                XmlSerializer xml = new XmlSerializer(typeof(IpcParamEx));
                FileStream fs = new FileStream(strPath, FileMode.Create, FileAccess.Write,
                    FileShare.None);

                try { xml.Serialize(fs, ipcMsg); }
                catch(Exception) { Debug.Assert(false); }

                fs.Close();
                return true;
            }
            catch(Exception) { Debug.Assert(false); }

            return false;
        }
Ejemplo n.º 26
0
        public static void SendGlobalMessage(IpcParamEx ipcMsg)
        {
            if(ipcMsg == null) throw new ArgumentNullException("ipcMsg");

            int nId = (int)(MemUtil.BytesToUInt32(CryptoRandom.Instance.GetRandomBytes(
                4)) & 0x7FFFFFFF);

            if(WriteIpcInfoFile(nId, ipcMsg) == false) return;

            try
            {
                NativeMethods.SendMessage((IntPtr)NativeMethods.HWND_BROADCAST,
                    Program.ApplicationMessage, (IntPtr)Program.AppMessage.IpcByFile,
                    (IntPtr)nId);
            }
            catch(Exception) { Debug.Assert(false); }

            RemoveIpcInfoFile(nId);
        }