AddRefToCache() private static method

private static AddRefToCache ( string strRef, string strValue, SprContext ctx ) : void
strRef string
strValue string
ctx SprContext
return void
Example #1
0
        private static string FillRefPlaceholders(string strSeq, SprContext ctx,
                                                  uint uRecursionLevel)
        {
            if (ctx.Database == null)
            {
                return(strSeq);
            }

            string str = strSeq;

            int nOffset = 0;

            for (int iLoop = 0; iLoop < 20; ++iLoop)
            {
                str = SprEngine.FillRefsUsingCache(str, ctx);

                int nStart = str.IndexOf(StrRefStart, nOffset, SprEngine.ScMethod);
                if (nStart < 0)
                {
                    break;
                }
                int nEnd = str.IndexOf(StrRefEnd, nStart + 1, SprEngine.ScMethod);
                if (nEnd <= nStart)
                {
                    break;
                }

                string  strFullRef = str.Substring(nStart, nEnd - nStart + 1);
                char    chScan, chWanted;
                PwEntry peFound = FindRefTarget(strFullRef, ctx, out chScan, out chWanted);

                if (peFound != null)
                {
                    string strInsData;
                    if (chWanted == 'T')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.TitleField);
                    }
                    else if (chWanted == 'U')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.UserNameField);
                    }
                    else if (chWanted == 'A')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.UrlField);
                    }
                    else if (chWanted == 'P')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.PasswordField);
                    }
                    else if (chWanted == 'N')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.NotesField);
                    }
                    else if (chWanted == 'I')
                    {
                        strInsData = peFound.Uuid.ToHexString();
                    }
                    else
                    {
                        nOffset = nStart + 1; continue;
                    }

                    if ((chWanted == 'P') && !ctx.ForcePlainTextPasswords &&
                        Program.Config.MainWindow.IsColumnHidden(AceColumnType.Password))
                    {
                        strInsData = PwDefs.HiddenPassword;
                    }

                    SprContext sprSub = ctx.WithoutContentTransformations();
                    sprSub.Entry = peFound;

                    string strInnerContent = SprEngine.CompileInternal(strInsData,
                                                                       sprSub, uRecursionLevel + 1);
                    strInnerContent = SprEngine.TransformContent(strInnerContent, ctx);

                    // str = str.Substring(0, nStart) + strInnerContent + str.Substring(nEnd + 1);
                    SprEngine.AddRefToCache(strFullRef, strInnerContent, ctx);
                    str = SprEngine.FillRefsUsingCache(str, ctx);
                }
                else
                {
                    nOffset = nStart + 1; continue;
                }
            }

            return(str);
        }
Example #2
0
        private static string FillRefPlaceholders(string strSeq, PwDatabase pwDatabase,
                                                  SprContentFlags cf, uint uRecursionLevel, SprRefsCache vRefsCache)
        {
            if (pwDatabase == null)
            {
                return(strSeq);
            }

            string str = strSeq;

            const string strStart = @"{REF:";
            const string strEnd   = @"}";

            int nOffset = 0;

            for (int iLoop = 0; iLoop < 20; ++iLoop)
            {
                str = SprEngine.FillRefsUsingCache(str, vRefsCache);

                int nStart = str.IndexOf(strStart, nOffset, SprEngine.ScMethod);
                if (nStart < 0)
                {
                    break;
                }
                int nEnd = str.IndexOf(strEnd, nStart, SprEngine.ScMethod);
                if (nEnd < 0)
                {
                    break;
                }

                string strFullRef = str.Substring(nStart, nEnd - nStart + 1);

                string strRef = str.Substring(nStart + strStart.Length, nEnd -
                                              nStart - strStart.Length);
                if (strRef.Length <= 4)
                {
                    nOffset = nStart + 1; continue;
                }
                if (strRef[1] != '@')
                {
                    nOffset = nStart + 1; continue;
                }
                if (strRef[3] != ':')
                {
                    nOffset = nStart + 1; continue;
                }

                char chScan   = char.ToUpper(strRef[2]);
                char chWanted = char.ToUpper(strRef[0]);

                SearchParameters sp = SearchParameters.None;
                sp.SearchString = strRef.Substring(4);
                if (chScan == 'T')
                {
                    sp.SearchInTitles = true;
                }
                else if (chScan == 'U')
                {
                    sp.SearchInUserNames = true;
                }
                else if (chScan == 'A')
                {
                    sp.SearchInUrls = true;
                }
                else if (chScan == 'P')
                {
                    sp.SearchInPasswords = true;
                }
                else if (chScan == 'N')
                {
                    sp.SearchInNotes = true;
                }
                else if (chScan == 'I')
                {
                    sp.SearchInUuids = true;
                }
                else if (chScan == 'O')
                {
                    sp.SearchInOther = true;
                }
                else
                {
                    nOffset = nStart + 1; continue;
                }

                PwObjectList <PwEntry> lFound = new PwObjectList <PwEntry>();
                pwDatabase.RootGroup.SearchEntries(sp, lFound, true);
                if (lFound.UCount > 0)
                {
                    PwEntry peFound = lFound.GetAt(0);

                    string strInsData;
                    if (chWanted == 'T')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.TitleField);
                    }
                    else if (chWanted == 'U')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.UserNameField);
                    }
                    else if (chWanted == 'A')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.UrlField);
                    }
                    else if (chWanted == 'P')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.PasswordField);
                    }
                    else if (chWanted == 'N')
                    {
                        strInsData = peFound.Strings.ReadSafe(PwDefs.NotesField);
                    }
                    else if (chWanted == 'I')
                    {
                        strInsData = peFound.Uuid.ToHexString();
                    }
                    else
                    {
                        nOffset = nStart + 1; continue;
                    }

                    string strInnerContent = SprEngine.CompileInternal(strInsData,
                                                                       peFound, pwDatabase, null, uRecursionLevel + 1, vRefsCache);
                    strInnerContent = SprEngine.TransformContent(strInnerContent, cf);

                    // str = str.Substring(0, nStart) + strInnerContent + str.Substring(nEnd + 1);
                    SprEngine.AddRefToCache(strFullRef, strInnerContent, vRefsCache);
                    str = SprEngine.FillRefsUsingCache(str, vRefsCache);
                }
                else
                {
                    nOffset = nStart + 1; continue;
                }
            }

            return(str);
        }