/// <summary>
/// играть за белых
/// </summary>
public void PlayAsWhite()
{
SenderState scriptToAccess = stateOBJ.GetComponent <SenderState>();
scriptToAccess.SetColor(0);
Debug.Log("Color setted is 0");
Application.LoadLevel("Scene");
}
public TwoChoicesExtendedObliviousTransferChannelBase(ITwoChoicesObliviousTransferChannel baseOT, int securityParameter, CryptoContext cryptoContext)
{
RandomNumberGenerator = new ThreadsafeRandomNumberGenerator(cryptoContext.RandomNumberGenerator);
RandomOracleProvider = new HashRandomOracleProvider(cryptoContext.HashAlgorithmProvider);
SecurityParameter = securityParameter;
_baseOT = baseOT;
_senderState = new SenderState();
_receiverState = new ReceiverState();
}
/// <summary>
/// 发送消息并在本地处理
/// </summary>
/// <param name="data">数据</param>
/// <param name="priority">0:最高优先级，-1:最低优先级</param>
/// <param name="proc">调用方法</param>
/// <returns></returns>
public object ProcessData(object data, int priority, MsgQueue.MessageProc proc)
{
State = SenderState.Busy;
DataSent d = PushData(MsgQueue.msgtype_Request, data, priority, proc);
requestThread = Thread.CurrentThread;
d.evt.WaitOne();
requestThread = null;
State = SenderState.Idle;
return(d.retData);
}
/// <summary>
/// 发送消息并请求响应
/// </summary>
/// <param name="data">数据</param>
/// <param name="priority">0:最高优先级，-1:最低优先级</param>
/// <returns></returns>
public object RequestData(object data, int priority)
{
State = SenderState.Waiting;
DataSent d = PushData(MsgQueue.msgtype_Request, data, priority, null);
requestThread = Thread.CurrentThread;
d.evt.WaitOne();
requestThread = null;
State = SenderState.Idle;
return(d.retData);
}
/// <summary>
/// при создании кадра происходит до Start . создаем и заполняем доску
/// </summary>
void Awake()
{
DontDestroyOnLoad(this.gameObject);
AIOBJ = GameObject.Find("AI");
stateOBJ = GameObject.Find("StateMessanger");
SenderState scriptToAccessOBJ = stateOBJ.GetComponent <SenderState>();
State2 = scriptToAccessOBJ.color;
State = scriptToAccessOBJ.color;
filing_table();
}
//init
public DispatchProcessor(SenderState <TKey> hubState, IDispatchQueue <TKey> dispatchQueue,
ILogger logger, SenderSettings senderSettings, IDispatchChannelRegistry <TKey> channelRegistry,
IEnumerable <IDispatchProcessingCommand <TKey> > processingCommands)
: base(logger)
{
_hubState = hubState;
_dispatchQueue = dispatchQueue;
_channelRegistry = channelRegistry;
_processingCommands = processingCommands
.OrderBy(x => x.Order)
.ToArray();
MaxParallelItems = senderSettings.MaxParallelDispatchesProcessed;
}
//init
public EventProcessor(SenderState <TKey> hubState, IMonitor <TKey> eventSink
, ILogger logger, SenderSettings senderSettings
, IEventQueue <TKey> eventQueue, IDispatchQueue <TKey> dispatchQueue
, IEventHandlerRegistry <TKey> handlerRegistry, IEventSettingsQueries <TKey> eventSettingsQueries)
: base(logger)
{
_hubState = hubState;
_monitor = eventSink;
_eventQueue = eventQueue;
_dispatchQueue = dispatchQueue;
_handlerRegistry = handlerRegistry;
_eventSettingsQueries = eventSettingsQueries;
MaxParallelItems = senderSettings.MaxParallelEventsProcessed;
}
/// <summary>
/// ставятся настройки и обновляются все фигуры
/// </summary>
void Start()
{
SetGameSettings();
UpdateFigures();
stateOBJ = GameObject.Find("StateMessanger");
SenderState scriptToAccessOBJ = stateOBJ.GetComponent <SenderState>();
if (scriptToAccessOBJ.color == 1) // если изначальный цвет 1 то мы передаем ход АИ
{
To_AI();
}
}
private void SendCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
SenderState sender = (SenderState)ar.AsyncState;
// Complete sending the data to the remote device.
int bytesSent = sender.Socket.EndSend(ar);
Console.WriteLine("" + localParty.Type + " sent {0} bytes to " + sender.To, bytesSent);
// Signal that all bytes have been sent.
sendDone[sender.To].Set();
}
catch (Exception e)
{
//Console.WriteLine(e.ToString());
}
}
/// <summary>
/// Performs k many 1-out-of-2 OTs on k bits for the sender, where k is the security parameter, using the base OT implementation.
///
/// These are subsequently expanded into m many 1oo2 OTs on arbitrarily long messages
/// by the SendAsync method, where m is only bounded by the amount of secure randomness the random
/// oracle implementation can produce.
/// </summary>
public async Task ExecuteSenderBaseOTAsync()
{
_senderState = new SenderState();
_senderState.RandomChoices = RandomNumberGenerator.GetBits(SecurityParameter);
// retrieve seeds for OT extension via _securityParameter many base OTs
int requiredBytes = BitArray.RequiredBytes(SecurityParameter);
byte[][] seeds = await _baseOT.ReceiveAsync(_senderState.RandomChoices, SecurityParameter, requiredBytes);
Debug.Assert(seeds.Length == SecurityParameter);
// initializing a random oracle based on each seed
_senderState.SeededRandomOracles = new IEnumerable <byte> [SecurityParameter];
for (int k = 0; k < SecurityParameter; ++k)
{
Debug.Assert(seeds[k].Length == requiredBytes);
_senderState.SeededRandomOracles[k] = RandomOracleProvider.Create().Invoke(seeds[k]);
}
}
private void ConnectCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
SenderState sender = (SenderState)ar.AsyncState;
// Complete the connection.
sender.Socket.EndConnect(ar);
// Console.WriteLine("" + localParty.Type + " connected to {0}",
// sender.Socket.RemoteEndPoint.ToString());
// Signal that the connection has been made.
connectDone[sender.To].Set();
}
catch (Exception e)
{
// ConnectCallback(ar);
// Console.WriteLine(e.ToString());
}
}
// Main loop of the sender
public void Run()
{
// Transfer state
SenderState state = SenderState.WaitingForFileRequest;
string requestedFile = "";
IPEndPoint receiver = null;
// This is a handly little function to reset the transfer state
Action ResetTransferState = new Action(() =>
{
state = SenderState.WaitingForFileRequest;
requestedFile = "";
receiver = null;
_blocks.Clear();
});
while (Running)
{
// Check for some new messages
_checkForNetworkMessages();
NetworkMessage nm = (_packetQueue.Count > 0) ? _packetQueue.Dequeue() : null;
// Check to see if we have a BYE
bool isBye = (nm == null) ? false : nm.Packet.IsBye;
if (isBye)
{
// Set back to the original state
ResetTransferState();
Console.WriteLine("Received a BYE message, waiting for next client.");
}
// Do an action depending on the current state
switch (state)
{
case SenderState.WaitingForFileRequest:
// Check to see that we got a file request
// If there was a packet, and it's a request file, send and ACK and switch the state
bool isRequestFile = (nm == null) ? false : nm.Packet.IsRequestFile;
if (isRequestFile)
{
// Prepare the ACK
RequestFilePacket REQF = new RequestFilePacket(nm.Packet);
AckPacket ACK = new AckPacket();
requestedFile = REQF.Filename;
// Print info
Console.WriteLine("{0} has requested file file \"{1}\".", nm.Sender, requestedFile);
// Check that we have the file
if (_transferableFiles.Contains(requestedFile))
{
// Mark that we have the file, save the sender as our current receiver
receiver = nm.Sender;
ACK.Message = requestedFile;
state = SenderState.PreparingFileForTransfer;
Console.WriteLine(" We have it.");
}
else
{
ResetTransferState();
}
// Send the message
byte[] buffer = ACK.GetBytes();
_client.Send(buffer, buffer.Length, nm.Sender);
}
break;
case SenderState.PreparingFileForTransfer:
// Using the requested file, prepare it in memory
byte[] checksum;
UInt32 fileSize;
if (_prepareFile(requestedFile, out checksum, out fileSize))
{
// It's good, send an info Packet
InfoPacket INFO = new InfoPacket();
INFO.Checksum = checksum;
INFO.FileSize = fileSize;
INFO.MaxBlockSize = MaxBlockSize;
INFO.BlockCount = Convert.ToUInt32(_blocks.Count);
// Send it
byte[] buffer = INFO.GetBytes();
_client.Send(buffer, buffer.Length, receiver);
// Move the state
Console.WriteLine("Sending INFO, waiting for ACK...");
state = SenderState.WaitingForInfoACK;
}
else
{
ResetTransferState(); // File not good, reset the state
}
break;
case SenderState.WaitingForInfoACK:
// If it is an ACK and the payload is the filename, we're good
bool isAck = (nm == null) ? false : (nm.Packet.IsAck);
if (isAck)
{
AckPacket ACK = new AckPacket(nm.Packet);
if (ACK.Message == "INFO")
{
Console.WriteLine("Starting Transfer...");
state = SenderState.Transfering;
}
}
break;
case SenderState.Transfering:
// If there is a block request, send it
bool isRequestBlock = (nm == null) ? false : nm.Packet.IsRequestBlock;
if (isRequestBlock)
{
// Pull out data
RequestBlockPacket REQB = new RequestBlockPacket(nm.Packet);
Console.WriteLine("Got request for Block #{0}", REQB.Number);
// Create the response packet
Block block = _blocks[REQB.Number];
SendPacket SEND = new SendPacket();
SEND.Block = block;
// Send it
byte[] buffer = SEND.GetBytes();
_client.Send(buffer, buffer.Length, nm.Sender);
Console.WriteLine("Sent Block #{0} [{1} bytes]", block.Number, block.Data.Length);
}
break;
}
Thread.Sleep(1);
}
// If there was a receiver set, that means we need to notify it to shutdown
if (receiver != null)
{
Packet BYE = new Packet(Packet.Bye);
byte[] buffer = BYE.GetBytes();
_client.Send(buffer, buffer.Length, receiver);
}
state = SenderState.NotRunning;
}
void StoreDataAndNotify(HttpContext context, HttpRequest req, string commitSourceID)
{
string csDataDir = Path.Combine (Path.Combine (Config.Instance.RootPath, "data"), commitSourceID);
if (!Directory.Exists (csDataDir)) {
try {
Directory.CreateDirectory (csDataDir);
} catch (Exception ex) {
Log (ex, "Failed to create data directory '{0}'", csDataDir);
InvalidRequest (context.Response, 500);
return;
}
}
DateTime now = DateTime.Now;
string fileName = Path.Combine (csDataDir, now.Ticks.ToString () + ".json");
try {
using (var writer = new FileStream (fileName, FileMode.Create, FileAccess.Write, FileShare.None)) {
byte[] data = new byte[INPUT_BUFFER_LENGTH];
Stream input = req.InputStream;
int rlen;
while ((rlen = input.Read (data, 0, INPUT_BUFFER_LENGTH)) > 0)
writer.Write (data, 0, rlen);
}
} catch (Exception ex) {
Log (ex, "Failed to write posted data to file '{4}'. Exception '{1}' was caught: '{2}'", fileName);
InvalidRequest (context.Response, 500);
return;
}
var state = new SenderState () {
CsDataDir = csDataDir,
CommitSourceID = commitSourceID
};
ThreadPool.QueueUserWorkItem (Sender, state);
}
void ks_threadSessionStateChanged(SenderState state)
{
switch(state)
{
case SenderState.Started:
toolStrip2.Invoke(new VoidMethod(SetStartedState));
break;
case SenderState.Stopped:
toolStrip2.Invoke(new VoidMethod(SetStoppedState));
break;
default:break;
}
}
private void Send(SenderState sender, byte[] data)
{
// Begin sending the data to the remote device.
sender.Socket.BeginSend(data, 0, data.Length, 0,
new AsyncCallback(SendCallback), sender);
}
// one thread is constantly scan the buffer for all parties
private void FlushBuffer()
{
Dictionary <PartyType, Stopwatch> stopwatch = new Dictionary <PartyType, Stopwatch>();
foreach (var party in msgBuffer.Keys)
{
stopwatch.Add(party, new Stopwatch());
stopwatch[party].Start();
}
while (!receiver.hasReceivedEOP)
{
foreach (var party in msgBuffer.Keys)
{
bool reachBufferThreshold = false, reachTimeThreshold = false;
switch (party)
{
//case PartyType.Client:
// reachBufferThreshold = msgBuffer[party].Count >= Config.Runtime_Network_BufferMessageThresholdClient;
// break;
case PartyType.EVH:
reachBufferThreshold = msgBuffer[party].Count >= Config.Runtime_Network_BufferMessageThresholdEVH;
break;
case PartyType.KH:
reachBufferThreshold = msgBuffer[party].Count >= Config.Runtime_Network_BufferMessageThresholdKH;
break;
case PartyType.Helper:
reachBufferThreshold = msgBuffer[party].Count >= Config.Runtime_Network_BufferMessageThresholdHelper;
break;
default:
break;
}
stopwatch[party].Stop();
reachTimeThreshold = stopwatch[party].ElapsedMilliseconds >= Config.Runtime_Network_TimeThreshold;
stopwatch[party].Start();
if (reachBufferThreshold || reachTimeThreshold)
{
List <byte[]> msgs = msgBuffer[party].Retrieve();
//// if buffer already contains a null referance, which means there will be no more messages
//if (msgBuffer[party].IsComplete)
//{
// // decrement notEmptyBufferCount
// --notEmptyBufferCount;
//}
// once messages are delivered, resart the stopwatch
stopwatch[party].Restart();
// if message buffer is not empty, send the message
if (msgs.Count != 0)
{
try
{
// Create a TCP/IP socket.
Socket socket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
SenderState sender = new SenderState(socket, party);
// Connect to the remote endpoint.
socket.BeginConnect(partyIPMap[party],
new AsyncCallback(ConnectCallback), sender);
connectDone[party].WaitOne();
// send data to remote party
byte[] data = Message.Pack(localParty.Type, msgs);
Send(sender, data);
sendDone[party].WaitOne();
// Release the socket.
socket.Shutdown(SocketShutdown.Both);
socket.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
// break the while(true) loop
break;
}
}
}
}
}
}