public List <string> GetDataDirectoriesWithEngine(string engine)
{
var list = DataDirectories.ToList();
list.Add(GetEngineFolderByVersion(engine));
return(list);
}
public DbMigrationsHostedService(InvoiceRepository invoiceRepository, SettingsRepository settingsRepository, ApplicationDbContextFactory dbContextFactory, DataDirectories datadirs)
{
_invoiceRepository = invoiceRepository;
_settingsRepository = settingsRepository;
_dbContextFactory = dbContextFactory;
_datadirs = datadirs;
}
public void WhenNull_Create_ThrowsException()
{
byte[] data = null;
DataDirectories directoryToInstantiate = DataDirectories.CertificateTable;
Assert.Throws <NullReferenceException>(delegate()
{
new DataDirectory(data, directoryToInstantiate);
});
}
protected void ExtractDataDirectories(IntPtr headerAt)
{
int offset = DataDirectoryOffset;
for (int index = 0; index < DirectoryEntriesCount; index++)
{
DataDirectories.Add(new DataDirectory((DataDirectoryKind)index, headerAt, ref offset));
}
return;
}
public void WhenIncorrectDataSize_Create_ThrowsException()
{
byte[] data = new byte[3];
DataDirectories directoryToInstantiate = DataDirectories.CertificateTable;
Assert.Throws <ArgumentException>(delegate()
{
new DataDirectory(data, directoryToInstantiate);
});
}
public PluginService(IEnumerable <IBTCPayServerPlugin> btcPayServerPlugins,
IHttpClientFactory httpClientFactory, DataDirectories datadirs, BTCPayServerOptions options, IEnumerable <IPluginHookAction> actions, IEnumerable <IPluginHookFilter> filters)
{
LoadedPlugins = btcPayServerPlugins;
_githubClient = httpClientFactory.CreateClient();
_githubClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("btcpayserver", "1"));
_datadirs = datadirs;
_options = options;
_actions = actions;
_filters = filters;
}
public void WhenVirtualAddressAndSizeAreNonZero_IsUsed_IsTrue()
{
byte[] data =
{
1, 0, 0, 0,
1, 0, 0, 0
};
DataDirectories directoryToInstantiate = DataDirectories.CertificateTable;
DataDirectory directory = new DataDirectory(data, directoryToInstantiate);
Assert.IsTrue(directory.IsUsed);
}
private static Table PrepareOptionalHeaderDataDirectories(DataDirectories dataDirectories)
{
var directoryNames = new[]
{
"Export Table", "Import Table", "Resource Table", "Exception Table",
"Certificate Table", "Base Relocation Table", "Debug", "Architecture",
"Global Ptr", "TLS Table", "Load Config Table", "Bound Import",
"IAT", "Delay Import Descriptor", "CLR Runtime Header", "Reserved"
};
return(new Table("Optional Header - Data Directories",
dataDirectories.Select((dd, i) => new Table(directoryNames.ElementAtOrDefault(i) ?? "Unknown", dd))));
}
/// <include file='..\..\code-documentation\core.pe.xml' path='docs/datadirectory/member[@name="ctor"]/*' />
public DataDirectory(byte[] data, DataDirectories directory)
{
if (data.Length < SizeInBytes)
{
throw new ArgumentException("Not enough byte data supplied to populate DataDirectory");
}
Offset offset = 0;
_directory = directory;
_virtualAddress = BitConverter.ToUInt32(data, offset.Shift(4));
_size = BitConverter.ToUInt32(data, offset.Shift(4));
}
public void WhenValid_Created_Correctly()
{
byte[] data =
{
1, 0, 0, 0,
1, 0, 0, 0
};
DataDirectories directoryToInstantiate = DataDirectories.CertificateTable;
DataDirectory directory = new DataDirectory(data, directoryToInstantiate);
Assert.AreEqual(1, directory.VirtualAddress);
Assert.AreEqual(1, directory.Size);
}
public void Database_Create_GetsCreated()
{
// Arrange
var exampleFile = "CreateFileTest.db";
var databaseFileHandler = new DatabaseFileHandler(exampleFile);
databaseFileHandler.DeleteDatabaseIfExists();
// Act && Assert
var fullexampleFile = Path.Combine(DataDirectories.GetUserApplicationDatabasesDirectory(), exampleFile);
Assert.DoesNotThrow(() => databaseFileHandler.CreateNewDatabase());
Assert.That(File.Exists(fullexampleFile));
databaseFileHandler.DeleteDatabaseIfExists();
}
public static void UseProviderStorage(this IApplicationBuilder builder, DataDirectories datadirs)
{
try
{
DirectoryInfo dirInfo;
if (!Directory.Exists(datadirs.StorageDir))
{
dirInfo = Directory.CreateDirectory(datadirs.StorageDir);
}
else
{
dirInfo = new DirectoryInfo(datadirs.StorageDir);
}
DirectoryInfo tmpdirInfo;
if (!Directory.Exists(datadirs.TempStorageDir))
{
tmpdirInfo = Directory.CreateDirectory(datadirs.TempStorageDir);
}
else
{
tmpdirInfo = new DirectoryInfo(datadirs.TempStorageDir);
}
builder.UseStaticFiles(new StaticFileOptions()
{
ServeUnknownFileTypes = true,
RequestPath = new PathString($"/{FileSystemFileProviderService.LocalStorageDirectoryName}"),
FileProvider = new PhysicalFileProvider(dirInfo.FullName),
OnPrepareResponse = HandleStaticFileResponse()
});
builder.UseStaticFiles(new StaticFileOptions()
{
ServeUnknownFileTypes = true,
RequestPath = new PathString($"/{FileSystemFileProviderService.LocalStorageDirectoryName}tmp"),
FileProvider = new TemporaryLocalFileProvider(tmpdirInfo, dirInfo,
builder.ApplicationServices.GetService <StoredFileRepository>()),
OnPrepareResponse = HandleStaticFileResponse()
});
}
catch (Exception e)
{
Logs.Utils.LogError(e, $"Could not initialize the Local File Storage system(uploading and storing files locally)");
}
}
/// <summary>
/// Factory method for instantiating different directories from the file
/// </summary>
/// <param name="directory">The type of directory to create</param>
/// <param name="fileContents">The contents of the file being read</param>
/// <param name="address">The address of the directory</param>
/// <returns></returns>
public static Directory Create(DataDirectories directory, byte[] fileContents, uint address)
{
Directory createdDirectory = null;
switch (directory)
{
case DataDirectories.CommonLanguageRuntimeHeader:
createdDirectory = new CLRDirectory(fileContents, address);
break;
default:
createdDirectory = new Directory();
break;
}
createdDirectory.Name = directory.ToString();
return(createdDirectory);
}
public void Configure(
IApplicationBuilder app,
IWebHostEnvironment env,
IServiceProvider prov,
BTCPayServerOptions options,
DataDirectories dataDirectories,
ILoggerFactory loggerFactory)
{
Logs.Configuration.LogInformation($"Root Path: {options.RootPath}");
if (options.RootPath.Equals("/", StringComparison.OrdinalIgnoreCase))
{
ConfigureCore(app, env, prov, loggerFactory, dataDirectories);
}
else
{
app.Map(options.RootPath, appChild =>
{
ConfigureCore(appChild, env, prov, loggerFactory, dataDirectories);
});
}
}
private void BuildNodesForDirectory(DataDirectories type, Directory directory, Entry parent)
{
switch (type)
{
case DataDirectories.CommonLanguageRuntimeHeader:
CLRDirectory clrDirectory = directory as CLRDirectory;
MetadataDirectory metadataDirectory = clrDirectory.Metadata;
// Metadata
Entry metadataEntry = new Entry("Metadata");
parent.Children.Add(metadataEntry);
// Streams
Entry streamsEntry = new Entry("Streams");
foreach (KeyValuePair <Streams, Stream> currentStream in metadataDirectory.Streams)
{
Entry streamEntry = new Entry(currentStream.Value.Name);
streamsEntry.Children.Add(streamEntry);
}
parent.Children.Add(streamsEntry);
break;
}
}
public void Database_Create_ConnectionCouldBeEstablished()
{
// Arrange
var exampleFile = "ConnectionAfterCreateTest.db";
var databaseFileHandler = new DatabaseFileHandler(exampleFile);
databaseFileHandler.DeleteDatabaseIfExists();
// Act && Assert
var fullexampleFile = Path.Combine(DataDirectories.GetUserApplicationDatabasesDirectory(), exampleFile);
Assert.DoesNotThrow(() => databaseFileHandler.CreateNewDatabase());
var fileWasCreated = File.Exists(fullexampleFile);
var connectionWasOpened = false;
using (var connection = databaseFileHandler.OpenConnection())
{
connectionWasOpened = connection.State == ConnectionState.Open;
}
Assert.That(fileWasCreated);
Assert.That(connectionWasOpened);
databaseFileHandler.DeleteDatabaseIfExists();
}
public FileSystemFileProviderService(DataDirectories datadirs)
{
_datadirs = datadirs;
}
private static void ConfigureCore(IApplicationBuilder app, IWebHostEnvironment env, IServiceProvider prov, ILoggerFactory loggerFactory, DataDirectories dataDirectories)
{
Logs.Configure(loggerFactory);
app.UsePlugins();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHeadersOverride();
var forwardingOptions = new ForwardedHeadersOptions()
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
};
forwardingOptions.KnownNetworks.Clear();
forwardingOptions.KnownProxies.Clear();
forwardingOptions.ForwardedHeaders = ForwardedHeaders.All;
app.UseForwardedHeaders(forwardingOptions);
app.UseStatusCodePagesWithReExecute("/Error/Handle", "?statusCode={0}");
app.UsePayServer();
app.UseRouting();
app.UseCors();
app.UseStaticFiles(new StaticFileOptions
{
OnPrepareResponse = ctx =>
{
// Cache static assets for one year, set asp-append-version="true" on references to update on change.
// https://andrewlock.net/adding-cache-control-headers-to-static-files-in-asp-net-core/
const int durationInSeconds = 60 * 60 * 24 * 365;
ctx.Context.Response.Headers[HeaderNames.CacheControl] = "public,max-age=" + durationInSeconds;
}
});
app.UseProviderStorage(dataDirectories);
app.UseAuthentication();
app.UseAuthorization();
app.UseSession();
app.UseWebSockets();
app.UseEndpoints(endpoints =>
{
AppHub.Register(endpoints);
PaymentRequestHub.Register(endpoints);
endpoints.MapControllers();
endpoints.MapControllerRoute("default", "{controller=Home}/{action=Index}/{id?}");
});
}
internal OptionalHeader64(ExeReader exeReader, IMAGE_OPTIONAL_HEADER64 optHeader, StreamLocation streamLoc) : base(exeReader,streamLoc)
{
header = optHeader;
List<DataDirectory> dirs = new List<DataDirectory>();
dirs.AddRange(new DataDirectory[] {
new DataDirectory(DataDirectoryType.ExportTable,header.ExportTable),
new DataDirectory(DataDirectoryType.ImportTable,header.ImportTable),
new DataDirectory(DataDirectoryType.ResourceTable,header.ResourceTable),
new DataDirectory(DataDirectoryType.ExceptionTable,header.ExceptionTable),
new DataDirectory(DataDirectoryType.CertificateTable,header.CertificateTable),
new DataDirectory(DataDirectoryType.BaseRelocationTable,header.BaseRelocationTable),
new DataDirectory(DataDirectoryType.Debug,header.Debug),
new DataDirectory(DataDirectoryType.Architecture,header.Architecture),
new DataDirectory(DataDirectoryType.GlobalPtr,header.GlobalPtr),
new DataDirectory(DataDirectoryType.TLSTable,header.TLSTable),
new DataDirectory(DataDirectoryType.LoadConfigTable,header.LoadConfigTable),
new DataDirectory(DataDirectoryType.BoundImport,header.BoundImport),
new DataDirectory(DataDirectoryType.ImportAddressTable,header.IAT),
new DataDirectory(DataDirectoryType.DelayImportDescriptor,header.DelayImportDescriptor),
new DataDirectory(DataDirectoryType.CLRRuntimeHeader,header.CLRRuntimeHeader)
});
long dir_size = 16 * DataDirectories.EntrySize;
StreamLocation location = new StreamLocation((streamLoc.Offset + streamLoc.Size) - dir_size,dir_size);
data_dirs = new DataDirectories(this,location,dirs.Where(dir => dir.DirectoryType != DataDirectoryType.None).ToDictionary(dir => dir.DirectoryType));
}
public static IMvcBuilder AddPlugins(this IMvcBuilder mvcBuilder, IServiceCollection serviceCollection,
IConfiguration config, ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger(typeof(PluginManager));
var pluginsFolder = new DataDirectories().Configure(config).PluginDir;
var plugins = new List <IBTCPayServerPlugin>();
serviceCollection.Configure <KestrelServerOptions>(options =>
{
options.Limits.MaxRequestBodySize = int.MaxValue; // if don't set default value is: 30 MB
});
_logger.LogInformation($"Loading plugins from {pluginsFolder}");
Directory.CreateDirectory(pluginsFolder);
ExecuteCommands(pluginsFolder);
List <(PluginLoader, Assembly, IFileProvider)> loadedPlugins =
new List <(PluginLoader, Assembly, IFileProvider)>();
var systemExtensions = GetDefaultLoadedPluginAssemblies();
plugins.AddRange(systemExtensions.SelectMany(assembly =>
GetAllPluginTypesFromAssembly(assembly).Select(GetPluginInstanceFromType)));
foreach (IBTCPayServerPlugin btcPayServerExtension in plugins)
{
btcPayServerExtension.SystemPlugin = true;
}
var orderFilePath = Path.Combine(pluginsFolder, "order");
var availableDirs = Directory.GetDirectories(pluginsFolder);
var orderedDirs = new List <string>();
if (File.Exists(orderFilePath))
{
var order = File.ReadLines(orderFilePath);
foreach (var s in order)
{
if (availableDirs.Contains(s))
{
orderedDirs.Add(s);
}
}
orderedDirs.AddRange(availableDirs.Where(s => !orderedDirs.Contains(s)));
}
else
{
orderedDirs = availableDirs.ToList();
}
var disabledPlugins = GetDisabledPlugins(pluginsFolder);
foreach (var dir in orderedDirs)
{
var pluginName = Path.GetFileName(dir);
if (disabledPlugins.Contains(pluginName))
{
continue;
}
var plugin = PluginLoader.CreateFromAssemblyFile(
Path.Combine(dir, pluginName + ".dll"), // create a plugin from for the .dll file
config =>
{
// this ensures that the version of MVC is shared between this app and the plugin
config.PreferSharedTypes = true;
config.IsUnloadable = true;
});
mvcBuilder.AddPluginLoader(plugin);
var pluginAssembly = plugin.LoadDefaultAssembly();
_pluginAssemblies.Add(pluginAssembly);
_plugins.Add(plugin);
var fileProvider = CreateEmbeddedFileProviderForAssembly(pluginAssembly);
loadedPlugins.Add((plugin, pluginAssembly, fileProvider));
plugins.AddRange(GetAllPluginTypesFromAssembly(pluginAssembly)
.Select(GetPluginInstanceFromType));
}
foreach (var plugin in plugins)
{
try
{
_logger.LogInformation(
$"Adding and executing plugin {plugin.Identifier} - {plugin.Version}");
plugin.Execute(serviceCollection);
serviceCollection.AddSingleton(plugin);
}
catch (Exception e)
{
_logger.LogError(
$"Error when loading plugin {plugin.Identifier} - {plugin.Version}{Environment.NewLine}{e.Message}");
}
}
return(mvcBuilder);
}
public OptionalHeader(PeInfoReader reader)
{
StandardFields = new OptionalHeaderStandardFields(reader);
WindowsSpecificFields = new OptionalHeaderWindowsSpecificFields(reader, StandardFields.Magic.Value);
DataDirectories = new DataDirectories(reader, WindowsSpecificFields.NumberOfRvaAndSizes.Value);
}
static void Main(string[] args)
{
if (args.Length > 0 && args[0] == "run")
{
args = args.Skip(1).ToArray(); // Hack to make dotnet watch work
}
ServicePointManager.DefaultConnectionLimit = 100;
IWebHost host = null;
var processor = new ConsoleLoggerProcessor();
CustomConsoleLogProvider loggerProvider = new CustomConsoleLogProvider(processor);
using var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
var logger = loggerFactory.CreateLogger("Configuration");
Logs logs = new Logs();
logs.Configure(loggerFactory);
IConfiguration conf = null;
try
{
conf = new DefaultConfiguration()
{
Logger = logger
}.CreateConfiguration(args);
if (conf == null)
{
return;
}
var builder = new WebHostBuilder()
.UseKestrel()
.UseConfiguration(conf)
.ConfigureLogging(l =>
{
l.AddFilter("Microsoft", LogLevel.Error);
if (!conf.GetOrDefault <bool>("verbose", false))
{
l.AddFilter("Events", LogLevel.Warning);
}
l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
l.AddFilter("Microsoft.AspNetCore.Antiforgery.Internal", LogLevel.Critical);
l.AddFilter("Fido2NetLib.DistributedCacheMetadataService", LogLevel.Error);
l.AddProvider(new CustomConsoleLogProvider(processor));
})
.UseStartup <Startup>();
// When we run the app with dotnet run (typically in dev env), the wwwroot isn't in the same directory
// than this assembly.
// But when we use dotnet publish, the wwwroot is published alongside the assembly!
// This fix https://github.com/btcpayserver/btcpayserver/issues/1894
var defaultContentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var defaultWebRoot = Path.Combine(defaultContentPath, "wwwroot");
var defaultWebRootExists = Directory.Exists(defaultWebRoot);
if (!defaultWebRootExists)
{
// When we use dotnet run...
builder.UseContentRoot(Directory.GetCurrentDirectory());
}
host = builder.Build();
host.StartWithTasksAsync().GetAwaiter().GetResult();
var urls = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses;
foreach (var url in urls)
{
// Some tools such as dotnet watch parse this exact log to open the browser
logger.LogInformation("Now listening on: " + url);
}
host.WaitForShutdown();
}
catch (ConfigException ex)
{
if (!string.IsNullOrEmpty(ex.Message))
{
logs.Configuration.LogError(ex.Message);
}
}
catch (Exception e) when(PluginManager.IsExceptionByPlugin(e))
{
var pluginDir = new DataDirectories().Configure(conf).PluginDir;
PluginManager.DisablePlugin(pluginDir, e.Source);
}
finally
{
processor.Dispose();
if (host == null)
{
logs.Configuration.LogError("Configuration error");
}
if (host != null)
{
host.Dispose();
}
Serilog.Log.CloseAndFlush();
loggerProvider.Dispose();
}
}
static void Main(string[] args)
{
ServicePointManager.DefaultConnectionLimit = 100;
IWebHost host = null;
var processor = new ConsoleLoggerProcessor();
CustomConsoleLogProvider loggerProvider = new CustomConsoleLogProvider(processor);
using var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
var logger = loggerFactory.CreateLogger("Configuration");
IConfiguration conf = null;
try
{
// This is the only way that LoadArgs can print to console. Because LoadArgs is called by the HostBuilder before Logs.Configure is called
conf = new DefaultConfiguration()
{
Logger = logger
}.CreateConfiguration(args);
if (conf == null)
{
return;
}
Logs.Configure(loggerFactory);
new BTCPayServerOptions().LoadArgs(conf);
Logs.Configure(null);
/////
host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseConfiguration(conf)
.ConfigureLogging(l =>
{
l.AddFilter("Microsoft", LogLevel.Error);
l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
l.AddFilter("Microsoft.AspNetCore.Antiforgery.Internal", LogLevel.Critical);
l.AddProvider(new CustomConsoleLogProvider(processor));
})
.UseStartup <Startup>()
.Build();
host.StartWithTasksAsync().GetAwaiter().GetResult();
var urls = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses;
foreach (var url in urls)
{
logger.LogInformation("Listening on " + url);
}
host.WaitForShutdown();
}
catch (ConfigException ex)
{
if (!string.IsNullOrEmpty(ex.Message))
{
Logs.Configuration.LogError(ex.Message);
}
}
catch (Exception e) when(PluginManager.IsExceptionByPlugin(e))
{
var pluginDir = new DataDirectories().Configure(conf).PluginDir;
PluginManager.DisablePlugin(pluginDir, e.Source);
}
finally
{
processor.Dispose();
if (host == null)
{
Logs.Configuration.LogError("Configuration error");
}
if (host != null)
{
host.Dispose();
}
Serilog.Log.CloseAndFlush();
loggerProvider.Dispose();
}
}
public StorageController(FileService fileService, DataDirectories datadirs)
{
_FileService = fileService;
_dir = datadirs.TempStorageDir;
}
