public override void Execute(NntpSession session)
{
switch (state)
{
case RequestState.StartingRequest:
state = RequestState.ReceivingHeaders;
session.Connection.SendLine("340 Send article to be posted");
break;
case RequestState.RequestFinished:
using (INntpConnection connection = session.Repository.CreateConnection())
{
INntpArticle article = connection.CreateArticle();
SetOverviewHeaders(article);
SetOtherHeaders(article);
article.Body = body.ToString();
connection.PostArticle(article);
}
session.Connection.SendLine("240 Article received OK");
break;
}
}
public static void Write(INntpConnection connection, NntpArticle article)
{
WriteHeaders(connection, article);
connection.WriteLine(string.Empty);
WriteBody(connection, article);
connection.WriteLine(".");
}
private static NntpMultilineResponse ExecuteArticleCommand(INntpConnection connection, string command, int? articleNo, int validCode)
{
var articleCommand = CommandBuilder.Build(command, builder =>
{
if (articleNo.HasValue) builder.AddParameter(articleNo.Value);
});
return connection.ExecuteMultilineCommand(articleCommand, validCode);
}
public static NntpMultilineResponse Hdr(this INntpConnection connection, string field, int?articleNo = null)
{
var command = CommandBuilder.Build(string.Format("HDR {0}", field), builder =>
{
if (articleNo.HasValue)
{
builder.AddParameter(articleNo.Value);
}
});
return(connection.ExecuteMultilineCommand(command, 225));
}
private static NntpMultilineResponse ExecuteArticleCommand(INntpConnection connection, string command, int?articleNo, int validCode)
{
var articleCommand = CommandBuilder.Build(command, builder =>
{
if (articleNo.HasValue)
{
builder.AddParameter(articleNo.Value);
}
});
return(connection.ExecuteMultilineCommand(articleCommand, validCode));
}
private static void WriteBody(INntpConnection connection, NntpArticle article)
{
foreach (string line in article.Body)
{
if (line.Length > 0 && line[0] == '.')
{
connection.WriteLine("." + line);
continue;
}
connection.WriteLine(line);
}
}
public static NntpMultilineResponse Capabilities(this INntpConnection connection, string keyword = null)
{
var command = CommandBuilder.Build("CAPABILITIES", builder =>
{
if (!string.IsNullOrWhiteSpace(keyword))
{
builder.AddParameter(keyword);
}
});
return(connection.ExecuteMultilineCommand(command, 101));
}
protected static bool GetArticleByMessageID(INntpConnection connection, NntpSession session, string id, out KeyValuePair <int, INntpArticle> pair)
{
pair = new KeyValuePair <int, INntpArticle>(0, connection.GetArticle(id));
if (pair.Value == null)
{
session.Connection.SendLine("430 No article with that message-id");
return(false);
}
return(true);
}
public static NntpMultilineResponse Over(this INntpConnection connection, int?articleNo = null)
{
var command = CommandBuilder.Build("OVER", builder =>
{
if (articleNo.HasValue)
{
builder.AddParameter(articleNo.Value);
}
});
return(connection.ExecuteMultilineCommand(command, 224));
}
public static NntpMultilineResponse NewGroups(this INntpConnection connection, DateTime createdSince, bool isGmt = false)
{
var command = CommandBuilder.Build("NEWGROUPS", builder =>
{
builder.AddDateAndTimeParameters(createdSince);
if (isGmt)
{
builder.AddParameter("GMT");
}
});
return(connection.ExecuteMultilineCommand(command, 231));
}
public override void Execute(NntpSession session)
{
using (INntpConnection connection = session.Repository.CreateConnection())
{
INntpGroup group;
if (!GetGroupByName(connection, session, _group, out group))
{
return;
}
session.Connection.SendLine("211 {0} {1} {2} {3}",
group.Count, group.Low, group.High, group.Name);
}
}
protected static bool GetGroupByName(INntpConnection connection, NntpSession session, string name, out INntpGroup group)
{
group = connection.GetGroup(name);
if (group == null)
{
session.Connection.SendLine("411 No such newsgroup");
return(false);
}
session.Context[typeof(INntpGroup)] = name;
session.Context[typeof(INntpArticle)] = group.Low;
return(true);
}
private static void WriteHeaders(INntpConnection connection, NntpArticle article)
{
WriteHeader(connection, NntpHeaders.MessageId, article.MessageId);
foreach (KeyValuePair <string, ICollection <string> > header in article.Headers)
{
if (header.Key == NntpHeaders.MessageId)
{
// skip message-id, already written
continue;
}
foreach (string value in header.Value)
{
WriteHeader(connection, header.Key, value);
}
}
}
public override void Execute(NntpSession session)
{
using (INntpConnection connection = session.Repository.CreateConnection())
{
INntpGroup group;
if (!GetGroupByCurrentName(connection, session, out group))
{
return;
}
KeyValuePair <int, INntpArticle> pair;
if (!GetArticleByCurrentNumber(connection, session, out pair))
{
return;
}
if (name == "NEXT")
{
pair = group.GetNextArticle(pair.Key);
if (pair.Value == null)
{
session.Connection.SendLine("421 No next article in this group");
return;
}
}
if (name == "LAST")
{
pair = group.GetLastArticle(pair.Key);
if (pair.Value == null)
{
session.Connection.SendLine("422 No previous article in this group");
return;
}
}
session.Context[typeof(INntpArticle)] = pair.Key;
session.Connection.SendLine("223 {0} {1}", pair.Key, pair.Value.MessageID);
}
}
private static void WriteHeaders(INntpConnection connection, NntpArticle article)
{
WriteHeader(connection, NntpHeaders.MessageId, article.MessageId);
WriteHeader(connection, NntpHeaders.Newsgroups, article.Groups.ToString());
foreach (KeyValuePair <string, ImmutableHashSet <string> > header in article.Headers)
{
if (header.Key == NntpHeaders.MessageId ||
header.Key == NntpHeaders.Newsgroups)
{
// skip message-id and newsgroups, they are already written
continue;
}
foreach (string value in header.Value)
{
WriteHeader(connection, header.Key, value);
}
}
}
public override void Execute(NntpSession session)
{
using (INntpConnection connection = session.Repository.CreateConnection())
{
List <INntpGroup> groups =
new List <INntpGroup>(connection.GetGroups());
session.Connection.SendLine("215 List of newsgroups follows");
foreach (INntpGroup group in groups)
{
session.Connection.SendLine("{0}\t{1}",
group.Name, group.Description);
}
session.Connection.SendLine(".");
}
}
public static NntpMultilineResponse ListGroup(this INntpConnection connection, string group = null, Range range = null)
{
var command = CommandBuilder.Build("LISTGROUP", builder =>
{
if (string.IsNullOrWhiteSpace(group))
{
return;
}
builder.AddParameter(group);
if (range != null)
{
builder.AddParameter(range);
}
});
return(connection.ExecuteMultilineCommand(command, 211));
}
public override void Execute(NntpSession session)
{
using (INntpConnection connection = session.Repository.CreateConnection())
{
INntpGroup group;
if (_group == null)
{
if (!GetGroupByCurrentName(connection, session, out group))
{
return;
}
}
else
{
if (!GetGroupByName(connection, session, _group, out group))
{
return;
}
}
if (low == 0)
{
low = group.Low;
}
if (high == 0)
{
high = group.High;
}
session.Context[typeof(INntpArticle)] = low; //???
session.Connection.SendLine("211 {0} {1} {2} {3}",
group.Count, group.Low, group.High, group.Name);
foreach (KeyValuePair <int, INntpArticle> pair in group.GetArticles(low, high))
{
session.Connection.SendLine("{0}", pair.Key);
}
session.Connection.SendLine(".");
}
}
public static NntpMultilineResponse List(this INntpConnection connection, ListKeyword?keyword = null, string wildmatOrArgument = null)
{
var command = CommandBuilder.Build("LIST", builder =>
{
if (!keyword.HasValue)
{
return;
}
builder.AddParameter(keyword.Value.GetDescription());
if (!string.IsNullOrWhiteSpace(wildmatOrArgument))
{
builder.AddParameter(wildmatOrArgument);
}
});
return(connection.ExecuteMultilineCommand(command, 215));
}
protected static bool GetGroupByCurrentName(INntpConnection connection, NntpSession session, out INntpGroup group)
{
group = null;
if (!session.Context.ContainsKey(typeof(INntpGroup)))
{
session.Connection.SendLine("412 No newsgroup selected");
return(false);
}
group = connection.GetGroup((string)session.Context[typeof(INntpGroup)]);
if (group == null)
{
session.Connection.SendLine("412 No newsgroup selected");
return(false);
}
return(true);
}
protected static bool GetArticleByCurrentNumber(INntpConnection connection, NntpSession session, out KeyValuePair <int, INntpArticle> pair)
{
pair = new KeyValuePair <int, INntpArticle>(0, null);
INntpGroup group;
if (!GetGroupByCurrentName(connection, session, out group))
{
return(false);
}
int number = (int)session.Context[typeof(INntpArticle)];
pair = new KeyValuePair <int, INntpArticle>(number, group.GetArticle(number));
if (pair.Value == null)
{
session.Connection.SendLine("420 Current article number is invalid");
return(false);
}
return(true);
}
protected static bool GetArticleByNumber(INntpConnection connection, NntpSession session, int number, out KeyValuePair <int, INntpArticle> pair)
{
pair = new KeyValuePair <int, INntpArticle>(number, null);
INntpGroup group;
if (!GetGroupByCurrentName(connection, session, out group))
{
return(false);
}
pair = new KeyValuePair <int, INntpArticle>(number, group.GetArticle(number));
if (pair.Value == null)
{
session.Connection.SendLine("423 No article with that number");
return(false);
}
session.Context[typeof(INntpArticle)] = number;
return(true);
}
private static void WriteHeader(INntpConnection connection, string key, string val)
{
if (key == NntpHeaders.MessageId)
{
val = new NntpMessageId(val);
}
string line = $"{key}: {val}";
if (line.Length <= maxHeaderLength)
{
connection.WriteLine(line);
return;
}
// header line is too long, fold it
connection.WriteLine(line.Substring(0, maxHeaderLength));
line = line.Substring(maxHeaderLength);
while (line.Length > maxHeaderLength)
{
connection.WriteLine("\t" + line.Substring(0, maxHeaderLength - 1));
line = line.Substring(maxHeaderLength - 1);
}
connection.WriteLine("\t" + line);
}
public override void Execute(NntpSession session)
{
using (INntpConnection connection = session.Repository.CreateConnection())
{
KeyValuePair <int, INntpArticle> pair;
switch (type)
{
case RequestType.ByMessageID:
if (!GetArticleByMessageID(connection, session, id, out pair))
{
return;
}
break;
case RequestType.ByArticleNumber:
if (!GetArticleByNumber(connection, session, number, out pair))
{
return;
}
break;
case RequestType.ByCurrentArticleNumber:
if (!GetArticleByCurrentNumber(connection, session, out pair))
{
return;
}
break;
default:
throw new InvalidOperationException("Unknown request type");
}
if (name == "ARTICLE")
{
session.Connection.SendLine("220 {0} {1}", pair.Key, pair.Value.MessageID);
}
if (name == "HEAD")
{
session.Connection.SendLine("221 {0} {1}", pair.Key, pair.Value.MessageID);
}
if (name == "BODY")
{
session.Connection.SendLine("222 {0} {1}", pair.Key, pair.Value.MessageID);
}
if (name == "STAT")
{
session.Connection.SendLine("223 {0} {1}", pair.Key, pair.Value.MessageID);
}
if (name == "ARTICLE" || name == "HEAD")
{
SendHeader(session, NntpHeaderName.MessageID, pair.Value.MessageID);
SendHeader(session, NntpHeaderName.Subject, pair.Value.Subject);
SendHeader(session, NntpHeaderName.From, pair.Value.From);
SendHeader(session, NntpHeaderName.Date, pair.Value.Date);
SendHeader(session, NntpHeaderName.Newsgroups, pair.Value.Newsgroups);
if (pair.Value.References != "")
{
SendHeader(session, NntpHeaderName.References, pair.Value.References);
}
foreach (KeyValuePair <string, string> header in pair.Value.Headers)
{
SendHeader(session, header.Key, header.Value);
}
}
if (name == "ARTICLE")
{
session.Connection.SendLine("");
}
if (name == "ARTICLE" || name == "BODY")
{
string[] lines = pair.Value.Body.Split('\n');
for (int i = 0; i < lines.Length; i++)
{
string line = lines[i];
if (line.StartsWith("."))
{
line = '.' + line;
}
session.Connection.SendLine(line);
}
}
if (name != "STAT")
{
session.Connection.SendLine(".");
}
}
}
public static NntpResponse Post(this INntpConnection connection, IEnumerable <string> article)
{
throw new PullRequestException();
}
public static NntpResponse IHave(this INntpConnection connection, string messageId, IEnumerable <string> article)
{
throw new PullRequestException();
}
public static NntpMultilineResponse Article(this INntpConnection connection, string messageId)
{
return(ExecuteArticleCommand(connection, "ARTICLE", messageId, 220));
}
private static NntpMultilineResponse ExecuteArticleCommand(INntpConnection connection, string command, string messageId, int validCode)
{
return(connection.ExecuteMultilineCommand(string.Join(" ", command, messageId.WithBrackets()), validCode));
}
public static NntpResponse Stat(this INntpConnection connection, int?articleNo = null)
{
return(ExecuteArticleCommand(connection, "STAT", articleNo, 223));
}
public static NntpResponse Stat(this INntpConnection connection, string messageId)
{
return(ExecuteArticleCommand(connection, "STAT", messageId, 223));
}
public static NntpMultilineResponse Body(this INntpConnection connection, int?articleNo = null)
{
return(ExecuteArticleCommand(connection, "BODY", articleNo, 222));
}
public NntpClient(INntpConnection connection)
{
_connection = connection;
}
private static NntpMultilineResponse ExecuteArticleCommand(INntpConnection connection, string command, string messageId, int validCode)
{
return connection.ExecuteMultilineCommand(string.Join(" ", command, messageId.WithBrackets()), validCode);
}
