public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true);
string str = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
CsvStreamReaderEx csr = new CsvStreamReaderEx(str, opt);
while (true)
{
string[] vLine = csr.ReadLine();
if (vLine == null)
{
break;
}
AddEntry(vLine, pwStorage);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Default, true);
string str = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
// Backslashes are not escaped, even though "\\n" is used
// to encode new-line characters
opt.BackslashIsEscape = false;
opt.FieldSeparator = ';';
CsvStreamReaderEx csr = new CsvStreamReaderEx(str, opt);
Dictionary <string, PwGroup> dGroups = new Dictionary <string, PwGroup>();
while (true)
{
string[] vLine = csr.ReadLine();
if (vLine == null)
{
break;
}
AddEntry(vLine, pwStorage, dGroups);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true);
string strData = sr.ReadToEnd();
sr.Close();
// The Chrome extension of LastPass 4.1.35 encodes some
// special characters as XML entities; the web version and
// the Firefox extension do not do this
strData = strData.Replace(@"<", @"<");
strData = strData.Replace(@">", @">");
strData = strData.Replace(@"&", @"&");
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
CsvStreamReaderEx csr = new CsvStreamReaderEx(strData, opt);
while (true)
{
string[] vLine = csr.ReadLine();
if (vLine == null)
{
break;
}
AddEntry(vLine, pwStorage);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true);
string str = sr.ReadToEnd();
sr.Close();
// All fields are enclosed in '"', however '"' in data is
// not encoded (broken format)
str = str.Trim();
str = StrUtil.NormalizeNewLines(str, false); // To Unix
char chFieldSep = StrUtil.GetUnusedChar(str);
str = str.Replace("\",\"", new string(chFieldSep, 1));
char chRecSep = StrUtil.GetUnusedChar(str);
str = str.Replace("\"\n\"", new string(chRecSep, 1));
if (str.StartsWith("\"") && str.EndsWith("\"") && (str.Length >= 2))
{
str = str.Substring(1, str.Length - 2);
}
else
{
Debug.Assert(false);
}
if (!NativeLib.IsUnix())
{
str = StrUtil.NormalizeNewLines(str, true);
}
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
opt.FieldSeparator = chFieldSep;
opt.RecordSeparator = chRecSep;
opt.TextQualifier = char.MinValue;
CsvStreamReaderEx csr = new CsvStreamReaderEx(str, opt);
while (true)
{
string[] vLine = csr.ReadLine();
if (vLine == null)
{
break;
}
AddEntry(vLine, pwStorage);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Unicode, true);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
while (true)
{
string[] v = csv.ReadLine();
if (v == null)
{
break;
}
if (v.Length < 5)
{
continue;
}
if (v[0].Equals("url", StrUtil.CaseIgnoreCmp) &&
v[1].Equals("username", StrUtil.CaseIgnoreCmp) &&
v[2].Equals("password", StrUtil.CaseIgnoreCmp))
{
continue; // Header
}
PwGroup pg = pwStorage.RootGroup;
string strGroup = v[4];
if (!string.IsNullOrEmpty(strGroup))
{
pg = pg.FindCreateGroup(strGroup, true);
}
PwEntry pe = new PwEntry(true, true);
pg.AddEntry(pe, true);
ImportUtil.AppendToField(pe, PwDefs.UrlField, v[0], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.UserNameField, v[1], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.PasswordField, v[2], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.TitleField, v[3], pwStorage);
}
}
public static Dictionary <string, bool> GetIfDevice(AutoExecItem item)
{
Dictionary <string, bool> result = new Dictionary <string, bool>();
string strList = item.IfDevice;
if (string.IsNullOrEmpty(strList))
{
return(result);
}
CsvOptions opt = new CsvOptions
{
BackslashIsEscape = false,
TrimFields = true
};
CsvStreamReaderEx csv = new CsvStreamReaderEx(strList, opt);
string[] vFlt = csv.ReadLine();
if (vFlt == null)
{
Debug.Assert(false); return(result);
}
foreach (string strFlt in vFlt)
{
if (string.IsNullOrEmpty(strFlt))
{
continue;
}
if (strFlt[0] == '!') // Exclusion
{
result[strFlt.Substring(1).TrimStart()] = false;
}
else // Inclusion
{
result[strFlt] = true;
}
}
return(result);
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
CsvStreamReaderEx csr = new CsvStreamReaderEx(strData, opt);
while(true)
{
string[] vLine = csr.ReadLine();
if(vLine == null) break;
AddEntry(vLine, pwStorage);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Unicode, true);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
while(true)
{
string[] v = csv.ReadLine();
if(v == null) break;
if(v.Length < 5) continue;
if(v[0].Equals("url", StrUtil.CaseIgnoreCmp) &&
v[1].Equals("username", StrUtil.CaseIgnoreCmp) &&
v[2].Equals("password", StrUtil.CaseIgnoreCmp))
continue; // Header
PwGroup pg = pwStorage.RootGroup;
string strGroup = v[4];
if(!string.IsNullOrEmpty(strGroup))
pg = pg.FindCreateGroup(strGroup, true);
PwEntry pe = new PwEntry(true, true);
pg.AddEntry(pe, true);
ImportUtil.AppendToField(pe, PwDefs.UrlField, v[0], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.UserNameField, v[1], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.PasswordField, v[2], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.TitleField, v[3], pwStorage);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true);
string str = sr.ReadToEnd();
sr.Close();
// All fields are enclosed in '"', however '"' in data is
// not encoded (broken format)
str = str.Trim();
str = StrUtil.NormalizeNewLines(str, false); // To Unix
char chFieldSep = StrUtil.GetUnusedChar(str);
str = str.Replace("\",\"", new string(chFieldSep, 1));
char chRecSep = StrUtil.GetUnusedChar(str);
str = str.Replace("\"\n\"", new string(chRecSep, 1));
if(str.StartsWith("\"") && str.EndsWith("\"") && (str.Length >= 2))
str = str.Substring(1, str.Length - 2);
else { Debug.Assert(false); }
if(!NativeLib.IsUnix()) str = StrUtil.NormalizeNewLines(str, true);
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
opt.FieldSeparator = chFieldSep;
opt.RecordSeparator = chRecSep;
opt.TextQualifier = char.MinValue;
CsvStreamReaderEx csr = new CsvStreamReaderEx(str, opt);
while(true)
{
string[] vLine = csr.ReadLine();
if(vLine == null) break;
AddEntry(vLine, pwStorage);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Default);
string strData = sr.ReadToEnd();
sr.Close();
sInput.Close();
Dictionary <string, PwGroup> dGroups = new Dictionary <string, PwGroup>();
dGroups[string.Empty] = pwStorage.RootGroup;
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
while (true)
{
string[] v = csv.ReadLine();
if (v == null)
{
break;
}
if (v.Length == 0)
{
continue;
}
if (v[0].StartsWith("TurboPasswords CSV Export File"))
{
continue;
}
if (v.Length < 24)
{
Debug.Assert(false); continue;
}
if ((v[0] == "Category") && (v[1] == "Type"))
{
continue;
}
PwEntry pe = new PwEntry(true, true);
PwGroup pg;
string strGroup = v[0];
if (!dGroups.TryGetValue(strGroup, out pg))
{
pg = new PwGroup(true, true, strGroup, PwIcon.Folder);
dGroups[string.Empty].AddGroup(pg, true);
dGroups[strGroup] = pg;
}
pg.AddEntry(pe, true);
string strType = v[1];
for (int f = 0; f < 6; ++f)
{
string strKey = v[2 + (2 * f)];
string strValue = v[2 + (2 * f) + 1];
if (strKey.Length == 0)
{
strKey = PwDefs.NotesField;
}
if (strValue.Length == 0)
{
continue;
}
if (strKey == "Description")
{
strKey = PwDefs.TitleField;
}
else if (((strType == "Contact") || (strType == "Personal Info")) &&
(strKey == "Name"))
{
strKey = PwDefs.TitleField;
}
else if (((strType == "Membership") || (strType == "Insurance")) &&
(strKey == "Company"))
{
strKey = PwDefs.TitleField;
}
else if (strKey == "SSN")
{
strKey = PwDefs.UserNameField;
}
else
{
string strMapped = ImportUtil.MapNameToStandardField(strKey, false);
if (!string.IsNullOrEmpty(strMapped))
{
strKey = strMapped;
}
}
ImportUtil.AppendToField(pe, strKey, strValue, pwStorage,
((strKey == PwDefs.NotesField) ? "\r\n" : ", "), false);
}
ImportUtil.AppendToField(pe, PwDefs.NotesField, v[20], pwStorage,
"\r\n\r\n", false);
if (v[21].Length > 0)
{
ImportUtil.AppendToField(pe, "Login URL", v[21], pwStorage, null, true);
}
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Default, true);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions o = new CsvOptions();
o.BackslashIsEscape = false;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, o);
SortedDictionary <string, PwGroup> dictGroups =
new SortedDictionary <string, PwGroup>();
while (true)
{
string[] vLine = csv.ReadLine();
if (vLine == null)
{
break;
}
if (vLine.Length == 0)
{
continue;
}
if (vLine.Length == 1)
{
Debug.Assert(vLine[0] == StrHeader);
continue;
}
// Support old version 3.4
if (vLine.Length == 9)
{
string[] v = new string[13];
for (int i = 0; i < 7; ++i)
{
v[i] = vLine[i];
}
for (int i = 7; i < 11; ++i)
{
v[i] = string.Empty;
}
v[11] = vLine[7];
v[12] = vLine[8];
vLine = v;
}
if (vLine.Length == 13)
{
ProcessCsvLine(vLine, pwStorage, dictGroups);
}
else
{
Debug.Assert(false);
}
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
opt.TextQualifier = char.MinValue;
opt.TrimFields = true;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
string strMapIgnore = Guid.NewGuid().ToString();
string strMapGroup = Guid.NewGuid().ToString();
string strMapTags = Guid.NewGuid().ToString();
string strMapLastMod = Guid.NewGuid().ToString();
string strMapEMail = Guid.NewGuid().ToString();
Dictionary <string, string> dMaps = new Dictionary <string, string>(
StrUtil.CaseIgnoreComparer);
dMaps["title"] = PwDefs.TitleField;
dMaps["type"] = strMapIgnore;
dMaps["username_field"] = strMapIgnore;
dMaps["username"] = PwDefs.UserNameField;
dMaps["password_field"] = strMapIgnore;
dMaps["password"] = PwDefs.PasswordField;
dMaps["url"] = PwDefs.UrlField;
dMaps["category"] = strMapGroup;
dMaps["note"] = PwDefs.NotesField;
dMaps["autofill"] = strMapIgnore;
dMaps["autofillenabled"] = strMapIgnore;
dMaps["last_password_change"] = strMapIgnore;
dMaps["lastmodified"] = strMapLastMod;
dMaps["iban"] = PwDefs.UserNameField;
dMaps["bic"] = "BIC";
dMaps["banking_pin"] = PwDefs.PasswordField;
dMaps["card_number"] = PwDefs.UserNameField;
dMaps["card_holder"] = "Card Holder";
dMaps["card_pin"] = PwDefs.PasswordField;
dMaps["card_verification_code"] = "Verification Code";
dMaps["valid_from"] = "Valid From";
dMaps["valid_thru"] = "Valid To";
dMaps["name"] = PwDefs.UserNameField;
dMaps["firstname"] = PwDefs.UserNameField;
dMaps["street"] = PwDefs.NotesField;
dMaps["houseno"] = PwDefs.NotesField;
dMaps["zip"] = PwDefs.NotesField;
dMaps["city"] = PwDefs.NotesField;
dMaps["mobile_phone"] = PwDefs.NotesField;
dMaps["phone"] = PwDefs.NotesField;
dMaps["email"] = strMapEMail;
dMaps["birthday"] = "Birthday";
dMaps["tags"] = strMapTags;
dMaps["keyword"] = strMapTags;
string[] vNames = csv.ReadLine();
if ((vNames == null) || (vNames.Length == 0))
{
Debug.Assert(false); return;
}
for (int i = 0; i < vNames.Length; ++i)
{
string str = vNames[i];
if (string.IsNullOrEmpty(str))
{
Debug.Assert(false); str = strMapIgnore;
}
else
{
string strMapped = null;
dMaps.TryGetValue(str, out strMapped);
if (string.IsNullOrEmpty(strMapped))
{
Debug.Assert(false);
strMapped = ImportUtil.MapNameToStandardField(str, true);
if (string.IsNullOrEmpty(strMapped))
{
strMapped = PwDefs.NotesField;
}
}
str = strMapped;
}
vNames[i] = str;
}
Dictionary <string, PwGroup> dGroups = new Dictionary <string, PwGroup>();
while (true)
{
string[] v = csv.ReadLine();
if (v == null)
{
break;
}
if (v.Length == 0)
{
continue;
}
PwEntry pe = new PwEntry(true, true);
PwGroup pg = pwStorage.RootGroup;
for (int i = 0; i < v.Length; ++i)
{
string strValue = v[i];
if (string.IsNullOrEmpty(strValue))
{
continue;
}
strValue = strValue.Replace(@"<COMMA>", ",");
strValue = strValue.Replace(@"<-N/L-/>", "\n");
strValue = StrUtil.NormalizeNewLines(strValue, true);
string strName = ((i < vNames.Length) ? vNames[i] : PwDefs.NotesField);
if (strName == strMapIgnore)
{
}
else if (strName == strMapGroup)
{
dGroups.TryGetValue(strValue, out pg);
if (pg == null)
{
pg = new PwGroup(true, true);
pg.Name = strValue;
pwStorage.RootGroup.AddGroup(pg, true);
dGroups[strValue] = pg;
}
}
else if (strName == strMapTags)
{
List <string> lTags = StrUtil.StringToTags(strValue);
foreach (string strTag in lTags)
{
pe.AddTag(strTag);
}
}
else if (strName == strMapLastMod)
{
double dUnix;
if (double.TryParse(strValue, out dUnix))
{
pe.LastModificationTime = TimeUtil.ConvertUnixTime(dUnix);
}
else
{
Debug.Assert(false);
}
}
else if (strName == strMapEMail)
{
ImportUtil.AppendToField(pe, PwDefs.UrlField,
"mailto:" + strValue, pwStorage);
}
else
{
ImportUtil.AppendToField(pe, strName, strValue, pwStorage);
}
}
pg.AddEntry(pe, true);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Default);
string strData = sr.ReadToEnd();
sr.Close();
sInput.Close();
Dictionary<string, PwGroup> dGroups = new Dictionary<string, PwGroup>();
dGroups[string.Empty] = pwStorage.RootGroup;
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
while(true)
{
string[] v = csv.ReadLine();
if(v == null) break;
if(v.Length == 0) continue;
if(v[0].StartsWith("TurboPasswords CSV Export File")) continue;
if(v.Length < 24) { Debug.Assert(false); continue; }
if((v[0] == "Category") && (v[1] == "Type")) continue;
PwEntry pe = new PwEntry(true, true);
PwGroup pg;
string strGroup = v[0];
if(!dGroups.TryGetValue(strGroup, out pg))
{
pg = new PwGroup(true, true, strGroup, PwIcon.Folder);
dGroups[string.Empty].AddGroup(pg, true);
dGroups[strGroup] = pg;
}
pg.AddEntry(pe, true);
string strType = v[1];
for(int f = 0; f < 6; ++f)
{
string strKey = v[2 + (2 * f)];
string strValue = v[2 + (2 * f) + 1];
if(strKey.Length == 0) strKey = PwDefs.NotesField;
if(strValue.Length == 0) continue;
if(strKey == "Description")
strKey = PwDefs.TitleField;
else if(((strType == "Contact") || (strType == "Personal Info")) &&
(strKey == "Name"))
strKey = PwDefs.TitleField;
else if(((strType == "Membership") || (strType == "Insurance")) &&
(strKey == "Company"))
strKey = PwDefs.TitleField;
else if(strKey == "SSN")
strKey = PwDefs.UserNameField;
else
{
string strMapped = ImportUtil.MapNameToStandardField(strKey, false);
if(!string.IsNullOrEmpty(strMapped)) strKey = strMapped;
}
ImportUtil.AppendToField(pe, strKey, strValue, pwStorage,
((strKey == PwDefs.NotesField) ? "\r\n" : ", "), false);
}
ImportUtil.AppendToField(pe, PwDefs.NotesField, v[20], pwStorage,
"\r\n\r\n", false);
if(v[21].Length > 0)
ImportUtil.AppendToField(pe, "Login URL", v[21], pwStorage, null, true);
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Default);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
opt.TextQualifier = char.MaxValue; // No text qualifier
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
PwGroup pg = pwStorage.RootGroup;
char[] vGroupSplit = new char[] { '\\' };
while(true)
{
string[] v = csv.ReadLine();
if(v == null) break;
if(v.Length < 1) continue;
for(int i = 0; i < v.Length; ++i)
v[i] = ParseString(v[i]);
if(v[0].StartsWith("\\")) // Group
{
string strGroup = v[0].Trim(vGroupSplit); // Also from end
if(strGroup.Length > 0)
{
pg = pwStorage.RootGroup.FindCreateSubTree(strGroup,
vGroupSplit);
if(v.Length >= 6) pg.Notes = v[5].Trim();
if((v.Length >= 5) && (v[4].Trim().Length > 0))
{
if(pg.Notes.Length > 0)
pg.Notes += Environment.NewLine + Environment.NewLine;
pg.Notes += v[4].Trim();
}
}
}
else // Entry
{
PwEntry pe = new PwEntry(true, true);
pg.AddEntry(pe, true);
List<string> l = new List<string>(v);
while(l.Count < 8)
{
Debug.Assert(false);
l.Add(string.Empty);
}
ImportUtil.AppendToField(pe, PwDefs.TitleField, l[0], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.UserNameField, l[1], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.PasswordField, l[2], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.UrlField, l[3], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.NotesField, l[4], pwStorage);
if(l[5].Length > 0)
ImportUtil.AppendToField(pe, "Custom 1", l[5], pwStorage);
if(l[6].Length > 0)
ImportUtil.AppendToField(pe, "Custom 2", l[6], pwStorage);
if(l[7].Length > 0)
ImportUtil.AppendToField(pe, "Custom 3", l[7], pwStorage);
}
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Default);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
opt.TextQualifier = char.MaxValue; // No text qualifier
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
PwGroup pg = pwStorage.RootGroup;
char[] vGroupSplit = new char[] { '\\' };
while (true)
{
string[] v = csv.ReadLine();
if (v == null)
{
break;
}
if (v.Length < 1)
{
continue;
}
for (int i = 0; i < v.Length; ++i)
{
v[i] = ParseString(v[i]);
}
if (v[0].StartsWith("\\")) // Group
{
string strGroup = v[0].Trim(vGroupSplit); // Also from end
if (strGroup.Length > 0)
{
pg = pwStorage.RootGroup.FindCreateSubTree(strGroup,
vGroupSplit);
if (v.Length >= 6)
{
pg.Notes = v[5].Trim();
}
if ((v.Length >= 5) && (v[4].Trim().Length > 0))
{
if (pg.Notes.Length > 0)
{
pg.Notes += Environment.NewLine + Environment.NewLine;
}
pg.Notes += v[4].Trim();
}
}
}
else // Entry
{
PwEntry pe = new PwEntry(true, true);
pg.AddEntry(pe, true);
List <string> l = new List <string>(v);
while (l.Count < 8)
{
Debug.Assert(false);
l.Add(string.Empty);
}
ImportUtil.AppendToField(pe, PwDefs.TitleField, l[0], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.UserNameField, l[1], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.PasswordField, l[2], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.UrlField, l[3], pwStorage);
ImportUtil.AppendToField(pe, PwDefs.NotesField, l[4], pwStorage);
if (l[5].Length > 0)
{
ImportUtil.AppendToField(pe, "Custom 1", l[5], pwStorage);
}
if (l[6].Length > 0)
{
ImportUtil.AppendToField(pe, "Custom 2", l[6], pwStorage);
}
if (l[7].Length > 0)
{
ImportUtil.AppendToField(pe, "Custom 3", l[7], pwStorage);
}
}
}
}
private static void ImportCsv(CsvStreamReaderEx csr, PwDatabase pd)
{
CsvTableEntryReader ctr = new CsvTableEntryReader(pd);
const string strColUrl = "url";
Predicate <string[]> fIsSecNote = delegate(string[] vRow)
{
string str = ctr.GetData(vRow, strColUrl, string.Empty);
return(str.Equals("http://sn", StrUtil.CaseIgnoreCmp));
};
ctr.SetDataAppend("name", PwDefs.TitleField);
ctr.SetDataAppend("username", PwDefs.UserNameField);
ctr.SetDataAppend("password", PwDefs.PasswordField);
ctr.SetDataHandler(strColUrl, delegate(string str, PwEntry pe,
string[] vContextRow)
{
if (!fIsSecNote(vContextRow))
{
ImportUtil.AppendToField(pe, PwDefs.UrlField, str, pd);
}
});
ctr.SetDataHandler("extra", delegate(string str, PwEntry pe,
string[] vContextRow)
{
if (fIsSecNote(vContextRow) && str.StartsWith("NoteType:",
StrUtil.CaseIgnoreCmp))
{
AddNoteFields(pe, str, pd);
return;
}
ImportUtil.AppendToField(pe, PwDefs.NotesField, str, pd);
});
ctr.SetDataHandler("grouping", delegate(string str, PwEntry pe,
string[] vContextRow)
{
if (str.Length == 0)
{
return;
}
PwGroup pg = pd.RootGroup.FindCreateSubTree(str,
new string[1] {
"\\"
}, true);
pg.AddEntry(pe, true);
});
ctr.SetDataHandler("fav", delegate(string str, PwEntry pe,
string[] vContextRow)
{
if (StrUtil.StringToBool(str))
{
pe.AddTag(PwDefs.FavoriteTag);
}
});
ctr.Read(csr);
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions opt = new CsvOptions();
opt.BackslashIsEscape = false;
opt.TrimFields = true;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
string[] vNames = csv.ReadLine();
if ((vNames == null) || (vNames.Length == 0))
{
Debug.Assert(false); return;
}
for (int i = 0; i < vNames.Length; ++i)
{
vNames[i] = (vNames[i] ?? string.Empty).ToLowerInvariant();
}
while (true)
{
string[] v = csv.ReadLine();
if (v == null)
{
break;
}
if (v.Length == 0)
{
continue;
}
PwEntry pe = new PwEntry(true, true);
pwStorage.RootGroup.AddEntry(pe, true);
Debug.Assert(v.Length == vNames.Length);
int m = Math.Min(v.Length, vNames.Length);
for (int i = 0; i < m; ++i)
{
string strValue = v[i];
if (string.IsNullOrEmpty(strValue))
{
continue;
}
string strName = vNames[i];
string strTo = null;
DateTime?odt;
switch (strName)
{
case "autologin":
case "protectedwithpassword":
case "subdomainonly":
case "type":
case "tk_export_version":
break; // Ignore
case "kind":
if (strValue.Equals("note", StrUtil.CaseIgnoreCmp))
{
pe.IconId = PwIcon.Note;
}
else if (strValue.Equals("identity", StrUtil.CaseIgnoreCmp) ||
strValue.Equals("drivers", StrUtil.CaseIgnoreCmp) ||
strValue.Equals("passport", StrUtil.CaseIgnoreCmp) ||
strValue.Equals("ssn", StrUtil.CaseIgnoreCmp))
{
pe.IconId = PwIcon.Identity;
}
else if (strValue.Equals("cc", StrUtil.CaseIgnoreCmp))
{
pe.IconId = PwIcon.Money;
}
else if (strValue.Equals("membership", StrUtil.CaseIgnoreCmp))
{
pe.IconId = PwIcon.UserKey;
}
break;
case "name":
case "title":
strTo = PwDefs.TitleField;
break;
case "cardholder":
case "email":
case "login":
strTo = PwDefs.UserNameField;
break;
case "password":
strTo = PwDefs.PasswordField;
break;
case "url":
case "website":
strTo = PwDefs.UrlField;
break;
case "document_content":
case "memo":
case "note":
strTo = PwDefs.NotesField;
break;
case "city":
case "company":
case "country":
case "number":
case "state":
case "street":
case "telephone":
strTo = (new string(char.ToUpperInvariant(strName[0]), 1)) +
strName.Substring(1);
break;
case "deliveryplace":
strTo = "Delivery Place";
break;
case "firstname":
strTo = "First Name";
break;
case "lastname":
strTo = "Last Name";
break;
case "memberid":
strTo = "Member ID";
break;
case "phonenumber":
strTo = "Phone Number";
break;
case "streetnumber":
strTo = "Street Number";
break;
case "zipcode":
strTo = "ZIP Code";
break;
case "dateofbirth":
strTo = "Date of Birth";
strValue = DateToString(strValue);
break;
case "expirationdate":
case "expirydate":
odt = ParseTime(strValue);
if (odt.HasValue)
{
pe.Expires = true;
pe.ExpiryTime = odt.Value;
}
break;
case "favorite":
if (StrUtil.StringToBoolEx(strValue).GetValueOrDefault(false))
{
pe.AddTag("Favorite");
}
break;
case "gender":
if ((strValue == "0") || (strValue == "1"))
{
strTo = "Gender";
strValue = ((strValue == "0") ? "Male" : "Female");
}
else
{
Debug.Assert(false);
}
break;
case "hexcolor":
if ((strValue.Length == 6) && StrUtil.IsHexString(strValue, true))
{
Color c = Color.FromArgb(unchecked ((int)(0xFF000000U |
Convert.ToUInt32(strValue, 16))));
Color cG = UIUtil.ColorToGrayscale(c);
if (cG.B < 128)
{
c = UIUtil.LightenColor(c, 0.5);
}
pe.BackgroundColor = c;
}
else
{
Debug.Assert(false);
}
break;
case "issuedate":
case "issueddate":
strTo = "Issue Date";
strValue = DateToString(strValue);
break;
case "membersince":
strTo = "Member Since";
strValue = DateToString(strValue);
break;
default:
Debug.Assert(false); // Unknown field
break;
}
if (!string.IsNullOrEmpty(strTo))
{
ImportUtil.AppendToField(pe, strTo, strValue, pwStorage);
}
}
}
}
private bool GuessFieldTypes()
{
CsvOptions opt = GetCsvOptions();
if (opt == null)
{
Debug.Assert(false); return(false);
}
string strData = GetDecodedText();
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, opt);
string[] v;
while (true)
{
v = csv.ReadLine();
if (v == null)
{
return(false);
}
if (v.Length == 0)
{
continue;
}
if ((v.Length == 1) && (v[0].Length == 0))
{
continue;
}
break;
}
if (v.Length <= 3)
{
return(false);
}
CsvFieldInfo[] vFields = new CsvFieldInfo[v.Length];
int nDetermined = 0;
for (int i = 0; i < v.Length; ++i)
{
CsvFieldInfo fi = GuessFieldType(v[i]);
if (fi != null)
{
++nDetermined;
}
else
{
fi = new CsvFieldInfo(CsvFieldType.Ignore, null, null);
}
vFields[i] = fi;
}
// Accept the guesses only if at least half of them are
// probably correct
if (nDetermined < (v.Length + 1) / 2)
{
return(false);
}
m_lvFields.Items.Clear();
foreach (CsvFieldInfo fi in vFields)
{
AddCsvField(fi.Type, fi.Name, fi.Format);
}
return(true);
}
private void PerformImport(PwGroup pgStorage, bool bCreatePreview)
{
List <CsvFieldInfo> lFields = GetCsvFieldInfos();
if (bCreatePreview)
{
int dx = m_lvImportPreview.ClientRectangle.Width; // Before clearing
m_lvImportPreview.Items.Clear();
m_lvImportPreview.Columns.Clear();
foreach (CsvFieldInfo cfi in lFields)
{
string strCol = CsvFieldToString(cfi.Type);
if (cfi.Type == CsvFieldType.CustomString)
{
strCol = (cfi.Name ?? string.Empty);
}
m_lvImportPreview.Columns.Add(strCol, dx / lFields.Count);
}
}
CsvOptions opt = GetCsvOptions();
if (opt == null)
{
Debug.Assert(bCreatePreview); return;
}
string strData = GetDecodedText();
CsvStreamReaderEx csr = new CsvStreamReaderEx(strData, opt);
Dictionary <string, PwGroup> dGroups = new Dictionary <string, PwGroup>();
dGroups[string.Empty] = pgStorage;
if (bCreatePreview)
{
m_lvImportPreview.BeginUpdate();
}
DateTime dtNow = DateTime.UtcNow;
DateTime dtNoExpire = KdbTime.NeverExpireTime.ToDateTime();
bool bIgnoreFirstRow = m_cbIgnoreFirst.Checked;
bool bIsFirstRow = true;
bool bMergeGroups = m_cbMergeGroups.Checked;
while (true)
{
string[] v = csr.ReadLine();
if (v == null)
{
break;
}
if (v.Length == 0)
{
continue;
}
if ((v.Length == 1) && (v[0].Length == 0))
{
continue;
}
if (bIsFirstRow && bIgnoreFirstRow)
{
bIsFirstRow = false;
continue;
}
bIsFirstRow = false;
PwGroup pg = pgStorage;
PwEntry pe = new PwEntry(true, true);
ListViewItem lvi = null;
for (int i = 0; i < Math.Min(v.Length, lFields.Count); ++i)
{
string strField = v[i];
CsvFieldInfo cfi = lFields[i];
if (cfi.Type == CsvFieldType.Ignore)
{
}
else if (cfi.Type == CsvFieldType.Group)
{
pg = FindCreateGroup(strField, pgStorage, dGroups,
cfi.Format, opt, bMergeGroups);
}
else if (cfi.Type == CsvFieldType.Title)
{
ImportUtil.AppendToField(pe, PwDefs.TitleField,
strField, m_pwDatabase);
}
else if (cfi.Type == CsvFieldType.UserName)
{
ImportUtil.AppendToField(pe, PwDefs.UserNameField,
strField, m_pwDatabase);
}
else if (cfi.Type == CsvFieldType.Password)
{
ImportUtil.AppendToField(pe, PwDefs.PasswordField,
strField, m_pwDatabase);
}
else if (cfi.Type == CsvFieldType.Url)
{
ImportUtil.AppendToField(pe, PwDefs.UrlField,
strField, m_pwDatabase);
}
else if (cfi.Type == CsvFieldType.Notes)
{
ImportUtil.AppendToField(pe, PwDefs.NotesField,
strField, m_pwDatabase);
}
else if (cfi.Type == CsvFieldType.CustomString)
{
ImportUtil.AppendToField(pe, (string.IsNullOrEmpty(cfi.Name) ?
PwDefs.NotesField : cfi.Name), strField, m_pwDatabase);
}
else if (cfi.Type == CsvFieldType.CreationTime)
{
pe.CreationTime = ParseDateTime(ref strField, cfi, dtNow);
}
// else if(cfi.Type == CsvFieldType.LastAccessTime)
// pe.LastAccessTime = ParseDateTime(ref strField, cfi, dtNow);
else if (cfi.Type == CsvFieldType.LastModTime)
{
pe.LastModificationTime = ParseDateTime(ref strField, cfi, dtNow);
}
else if (cfi.Type == CsvFieldType.ExpiryTime)
{
bool bParseSuccess;
pe.ExpiryTime = ParseDateTime(ref strField, cfi, dtNow,
out bParseSuccess);
pe.Expires = (bParseSuccess && (pe.ExpiryTime != dtNoExpire));
}
else if (cfi.Type == CsvFieldType.Tags)
{
StrUtil.AddTags(pe.Tags, StrUtil.StringToTags(strField));
}
else
{
Debug.Assert(false);
}
if (bCreatePreview)
{
strField = StrUtil.MultiToSingleLine(strField);
if (lvi != null)
{
lvi.SubItems.Add(strField);
}
else
{
lvi = m_lvImportPreview.Items.Add(strField);
}
}
}
if (bCreatePreview)
{
// Create remaining subitems
for (int r = v.Length; r < lFields.Count; ++r)
{
if (lvi != null)
{
lvi.SubItems.Add(string.Empty);
}
else
{
lvi = m_lvImportPreview.Items.Add(string.Empty);
}
}
}
pg.AddEntry(pe, true);
}
if (bCreatePreview)
{
m_lvImportPreview.EndUpdate();
ProcessResize();
}
}
public override void Import(PwDatabase pwStorage, Stream sInput,
IStatusLogger slLogger)
{
StreamReader sr = new StreamReader(sInput, Encoding.Default, true);
string strData = sr.ReadToEnd();
sr.Close();
CsvOptions o = new CsvOptions();
o.BackslashIsEscape = false;
CsvStreamReaderEx csv = new CsvStreamReaderEx(strData, o);
SortedDictionary<string, PwGroup> dictGroups =
new SortedDictionary<string, PwGroup>();
while(true)
{
string[] vLine = csv.ReadLine();
if(vLine == null) break;
if(vLine.Length == 0) continue;
if(vLine.Length == 1)
{
Debug.Assert(vLine[0] == StrHeader);
continue;
}
// Support old version 3.4
if(vLine.Length == 9)
{
string[] v = new string[13];
for(int i = 0; i < 7; ++i) v[i] = vLine[i];
for(int i = 7; i < 11; ++i) v[i] = string.Empty;
v[11] = vLine[7];
v[12] = vLine[8];
vLine = v;
}
if(vLine.Length == 13)
ProcessCsvLine(vLine, pwStorage, dictGroups);
else { Debug.Assert(false); }
}
}
