public static void OnDataReceive(System.Object sender, DataEventArgs e)
{
print("buff length: " + e.Length + ", offset: " + e.Offset);
if (e.Length <= 0)
{
return;
}
// CodedInputStream stream = CodedInputStream.CreateInstance(e.Data);
// int length = (int)stream.ReadRawVarint32();
// byte[] baseBytes = stream.ReadRawBytes (e.Length);
// byte[] baseBytes = stream.ToArray();
MemoryStream stream = new MemoryStream(e.Data);
byte[] baseBytes = new byte[e.Length];
stream.Read(baseBytes, e.Offset, e.Length);
BasePacket basePacket = BasePacket.ParseFrom(baseBytes);
int packetId = basePacket.PacketId;
byte[] namePacketBytes = basePacket.PacketData.ToByteArray();
NamePacket response = NamePacket.ParseFrom(namePacketBytes);
print("packetId - " + packetId + ", response - " + response);
}
void OnGUI()
{
if (GUI.Button(new Rect(100, 130, 100, 25), "SuperSocket"))
{
buffer.Data = new byte[8192];
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(host), port);
AsyncTcpSession client = new AsyncTcpSession(endPoint);
client.Connected += OnConnected;
client.DataReceived += OnDataReceive;
client.Connect();
NamePacket.Builder b = new NamePacket.Builder();
b.SetName("Client name data");
NamePacket np = b.BuildPartial();
MemoryStream stream = new MemoryStream();
np.WriteTo(stream);
byte[] bytes = stream.ToArray();
BasePacket.Builder basePacketBuilder = new BasePacket.Builder();
basePacketBuilder.SetPacketId(64553060);
basePacketBuilder.SetPacketData(
ByteString.CopyFrom(bytes)
);
BasePacket basePacket = basePacketBuilder.BuildPartial();
sendMessage(client, basePacket);
print("SuperSocket!");
}
}
private void ConnectToServer(int retries)
{
//this loop allows for multiple attempts to connect to the server before timing out
for (int i = 0; i < retries; i++)
{
UpdateStatus(">>Attempting to connect...");
try {
ClientSocket.Connect(Server, 8888);
} catch (Exception ex) {
UpdateStatus(ex.Message);
}
//once connected, the client sends a packet to the server to agknowledge logging in.
if (ClientSocket.Connected)
{
NetworkStream loginStream = ClientSocket.GetStream();
NamePacket handshake = new NamePacket(Environment.UserName);
loginStream.Write(handshake.CreateDataStream(), 0, handshake.PacketLength);
loginStream.Flush();
UpdateStatus("Server Connected ... " + Server);
//bwBroadcastStream.RunWorkerAsync();
break;
}
UpdateStatus(">> Waiting 3 Seconds before trying again.");
DateTime start = DateTime.Now;
while (DateTime.Now.Subtract(start).Seconds < 3)
{
}
}
if (!ClientSocket.Connected)
{
UpdateStatus("Connection Failed!!");
}
}
public void SetName(string _name)
{
try
{
NamePacket packet = new NamePacket();
packet.id = localID;
packet.name = _name;
socket.Emit("name", JsonUtility.ToJson(packet));
}
catch (Exception ex) { Debug.Log(ex.Message + " | " + ex.StackTrace); }
}
public void setName(string name, NetworkCallBack callBack)
{
NetWorkServices netWorkServices = NetWorkServices.getInstance();
NamePacket packet = new NamePacket();
packet.name = name;
packet.type = "CGI";
packet.command = "setName";
string jsonStr = JSON.Dump(packet);
Variant jsonObj = JSON.Load(jsonStr);
netWorkServices.sendCGIRequest(jsonObj, callBack);
}
public static void OnDataReceive2(System.Object sender, DataEventArgs e)
{
print("buff length: " + e.Length + ", offset: " + e.Offset);
if (e.Length <= 0)
{
return;
}
Array.Copy(e.Data, 0, buffer.Data, buffer.Length, e.Length);
buffer.Length += e.Length;
CodedInputStream stream = CodedInputStream.CreateInstance(buffer.Data);
while (!stream.IsAtEnd)
{
int markReadIndex = (int)stream.Position;
int varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (buffer.Length - (int)stream.Position))
{
try {
byte[] body = stream.ReadRawBytes(varint32);
NamePacket response = NamePacket.ParseFrom(body);
print("Response: " + response.ToString() + ", count: " + (++count));
} catch (Exception exception) {
print(exception.Message);
}
}
else
{
byte[] dest = new byte[8192];
int remainSize = buffer.Length - markReadIndex;
Array.Copy(buffer.Data, markReadIndex, dest, 0, remainSize);
buffer.Data = dest;
buffer.Offset = 0;
buffer.Length = remainSize;
break;
}
}
}
public void ReadDir(uint requestId)
{
// If the pending items list is null, OpenDir was never called
if (pendingDirectoryItems == null)
{
var packet = new StatusPacket
{
Id = requestId,
StatusCode = StatusPacket.Failure,
ErrorMessage = "directory not open"
};
sftp.Send(packet);
}
// If the pending items list is empty, we're done - send EOF
if (pendingDirectoryItems.Count == 0)
{
var packet = new StatusPacket
{
Id = requestId,
StatusCode = StatusPacket.Eof,
ErrorMessage = "no more files"
};
sftp.Send(packet);
}
else
{
// We have files to send...send a batch.
// TODO - keep the batch small enough that we do not exceed the connection's max packet size
// TODO - implement me!
var packet = new NamePacket();
// TODO - parameterize the max entry count (and eventually base it off packet size)
while ((pendingDirectoryItems.Count > 0) && (packet.Entries.Count < 10))
{
packet.Entries.Add(pendingDirectoryItems.Dequeue().AsPacketEntry());
}
sftp.Send(packet);
}
}
private void HandlePacket(RealPathPacket packet)
{
logger.LogDebug("Processing RealPath SFTP packet, Id={Id}, Path='{Path}'.", packet.Id, packet.Path);
var name = new NamePacket
{
Id = packet.Id
};
// TODO - properly set Longname - need that from file system, too.
var realPath = fileSystem.GetRealPath(packet.Path);
name.AddEntry(new NamePacket.Entry
{
Filename = realPath,
Longname = realPath // TODO - fix!
});
Send(name);
}
