if-elseif chain. Is there a better pattern?

There is a bug in that you are not resetting the state when you read an unexpected byte. For example, this byte sequence would be accepted as a valid header by your code:

0x12 0xff 0x34 0xff 0x89

I wonder whether you would get a neater solution if you used a stream:

Stream stream = new MemoryStream(buffer);
ReadHeader(stream);
int length = ReadLength(stream);
byte[] data = new byte[length];
stream.Read(data, 0, length);

Where ReadHeader looks something like this:

byte[] header = new byte[TcpHeader.Length];
stream.Read(header, 0, TcpHeader.Length);
while (!header.equals(TcpHeader)) {
  // move back to 1 byte on from where we last tried to read the header
  stream.Seek(1 - TcpHeader.Length, SeekOrigin.Current);
  stream.Read(header, 0, TcpHeader.Length);
}

And where ReadLength reads 4 bytes and creates an int, taking network byte order into consideration.

Note there are some defects in my code which I have left there to keep it readable:

• The length field is probably an unsigned int, whereas Stream.Read only accepts an int.
• Stream.Read may not read all the bytes you asked for, so a loop is required to fill the buffer.
• We may reach the end of the stream while reading.

(feedback on my first ever answer is very welcome!)

This answer is just to show the current implementation (proposed by Mikey).

    public PacketHandler()
    {
        _packet = new List<byte>();
        _handlers = new Dictionary<PacketStatus, Action<byte>>{
                { PacketStatus.Empty, b => Expect(FirstHeaderByte, b, PacketStatus.FirstHeaderReceived) },
                { PacketStatus.FirstHeaderReceived, b => Expect(SecondHeaderByte, b, PacketStatus.SecondHeaderReceived) },
                { PacketStatus.SecondHeaderReceived,b => Expect(ThirdHeaderByte, b, PacketStatus.ThirdHeaderReceived)},
                { PacketStatus.ThirdHeaderReceived, AcceptPacketLength},
                { PacketStatus.ReceivingPacketLength, AcceptPacketLength},
                { PacketStatus.ReceivingData, AcceptData},
                { PacketStatus.Unsynchronized, b => Expect(FirstHeaderByte, b, PacketStatus.FirstHeaderReceived) }
            };
    }

    public void  ProcessIncomingData(byte[] buffer, int length)
    {
        for (_currentByteIndex = 0; _currentByteIndex < length; _currentByteIndex++)
        {
            var currentByte = buffer[_currentByteIndex];
            var handler = _handlers[_status];
            handler(currentByte);
        }
    }

I come up with a solution using bit mask to detect the header. I think using Dictionary looks more maintainable anyway.

    private int _expectedBytesLength;
    private int _consumedBytesLength;
    private readonly byte[] _packetMask = new byte[] { 0x12, 0x34, 0x89, 0xFF, 0xFF, 0xFF, 0xFF };
    private byte[] _packetHeaderBuffer = new byte[7]; // should be allocated with _packetMask.Length in constructor
    private List<byte> _packet = new List<byte>();

    public void ProcessByte(byte b) {
        if (_expectedBytesLength > 0) {
            if (_expectedBytesLength > _consumedBytesLength) {
                _packet.Add (b);
                _consumedBytesLength++;
            }
            if (_consumedBytesLength >= _expectedBytesLength) {
                var packetData = new byte[_packet.Count];
                _packet.CopyTo (packetData);
                Console.WriteLine (packetData.Length);
                // raise events etc.
                _expectedBytesLength = 0;
                _consumedBytesLength = 0;
                _packet.Clear ();
            }
        } 
        else {
            bool inState = (b & _packetMask[_consumedBytesLength]) == b;
            if (inState) {
                _packetHeaderBuffer[_consumedBytesLength] = b;
                _consumedBytesLength++;
                if (_consumedBytesLength >= _packetMask.Length) {
                    int length = 0;
                    for (int i = 3; i < 7; i++) {
                        length <<= 1;
                        length += _packetHeaderBuffer[i];
                    }
                    _expectedBytesLength = length + _packetHeaderBuffer.Length;
                }
            }
        }
    }