erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

feat(net): PacketWriter + LoginRequest payload builder (Phase 4.5a/b)

Browse source 
Adds the outbound-side primitives acdream needs to send a LoginRequest
packet to an ACE server: a growable byte buffer writer with AC's two
length-prefixed string formats, plus the LoginRequest payload builder
and parser.

PacketWriter (Packets/PacketWriter.cs):
  - Growable byte[] buffer with little-endian WriteByte/UInt16/UInt32/Bytes
  - WriteString16L: u16 length + ASCII bytes + zero-pad to 4-byte boundary
    (pad counted from start of length prefix, matching ACE's Extensions.cs)
  - WriteString32L: u32 outer length (= asciiLen+1) + 1 marker byte (value
    ignored by reader, we emit 0) + ASCII + pad. Reader decrements the
    outer length by 1 when consuming the marker, so asciiLen is recovered
    correctly. Asserts ≤255 chars (two-byte-marker variant not needed for
    acdream's dev credentials).
  - ASCII encoding used instead of Windows-1252 since dev account names
    and passwords are ASCII-safe; can switch to CodePages later if a
    non-ASCII identifier ever turns up.

LoginRequest (Packets/LoginRequest.cs):
  - Build(account, password, timestamp, clientVersion="1802") produces
    the login payload bytes that go into the body of a packet whose
    header has the LoginRequest flag set
  - Parse(bytes) for tests and diagnostics — server never calls this
    in production, but round-trip tests make the writer self-verifying
  - NetAuthType enum mirrors ACE: Account/AccountPassword/GlsTicket
  - Wire layout per ACE's PacketInboundLoginRequest:
      String16L ClientVersion
      u32       bodyLength (bytes remaining after this field)
      u32       NetAuthType (2 = AccountPassword)
      u32       AuthFlags (0 for normal client)
      u32       Timestamp
      String16L Account
      String16L LoginAs (empty for non-admin)
      String32L Password (when AccountPassword)
  - bodyLength field is back-patched after the full body has been
    written (classic "write placeholder, come back and patch" flow)

Tests (17 new, 61 total in net project, 138 across both test projects):
  PacketWriter (11):
    - u32 little-endian
    - String16L: empty, 1/2/3-char with correct padding
    - String32L: 2-char short, empty, >255 throws
    - AlignTo4 no-op when aligned, pads when not
    - Buffer grows past initial capacity on big writes
  LoginRequest (6):
    - Build→Parse round-trip with realistic credentials (testaccount/
      testpassword/timestamp)
    - Empty account/password round-trip (padding edge case)
    - BodyLength field reflects actual remaining bytes after itself
    - Total wire size is multiple of 4 (sanity check on padding)
    - Different credentials produce different bytes
    - End-to-end: payload embedded in a full Packet with LoginRequest
      header flag + correct unencrypted checksum, PacketCodec.TryDecode
      parses it, BodyBytes round-trips back to the same credentials
      through LoginRequest.Parse

This gives acdream everything needed to construct the first datagram
of the handshake. Phase 4.5c next: WorldSession state machine to drive
the handshake sequence.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Erik 2026-04-11 14:36:39 +02:00
parent c64bbf29e4
commit 44c335469a
4 changed files with 556 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

162
src/AcDream.Core.Net/Packets/PacketWriter.cs Normal file
View file

@ -0,0 +1,162 @@
using System.Buffers.Binary;
using System.Text;
namespace AcDream.Core.Net.Packets;
/// <summary>
/// Growable byte buffer with AC-specific write helpers. The wire format
/// uses little-endian primitives plus two string encodings inherited from
/// the retail client:
///
/// <list type="bullet">
/// <item><b>String16L</b> — <c>u16 length</c> + ASCII bytes + zero
/// padding to the next 4-byte boundary (counting from the length
/// prefix).</item>
/// <item><b>String32L</b> — used only in the login header. <c>u32 outer
/// length</c> + a single marker byte + ASCII bytes + optional
/// padding. Outer length = strlen + 1. The marker byte's value is
/// ignored by the reader so we emit <c>0x00</c>. Strings longer
/// than 255 chars need a two-byte marker; acdream asserts usernames
/// and passwords stay short and avoids that case.</item>
/// </list>
///
/// Uses Windows-1252 at the .NET level by falling back to ASCII bytes for
/// the characters we actually care about (usernames and passwords in
/// ACE-auto-created accounts are ASCII-safe). A future phase can fold in
/// <c>System.Text.Encoding.CodePages</c> if we ever see non-ASCII identifiers.
/// </summary>
public sealed class PacketWriter
{
private byte[] _buffer;
private int _position;
public PacketWriter(int initialCapacity = 256)
{
_buffer = new byte[initialCapacity];
_position = 0;
}
public int Position => _position;
/// <summary>Bytes written so far, as a freshly-allocated array.</summary>
public byte[] ToArray()
{
var copy = new byte[_position];
Array.Copy(_buffer, copy, _position);
return copy;
}
/// <summary>Bytes written so far, as a span view over the internal buffer.
/// Do not hold on to this after more writes — the buffer may be reallocated.</summary>
public ReadOnlySpan<byte> AsSpan() => _buffer.AsSpan(0, _position);
private void EnsureCapacity(int additional)
{
int required = _position + additional;
if (required <= _buffer.Length) return;
int newSize = _buffer.Length;
while (newSize < required) newSize *= 2;
var bigger = new byte[newSize];
Array.Copy(_buffer, bigger, _position);
_buffer = bigger;
}
public void WriteByte(byte value)
{
EnsureCapacity(1);
_buffer[_position++] = value;
}
public void WriteUInt16(ushort value)
{
EnsureCapacity(2);
BinaryPrimitives.WriteUInt16LittleEndian(_buffer.AsSpan(_position), value);
_position += 2;
}
public void WriteUInt32(uint value)
{
EnsureCapacity(4);
BinaryPrimitives.WriteUInt32LittleEndian(_buffer.AsSpan(_position), value);
_position += 4;
}
public void WriteBytes(ReadOnlySpan<byte> bytes)
{
EnsureCapacity(bytes.Length);
bytes.CopyTo(_buffer.AsSpan(_position));
_position += bytes.Length;
}
/// <summary>Pad with zeros so the buffer length is a multiple of 4.</summary>
public void AlignTo4()
{
int padding = (4 - (_position & 3)) & 3;
EnsureCapacity(padding);
for (int i = 0; i < padding; i++) _buffer[_position++] = 0;
}
/// <summary>Pad with N zero bytes from the current position.</summary>
public void Pad(int count)
{
if (count <= 0) return;
EnsureCapacity(count);
for (int i = 0; i < count; i++) _buffer[_position++] = 0;
}
/// <summary>
/// Write a String16L: u16 length + ASCII bytes + pad-to-4 from the
/// start of the length prefix.
/// </summary>
public void WriteString16L(string value)
{
value ??= string.Empty;
int asciiLen = value.Length;
WriteUInt16((ushort)asciiLen);
if (asciiLen > 0)
{
EnsureCapacity(asciiLen);
// Encoding.ASCII is sufficient for dev account names/passwords.
int written = Encoding.ASCII.GetBytes(value, 0, asciiLen, _buffer, _position);
_position += written;
}
// Pad from the start of the string record (u16 + asciiLen).
int recordSize = 2 + asciiLen;
int padding = (4 - (recordSize & 3)) & 3;
Pad(padding);
}
/// <summary>
/// Write a String32L: u32 outer length (= asciiLen + 1), one marker
/// byte (value 0, ignored by reader), asciiLen bytes, then pad to 4
/// from the start of the length prefix.
/// Asserts <paramref name="value"/> is ≤ 255 characters.
/// </summary>
public void WriteString32L(string value)
{
value ??= string.Empty;
if (value.Length > 255)
throw new ArgumentException($"String32L only supports short strings (≤255), got {value.Length}", nameof(value));
int asciiLen = value.Length;
if (asciiLen == 0)
{
// Reader treats length==0 as empty string with no marker, no content.
WriteUInt32(0);
return;
}
WriteUInt32((uint)(asciiLen + 1)); // outer length includes the marker
WriteByte(0); // marker byte — value is ignored
if (asciiLen > 0)
{
EnsureCapacity(asciiLen);
int written = Encoding.ASCII.GetBytes(value, 0, asciiLen, _buffer, _position);
_position += written;
}
// Pad from start of the u32 length prefix: 4 + 1 + asciiLen.
int recordSize = 4 + 1 + asciiLen;
int padding = (4 - (recordSize & 3)) & 3;
Pad(padding);
}
}