/// <summary>
/// Generate the statements for pem certificate configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>>
/// X509Certificate2.CreateFromPemFile("cert.pem", "private.pem");
/// </remarks>
private static ExpressionSyntax CreatePemCertificateStatements(CurlOptions curlOptions)
{
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
string methodName = null;
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
methodName = "CreateFromEncryptedPemFile";
}
else
{
methodName = "CreateFromPemFile";
}
if (curlOptions.HasKey)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.KeyFileName));
}
var createFromPemInvocationExpression = RoslynExtensions.CreateInvocationExpression(X509Certificate2ClassName, methodName, newCertificateArguments.ToArray());
var pfxTypeExpression = RoslynExtensions.CreateMemberAccessExpression("X509ContentType", "Pfx");
createFromPemInvocationExpression = RoslynExtensions.CreateInvocationExpression(createFromPemInvocationExpression, "Export", SyntaxFactory.Argument(pfxTypeExpression));
return(RoslynExtensions.CreateObjectCreationExpression(X509Certificate2ClassName, SyntaxFactory.Argument(createFromPemInvocationExpression)));
}
private ObjectCreationExpressionSyntax CreateStringContentCreation(CurlOptions curlOptions)
{
var arguments = new LinkedList <ArgumentSyntax>();
arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.Payload));
var contentHeader = curlOptions.Headers.GetCommaSeparatedValues(HeaderNames.ContentType);
if (contentHeader.Any())
{
arguments.AddLast(SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("Encoding", "UTF8")));
arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(contentHeader.First()));
}
var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray());
return(stringContentCreation);
}
/// <summary>
/// Generates the string content creation expression.
/// </summary>
/// <param name="contentSyntax">The content syntax.</param>
/// <param name="curlOptions">The curl options.</param>
/// <returns>
/// <see cref="ObjectCreationExpressionSyntax" /> expression.
/// </returns>
/// <remarks>
/// new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json")
/// </remarks>
private ObjectCreationExpressionSyntax CreateStringContentCreation(ArgumentSyntax contentSyntax, CurlOptions curlOptions)
{
var arguments = new LinkedList <ArgumentSyntax>();
arguments.AddLast(contentSyntax);
var contentHeader = curlOptions.Headers.GetCommaSeparatedValues(HeaderNames.ContentType).FirstOrDefault();
if (!string.IsNullOrEmpty(contentHeader))
{
var contentTypeValues = contentHeader.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
arguments.AddLast(SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("Encoding", "UTF8")));
arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(contentTypeValues[0].Trim()));
}
var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray());
return(stringContentCreation);
}
private static IEnumerable <MemberDeclarationSyntax> CreateCertificateStatement(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ClientCertificateOptions",
RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual"));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
var certificateCreationStatement = curlOptions.CertificateType switch
{
CertificateType.P12 => CreateP12CertificateStatements(curlOptions),
CertificateType.Pem => CreatePemCertificateStatements(curlOptions),
_ => throw new ArgumentOutOfRangeException(nameof(curlOptions.CertificateType), $"Unsupported certificate type {curlOptions.CertificateType}")
};
var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression(
HandlerVariableName,
"ClientCertificates",
"Add",
SyntaxFactory.Argument(certificateCreationStatement));
if (curlOptions.CertificateType == CertificateType.Pem)
{
certificateAssignmentExpression = certificateAssignmentExpression
.PrependComment(
Chars.NewLineString + "// PEM certificates support requires .NET 5 and higher" +
Chars.NewLineString + "// Export to PFX is needed because of this bug https://github.com/dotnet/runtime/issues/23749#issuecomment-747407051"
);
}
statementSyntaxs.AddLast(SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression)));
return(statementSyntaxs);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = CreateProxyStatements(curlOptions);
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.IsCompressed)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"AutomaticDecompression",
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, RoslynExtensions.CreateMemberAccessExpression("DecompressionMethods", "None")));
memberAssignmentExpression = memberAssignmentExpression
.PrependComment(Chars.NewLineString + "// If you are using .NET Core 3.0+ you can replace `~DecompressionMethods.None` to `DecompressionMethods.All`");
statementSyntaxs.AddLast(SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
foreach (var declarationSyntax in CreateCertificateStatement(curlOptions))
{
statementSyntaxs.AddLast(declarationSyntax);
}
}
if (curlOptions.Insecure)
{
var parameterListSyntax = RoslynExtensions.CreateParameterListSyntax(
"requestMessage",
"certificate",
"chain",
"policyErrors");
var lambdaExpression = SyntaxFactory.ParenthesizedLambdaExpression(
parameterListSyntax,
SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword)));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ServerCertificateCustomValidationCallback",
lambdaExpression))));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generates the string content creation statements.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// request.Content = new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json");
/// </remarks>
private IEnumerable <StatementSyntax> CreateStringContentAssignmentStatement(CurlOptions curlOptions)
{
var expressions = new LinkedList <ExpressionSyntax>();
foreach (var data in curlOptions.UploadData)
{
if (data.IsUrlEncoded)
{
ExpressionSyntax dataExpression;
if (data.IsFile)
{
dataExpression = CreateFileReadAllTextExpression(data.Content);
}
else
{
dataExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(data.Content));
}
dataExpression = RoslynExtensions.CreateInvocationExpression("Uri", "EscapeDataString", SyntaxFactory.Argument(dataExpression));
if (data.HasName)
{
dataExpression =
RoslynExtensions.CreateInterpolatedStringExpression($"{data.Name}=", dataExpression);
}
expressions.AddLast(dataExpression);
continue;
}
if (data.Type == UploadDataType.BinaryFile)
{
var readFileExpression = CreateFileReadAllTextExpression(data.Content);
expressions.AddLast(readFileExpression);
continue;
}
if (data.Type == UploadDataType.InlineFile)
{
var readFileExpression = CreateFileReadAllTextExpression(data.Content);
var replaceNewLines = RoslynExtensions.CreateInvocationExpression(
"Regex",
"Replace",
SyntaxFactory.Argument(readFileExpression),
RoslynExtensions.CreateStringLiteralArgument(@"(?:\r\n|\n|\r)"),
SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("string", "Empty")));
expressions.AddLast(replaceNewLines);
continue;
}
expressions.AddLast(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(data.Content)));
}
var statements = new LinkedList <StatementSyntax>();
ArgumentSyntax stringContentArgumentSyntax;
if (expressions.Count > 1)
{
var contentListVariableName = "contentList";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(contentListVariableName, "List<string>")));
foreach (var expression in expressions)
{
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
contentListVariableName,
"Add",
SyntaxFactory.Argument(expression))));
}
stringContentArgumentSyntax = SyntaxFactory.Argument(
RoslynExtensions.CreateInvocationExpression(
"string",
"Join",
RoslynExtensions.CreateStringLiteralArgument("&"),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName(contentListVariableName))));
}
else
{
stringContentArgumentSyntax = SyntaxFactory.Argument(expressions.First.Value);
}
var stringContentCreation = CreateStringContentCreation(
stringContentArgumentSyntax);
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
stringContentCreation)));
var memberAccessExpressionSyntax = RoslynExtensions.CreateMemberAccessExpression(
RoslynExtensions.CreateMemberAccessExpression(
RoslynExtensions.CreateMemberAccessExpression(RequestVariableName, RequestContentPropertyName),
"Headers"),
"ContentType");
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
memberAccessExpressionSyntax,
RoslynExtensions.CreateInvocationExpression("MediaTypeHeaderValue", "Parse", RoslynExtensions.CreateStringLiteralArgument(curlOptions.GetHeader(HeaderNames.ContentType))))));
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = CreateProxyStatements(curlOptions);
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ClientCertificateOptions",
RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual"));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
}
var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression(
"X509Certificate2",
newCertificateArguments.ToArray());
var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression(
HandlerVariableName,
"ClientCertificates",
"Add",
SyntaxFactory.Argument(newCertificateExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression)));
}
if (curlOptions.Insecure)
{
var parameterListSyntax = RoslynExtensions.CreateParameterListSyntax(
"requestMessage",
"certificate",
"chain",
"policyErrors");
var lambdaExpression = SyntaxFactory.ParenthesizedLambdaExpression(
parameterListSyntax,
SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword)));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ServerCertificateCustomValidationCallback",
lambdaExpression))));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"Proxy",
RoslynExtensions.CreateObjectCreationExpression("WebProxy", RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString())));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ClientCertificateOptions",
RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual"));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
}
var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression(
"X509Certificate2",
newCertificateArguments.ToArray());
var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression(
HandlerVariableName,
"ClientCertificates",
"Add",
SyntaxFactory.Argument(newCertificateExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression)));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}