static void p5_crypto_get_key_details(ApplicationContext context, ActiveEventArgs e)
{
// Using common helper to iterate all secret keys.
ObjectIterator.MatchingPublicKeys(context, e.Args, delegate(PgpPublicKey key) {
// This key is matching specified filter criteria.
var fingerprint = BitConverter.ToString(key.GetFingerprint()).Replace("-", "").ToLower();
var node = e.Args.Add(fingerprint).LastChild;
node.Add("id", ((int)key.KeyId).ToString("X"));
node.Add("algorithm", key.Algorithm.ToString());
node.Add("strength", key.BitStrength);
node.Add("creation-time", key.CreationTime);
node.Add("is-encryption-key", key.IsEncryptionKey);
node.Add("is-master-key", key.IsMasterKey);
node.Add("is-revoked", key.IsRevoked());
node.Add("version", key.Version);
DateTime expires = key.CreationTime.AddSeconds(key.GetValidSeconds());
node.Add("expires", expires);
foreach (var idxUserId in key.GetUserIds())
{
if (idxUserId is string)
{
node.FindOrInsert("user-ids").Add("", idxUserId);
}
}
foreach (PgpSignature signature in key.GetSignatures())
{
node.FindOrInsert("signed-by").Add(((int)signature.KeyId).ToString("X"), signature.CreationTime);
}
}, false);
}
public static void _p5_io_file_serialize_to_stream(ApplicationContext context, ActiveEventArgs e)
{
// Retrieving stream argument.
var tuple = e.Args.Value as Tuple <object, Stream>;
e.Args.Value = tuple.Item1;
var output = tuple.Item2;
// Iterating through files specified.
ObjectIterator.Iterate(
context,
e.Args,
true,
"read-file",
delegate(string filename, string fullpath) {
if (File.Exists(fullpath))
{
// Serializing file into stream.
using (FileStream stream = File.OpenRead(fullpath)) {
stream.CopyTo(output);
}
}
else
{
// Oops, file didn't exist.
throw new LambdaException(
string.Format("Couldn't find file '{0}'", filename),
e.Args,
context);
}
});
}
public static Object object_iterator_item(ObjectIterator p0)
{
global::System.IntPtr cPtr = storj_uplinkPINVOKE.object_iterator_item(ObjectIterator.getCPtr(p0));
Object ret = (cPtr == global::System.IntPtr.Zero) ? null : new Object(cPtr, false);
return(ret);
}
public static Error object_iterator_err(ObjectIterator p0)
{
global::System.IntPtr cPtr = storj_uplinkPINVOKE.object_iterator_err(ObjectIterator.getCPtr(p0));
Error ret = (cPtr == global::System.IntPtr.Zero) ? null : new Error(cPtr, false);
return(ret);
}
public static void p5_io_folder_list_files(ApplicationContext context, ActiveEventArgs e)
{
// Getting root folder
var rootFolder = Common.GetRootFolder(context);
// Checking if we've got a filter
string filter = e.Args.GetExChildValue("filter", context, "") ?? "";
bool showAll = e.Args.GetExChildValue("show-all", context, false);
ObjectIterator.Iterate(context, e.Args, true, "read-folder", delegate(string foldername, string fullpath) {
foreach (var idxFile in Directory.GetFiles(fullpath))
{
if (filter == "" || MatchFilter(idxFile, filter))
{
// Notice, unless [show-all] is true, we explicitly remove all files starting with a "." as a part of their filename.
if (!showAll && Path.GetFileName(idxFile).StartsWithEx("."))
{
continue;
}
var fileName = idxFile.Replace("\\", "/");
fileName = fileName.Replace(rootFolder, "");
e.Args.Add(fileName);
}
}
});
}
public static void p5_io_file_delete(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(
context,
e.Args,
true,
"modify-file",
delegate(string filename, string fullpath) {
if (File.Exists(fullpath))
{
// File exists, deleting it, but first making sure it's not read only.
// Notice, Linux and Mac allows a read only file to be deleted, so even though .Net on Windows takes care
// of this automatically for us, we'll need this check in here, to have *nix and Windows systems to behave similarly.
if (new FileInfo(fullpath).IsReadOnly)
{
throw new LambdaException(
string.Format("[delete-file] tried to delete a read only file called; '{0}'", filename),
e.Args,
context);
}
File.Delete(fullpath);
}
else
{
// Oops, file didn't exist, throwing an exception.
throw new LambdaException(
string.Format("[delete-file] tried to delete non-existing file '{0}'", filename),
e.Args,
context);
}
});
}
public static ObjectIterator list_objects(Project p0, string p1, ListObjectsOptions p2)
{
global::System.IntPtr cPtr = storj_uplinkPINVOKE.list_objects(Project.getCPtr(p0), p1, ListObjectsOptions.getCPtr(p2));
ObjectIterator ret = (cPtr == global::System.IntPtr.Zero) ? null : new ObjectIterator(cPtr, false);
return(ret);
}
public static void p5_io_file_load(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(
context,
e.Args,
true,
"read-file",
delegate(string filename, string fullpath) {
if (File.Exists(fullpath))
{
// Text files and binary files are loaded differently.
// Text file might for instance be converted automatically.
if (IsTextFile(filename))
{
LoadTextFile(context, e.Args, fullpath, filename);
}
else
{
LoadBinaryFile(e.Args, fullpath, filename);
}
}
else
{
// Oops, file didn't exist.
throw new LambdaException(
string.Format("Couldn't find file '{0}'", filename),
e.Args,
context);
}
});
}
static void p5_crypto_list_public_keys(ApplicationContext context, ActiveEventArgs e)
{
// Using common helper to iterate all secret keys.
ObjectIterator.MatchingPublicKeys(context, e.Args, delegate(PgpPublicKey key) {
// Retrieving fingerprint of currently iterated key, and returning to caller.
var fingerprint = BitConverter.ToString(key.GetFingerprint()).Replace("-", "").ToLower();
e.Args.Add(fingerprint);
}, false);
}
public static void p5_io_folder_create(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "modify-folder", delegate(string foldername, string fullpath) {
if (Directory.Exists(fullpath))
{
throw new LambdaException(string.Format("Folder '{0}' exist from before", foldername), e.Args, context);
}
Directory.CreateDirectory(fullpath);
});
}
public static void p5_io_folder_delete(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "modify-folder", delegate(string foldername, string fullpath) {
if (Directory.Exists(fullpath))
{
Directory.Delete(fullpath, true);
}
else
{
throw new LambdaException(string.Format("Tried to delete non-existing folder - '{0}'", foldername), e.Args, context);
}
});
}
public static void p5_io_folder_list_folders(ApplicationContext context, ActiveEventArgs e)
{
// Getting root folder
var rootFolder = Common.GetRootFolder(context);
ObjectIterator.Iterate(context, e.Args, true, "read-folder", delegate(string foldername, string fullpath) {
foreach (var idxFolder in Directory.GetDirectories(rootFolder + foldername))
{
var folderName = idxFolder.Replace("\\", "/");
folderName = folderName.Replace(rootFolder, "");
e.Args.Add(folderName.TrimEnd('/') + "/");
}
});
}
static void p5_crypto_delete_public_key(ApplicationContext context, ActiveEventArgs e)
{
// House cleaning
using (new ArgsRemover(e.Args, true)) {
// Creating new GnuPG context
using (var ctx = new GnuPrivacyContext(true)) {
// Signaler boolean
bool somethingWasRemoved = false;
var bundle = ctx.PublicKeyRingBundle;
// Looping through each ID given by caller
foreach (var idxId in XUtil.Iterate <string> (context, e.Args))
{
// Looping through each public key ring in GnuPG database until we find given ID
foreach (PgpPublicKeyRing idxPublicKeyRing in bundle.GetKeyRings())
{
// Looping through each key in keyring
foreach (PgpPublicKey idxPublicKey in idxPublicKeyRing.GetPublicKeys())
{
// Checking for a match, making sure we do not match UserIDs.
if (ObjectIterator.IsMatch(idxPublicKey, idxId, false))
{
// Removing entire keyring, and signaling to save keyring bundle
somethingWasRemoved = true;
bundle = PgpPublicKeyRingBundle.RemovePublicKeyRing(bundle, idxPublicKeyRing);
// Breaking inner most foreach
break;
}
}
// Checking if currently iterated filter was found in currently iterated secret keyring.
if (somethingWasRemoved)
{
break;
}
}
}
// Checking to see if something was removed, and if so, saving GnuPG context
if (somethingWasRemoved)
{
ctx.SavePublicKeyRingBundle(bundle);
}
}
}
}
public static void p5_io_folder_list_files(ApplicationContext context, ActiveEventArgs e)
{
// Getting root folder
var rootFolder = Common.GetRootFolder(context);
// Checking if we've got a filter
string filter = e.Args.GetExChildValue("filter", context, "") ?? "";
ObjectIterator.Iterate(context, e.Args, true, "read-folder", delegate(string foldername, string fullpath) {
foreach (var idxFile in Directory.GetFiles(fullpath))
{
if (filter == "" || MatchFilter(idxFile, filter))
{
var fileName = idxFile.Replace("\\", "/");
fileName = fileName.Replace(rootFolder, "");
e.Args.Add(fileName);
}
}
});
}
static void p5_crypto_get_private_key(ApplicationContext context, ActiveEventArgs e)
{
// Using common helper to iterate all secret keys.
ObjectIterator.MatchingPrivateKeys(context, e.Args, delegate(PgpSecretKey key) {
// Retrieving fingerprint of currently iterated key, and returning to caller.
var fingerprint = BitConverter.ToString(key.PublicKey.GetFingerprint()).Replace("-", "").ToLower();
var node = e.Args.Add(fingerprint).LastChild;
// This is the key we're looking for
using (var memStream = new MemoryStream()) {
using (var armored = new ArmoredOutputStream(memStream)) {
key.Encode(armored);
armored.Flush();
}
memStream.Flush();
memStream.Position = 0;
var sr = new StreamReader(memStream);
node.Value = sr.ReadToEnd();
}
}, false);
}
public static void p5_io_folder_exists(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "read-folder", delegate(string foldername, string fullpath) {
e.Args.Add(foldername, Directory.Exists(fullpath));
});
}
public static void p5_io_file_get_last_write_time(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "read-file", delegate(string filename, string fullpath) {
e.Args.Add(filename, new FileInfo(fullpath).LastWriteTime);
});
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ObjectIterator obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public static void p5_io_folder_get_length(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "read-file", delegate(string filename, string fullpath) {
e.Args.Add(filename, FolderSize(new DirectoryInfo(fullpath)));
});
}
public static void p5_io_file_read_only_set_delete(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "modify-file", delegate(string filename, string fullpath) {
new FileInfo(fullpath).IsReadOnly = e.Name == "p5.io.file.read-only.set" || e.Name == "p5.io.folder.read-only.set";
});
}
public static void p5_io_file_read_only_get(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "read-file", delegate(string filename, string fullpath) {
e.Args.Add(filename, new FileInfo(fullpath).IsReadOnly);
});
}
public static void free_object_iterator(ObjectIterator p0)
{
storj_uplinkPINVOKE.free_object_iterator(ObjectIterator.getCPtr(p0));
}
static void p5_crypto_sign_public_key(ApplicationContext context, ActiveEventArgs e)
{
// Figuring out which private key to use for signing, and doing some basic sanity check.
var fingerprint = e.Args.GetExChildValue("private-key", context, "").ToLower();
if (fingerprint == "")
{
throw new LambdaException("No [private-key] argument supplied to [p5.crypto.sign-public-key]", e.Args, context);
}
// Finding password to use to extract private key from GnuPG context, and doing some basic sanity check.
var password = e.Args.GetExChildValue("password", context, "");
if (password == "")
{
throw new LambdaException("No [password] argument supplied to [p5.crypto.sign-public-key] to extract your private key", e.Args, context);
}
// Retrieving our private key to use for signing public key from GnuPG database.
// Finding password to use to extract private key from GnuPG context, and doing some basic sanity check.
var certain = e.Args.GetExChildValue("certain", context, false);
PgpSecretKey signingKey = null;
using (var ctx = new GnuPrivacyContext(false)) {
// Iterating all secret keyrings.
foreach (PgpSecretKeyRing idxRing in ctx.SecretKeyRingBundle.GetKeyRings())
{
// Iterating all keys in currently iterated secret keyring.
foreach (PgpSecretKey idxSecretKey in idxRing.GetSecretKeys())
{
// Checking if caller provided filters, and if not, yielding "everything".
if (BitConverter.ToString(idxSecretKey.PublicKey.GetFingerprint()).Replace("-", "").ToLower() == fingerprint)
{
// No filters provided, matching everything.
signingKey = idxSecretKey;
break;
}
}
if (signingKey != null)
{
break;
}
}
}
// Using common helper to iterate all public keys caller wants to sign.
PgpPublicKeyRing sRing = null;
ObjectIterator.MatchingPublicKeys(context, e.Args, delegate(PgpPublicKey idxKey) {
// Retrieving fingerprint of currently iterated key, and returning to caller.
var node = e.Args.Add(BitConverter.ToString(idxKey.GetFingerprint()).Replace("-", "").ToLower()).LastChild;
// Doing the actual signing of currently iterated public key.
sRing = new PgpPublicKeyRing(new MemoryStream(SignPublicKey(signingKey, password, idxKey, certain), false));
}, false);
// Creating new GnuPG context and importing signed key into context.
using (var ctx = new GnuPrivacyContext(true)) {
// Importing signed key.
ctx.Import(sRing);
}
}
public static bool object_iterator_next(ObjectIterator p0)
{
bool ret = storj_uplinkPINVOKE.object_iterator_next(ObjectIterator.getCPtr(p0));
return(ret);
}
public static void p5_io_file_exists(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "read-file", delegate(string filename, string fullpath) {
e.Args.Add(filename, File.Exists(fullpath));
});
}
private IValue ExpectingForeachObjectExpression(ObjectNode context, TokenTypes terminators, ObjectIterator rvalue, int depth = 0)
{
// do we need the context?
var x = rvalue.Template.Count == 0 ? NextAfter(WhiteSpaceOrComments) : NextAfter(Comments);
/*
* switch(rvalue.Template.Count == 0 ? NextAfter(WhiteSpaceOrComments) : NextAfter(Comments)) {
* case TokenType.Lambda:
* // can't chain foreach object expressions.
* throw Fail(ErrorCode.TokenNotExpected, "Object ForEach Expressions can not be nested.");
* }
*/
if (depth == 0)
{
if (terminators.Contains(Type))
{
// we got to the end. finish up the expression and return it as the rvalue;
return(rvalue);
}
}
switch (Type)
{
case TokenType.OpenBrace:
depth++;
break;
case TokenType.CloseBrace:
depth--;
break;
}
rvalue.Template.Add(Token);
return(ExpectingForeachObjectExpression(context, terminators, rvalue, depth));
}
public static void p5_io_folder_get_last_access_time(ApplicationContext context, ActiveEventArgs e)
{
ObjectIterator.Iterate(context, e.Args, true, "read-file", delegate(string filename, string fullpath) {
e.Args.Add(filename, new DirectoryInfo(fullpath).LastAccessTime);
});
}
