protected override void OnOperationRequest(OperationRequest operationRequest, SendParameters sendParameters)
{
switch (operationRequest.OperationCode)
{
// Echo
case 0:
{
var request = OperationFactory.GetRequest(operationRequest.OperationCode, operationRequest.Parameters) as EchoRequest;
EchoResponse response = new EchoResponse(request.Message);
SendOperationResponse(new OperationResponse(response.OperationCode, response.Parameters), sendParameters);
}
break;
// Delay Echo
case 1:
{
var request = OperationFactory.GetRequest(operationRequest.OperationCode, operationRequest.Parameters) as DelayRequest;
int sleepTime = request.DelayMilliSeconds;
Thread.Sleep(sleepTime);
DelayResponse response = new DelayResponse(request.DelayMilliSeconds, request.Message);
SendOperationResponse(new OperationResponse(response.OperationCode, response.Parameters), sendParameters);
}
break;
}
}
private async Task <MethodResult> SendEcho()
{
try
{
if (_client.Misc == null || !_client.LoggedIn)
{
return(new MethodResult
{
Message = "Client not logged in"
});
}
EchoResponse response = await _client.Misc.SendEcho();
return(new MethodResult
{
Message = response.Context,
Success = true
});
}
catch (Exception)
{
LogCaller(new LoggerEventArgs("Echo failed", LoggerTypes.Warning));
return(new MethodResult
{
Message = "Echo failed"
});
}
}
public async Task <EchoResponse> Echo()
{
var client = new RestClient();
//client.BaseUrl = BaseUri;
var request = new RestRequest("echo");
client.BaseUrl = BaseUri;
request.Timeout = 2000;
EchoResponse get_Echo = new EchoResponse();
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
get_Echo = JsonConvert.DeserializeObject <EchoResponse>(client.Execute(request).Content);
}
catch (JsonException e)
{
get_Echo = new EchoResponse(Name, "Invalid respose", e.Message, DateTime.Now.ToString());
}
get_Echo = get_Echo ?? new EchoResponse(Name, "Network problem", "Node not found", DateTime.Now.ToString());
//if (getEcho. != null)
// getEcho = new EchoResponse(Name, "Network problem", getEcho.ErrorMessage, DateTime.Now.ToString());
sw.Stop();
get_Echo.responseTime = sw.Elapsed;
LastEchoStatus = get_Echo;
return(get_Echo);
}
public async Task TestSendIntegerArray()
{
// Parameters for the API call
List <int> integers = APIHelper.JsonDeserialize <List <int> >("[1,2,3,4,5]");
// Perform API call
EchoResponse result = null;
try
{
result = await controller.SendIntegerArrayAsync(integers);
}
catch (APIException) {};
// Test response code
Assert.AreEqual(200, httpCallBackHandler.Response.StatusCode,
"Status should be 200");
// Test whether the captured response is as we expected
Assert.IsNotNull(result, "Result should exist");
Assert.IsTrue(TestHelper.IsJsonObjectProperSubsetOf(
"{\"path\":\"/1/2/3/4/5\"}",
TestHelper.ConvertStreamToString(httpCallBackHandler.Response.RawBody),
true, true, false),
"Response body should have matching keys");
}
public override Task <EchoResponse> Echo(EchoRequest request, ServerCallContext context)
{
EchoResponse response = new EchoResponse {
Name = request.Name, Message = request.Message
};
return(Task.FromResult(response));
}
public ValueTask <EchoResponse> EchoMessage(EchoRequest request)
{
var response = new EchoResponse()
{
Message = $"Echo {request.Message}"
};
return(new ValueTask <EchoResponse>(response));
}
internal static EchoResponse GetUnsolicitedEchoResponse()
{
// [MS-SMB2] 3.2.5.1.2 - If the MessageId is 0xFFFFFFFFFFFFFFFF, this is not a reply to a previous request, and the client MUST NOT attempt to locate the request, but instead process it as follows:
// If the command field in the SMB2 header is SMB2 OPLOCK_BREAK, it MUST be processed as specified in 3.2.5.19. Otherwise, the response MUST be discarded as invalid.
EchoResponse response = new EchoResponse();
response.Header.MessageID = 0xFFFFFFFFFFFFFFFF;
return(response);
}
public EchoResponse Echo()
{
ToastHelper.PopToast("Echo");
var response = new EchoResponse();
response.Message = "Message";
return(response);
}
public IHttpActionResult GetEcho(string Message, string RequestID, string SessionToken)
{
EchoResponse response = new EchoResponse();
response.Payload.Message = "Echo 2: " + Message;
response.Success = true;
return(Ok(response));
}
public override Task <EchoResponse> EchoMessage(EchoRequest request, ServerCallContext context)
{
var responseMessage = $"Echo: {request.Name}";
var echoResponse = new EchoResponse {
Name = responseMessage
};
return(Task.FromResult <EchoResponse>(echoResponse));
}
public override Task <EchoResponse> ReverseEcho(EchoRequest request,
ServerCallContext context)
{
var response = new EchoResponse()
{
Original = request.Text, Result = request.Text.Reverse()
};
return(Task.FromResult(response));
}
public IActionResult Echo(EchoRequest request)
{
EchoResponse response = new EchoResponse()
{
Message = request.Message,
SentDt = DateTime.UtcNow
};
IActionResult result = Ok(response);
return(result);
}
public async Task <ActionResult <ServiceDescriptor> > Get()
{
foreach (var feature in this.features.Safe())
{
if (!feature.EchoRoute.IsNullOrEmpty() && !feature.EchoRoute.StartsWith("http"))
{
feature.EchoRoute = this.Url.AbsolutePath(feature.EchoRoute);
}
}
var result = new EchoResponse
{
Service = this.serviceDescriptor,
Request = new Dictionary <string, object> // TODO: replace with RequestCorrelationContext
{
["correlationId"] = this.HttpContext.GetCorrelationId(),
["requestId"] = this.HttpContext.GetRequestId(),
["isLocal"] = this.HttpContext.Request.IsLocal(),
["host"] = Dns.GetHostName(),
["ip"] = (await Dns.GetHostAddressesAsync(Dns.GetHostName())).Select(i => i.ToString()).Where(i => i.Contains("."))
//["userIdentity"] = serviceContext.UserIdentity,
//["username"] = serviceContext.Username
},
Runtime = new Dictionary <string, string>
{
// TODO: get these endpoints through DI for all active capabilities
["name"] = Assembly.GetEntryAssembly().GetName().Name,
["version"] = Assembly.GetEntryAssembly().GetName().Version.ToString(),
["buildDate"] = Assembly.GetEntryAssembly().GetBuildDate().ToString("o")
},
Actions = new Dictionary <string, string>
{
// TODO: get these endpoints through DI for all active capabilities
["index"] = this.Url.AbsolutePath("index.html"),
["logevents-ui"] = this.Url.AbsolutePath("api/operations/logevents/dashboard"),
["swagger-ui"] = this.Url.AbsolutePath("swagger/index.html"),
["swagger"] = this.Url.AbsolutePath("swagger/v1/swagger.json"),
["health"] = this.Url.AbsolutePath("health"),
// TODO: discover below
["sample-logevents"] = this.Url.AbsolutePath("api/operations/logevents"),
["sample-logevents2"] = this.Url.AbsolutePath("api/operations/logevents?q=Ticks=gt:636855734000000000,Environment=Development"),
["sample-countries1"] = this.Url.AbsolutePath("api/countries?q=name=Belgium&order=name&take=1"),
["sample-countries2"] = this.Url.AbsolutePath("api/countries?q=name=Belgium"),
["sample-customers1"] = this.Url.AbsolutePath("api/customers?q=region=East,state.createdDate=ge:2010-01-01&order=lastName"),
["sample-customers2"] = this.Url.AbsolutePath("api/customers?q=region=East,state.createdDate=ge:2010-01-01"),
["sample-useraccounts1"] = this.Url.AbsolutePath("api/useraccounts?q=visitCount=ge:1&order=email&take=10"),
["sample-useraccounts2"] = this.Url.AbsolutePath("api/useraccounts?q=visitCount=ge:1"),
},
Features = this.features
};
return(this.Ok(result));
}
public IActionResult Echo(EchoRequest request)
{
EchoResponse echoResp = new EchoResponse()
{
Reponse = request.Message,
Processed = DateTime.Now
};
logger.LogInformation($"Echo: '{request.Message}' processed");
return(Ok(JsonConvert.SerializeObject(echoResp, Formatting.Indented)));
}
public HttpResponseMessage Echo(EchoRequest request)
{
EchoResponse echoResp = new EchoResponse()
{
Reponse = request.Message
};
HttpResponseMessage response = new HttpResponseMessage();
response.StatusCode = HttpStatusCode.OK;
response.Content = new StringContent(JsonConvert.SerializeObject(echoResp));
return(response);
}
internal static List <SMB1Command> GetEchoResponse(EchoRequest request)
{
List <SMB1Command> response = new List <SMB1Command>();
for (int index = 0; index < request.EchoCount; index++)
{
EchoResponse echo = new EchoResponse();
echo.SequenceNumber = (ushort)index;
echo.Data = request.Data;
response.Add(echo);
}
return(response);
}
public object Any(Sanitize request)
{
_logger.Log(EErrorType.Info, " ****** Call start: Sanitize");
EchoResponse response = new EchoResponse();
try
{
TransferHeader(request, response);
if (IsValidSessionToken(request))
{
if (ConfigurationManager.AppSettings["CanSanitize"] != null && bool.Parse(ConfigurationManager.AppSettings["CanSanitize"]))
{
TechUtils tu = new TechUtils();
tu.Sanitize();
_logger.Log(EErrorType.Info, string.Format("Sanitization started"));
}
else
{
_logger.Log(EErrorType.Warning, string.Format("Sanitization not allowed - start cancelled"));
}
response.Success = true;
}
else
{
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.InvalidSession, Type = EErrorType.Error, Message = "Invalid session token"
});
}
}
catch (Exception ex)
{
_logger.Log(ex);
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.GeneralError,
Type = EErrorType.Error,
Message = string.Format("Unpexcted error: {0}", ex.Message)
});
}
_logger.Log(EErrorType.Info, " ****** Call end: Sanitize");
return(response);
}
internal static EchoResponse GetEchoResponse(EchoRequest request, List <SMBCommand> sendQueue)
{
EchoResponse response = new EchoResponse();
response.SequenceNumber = 0;
response.SMBData = request.SMBData;
for (int index = 1; index < request.EchoCount; index++)
{
EchoResponse echo = new EchoResponse();
echo.SequenceNumber = (ushort)index;
echo.SMBData = request.SMBData;
sendQueue.Add(echo);
}
return(response);
}
public object Any(ClearLayer request)
{
_logger.Log(EErrorType.Info, " ****** Call start: ClearLayer");
EchoResponse response = new EchoResponse();
try
{
TransferHeader(request, response);
if (IsValidSessionToken(request))
{
string checkFlag = "CanClear" + request.LayerCode;
if (ConfigurationManager.AppSettings[checkFlag] != null && bool.Parse(ConfigurationManager.AppSettings[checkFlag]))
{
TechUtils tu = new TechUtils();
tu.ClearLayer(request.LayerCode);
}
_logger.Log(EErrorType.Info, string.Format("ClearLayer started"));
response.Success = true;
}
else
{
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.InvalidSession, Type = EErrorType.Error, Message = "Invalid session token"
});
}
}
catch (Exception ex)
{
_logger.Log(ex);
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.GeneralError,
Type = EErrorType.Error,
Message = string.Format("Unpexcted error: {0}", ex.Message)
});
}
_logger.Log(EErrorType.Info, " ****** Call end: ClearLayer");
return(response);
}
public EchoResponse echo(EchoRequest request)
{
var response = new EchoResponse();
response.Success = true;
try
{
response.Message = "Hello " + request.message;
}
catch (Exception ex)
{
response.ErrorCode = ErrorCodes.WebServiceCall;
response.Message = ex.Message;
response.Success = false;
}
return(response);
}
public IHttpActionResult GetEcho(string Message, string RequestID, string SessionToken)
{
//ThreadPool.SetMinThreads(100, 10);
EchoResponse response = new EchoResponse();
try
{
string echo2Resp = string.Empty;
using (var client = new HttpClient())
{
/*
* var sResp = client.DownloadString("http://192.168.0.103/api/echoservice2/Echo/" + Message +"/2/3");
*/
var sResp = client.GetAsync("http://localhost/api/echoservice2/Echo/" + Message + "/2/3");
sResp.Wait();
var result = sResp.Result;
if (result.IsSuccessStatusCode)
{
var readTask = result.Content.ReadAsAsync <EchoResponse>();
readTask.Wait();
var echoResponse = readTask.Result;
echo2Resp = string.Format("EchoService2 responded - {0}", echoResponse.Payload.Message);
}
}
response.Payload.Message = "Echo: " + echo2Resp;
response.Success = true;
}
catch (Exception ex)
{
response.Payload.Message = "Echo: Error!";
response.Errors.Add(new Error()
{
Code = EErrorCodes.GeneralError, Type = EErrorType.Error, Message = ex.Message
});
response.Success = false;
}
return(Ok(response));
}
/// <summary> Perform a call to bwsService.echo(). </summary>
/// <returns>Returns true if echo is successful, and false otherwise.</returns>
private static bool echo()
{
const string METHOD_NAME = "echo()";
const string BWS_API_NAME = "bwsService.echo()";
logMessage("Entering {0}", METHOD_NAME);
bool returnValue = true;
EchoRequest request = new EchoRequest();
EchoResponse response = null;
request.metadata = REQUEST_METADATA;
request.text = "Hello World!";
try
{
logRequest(BWS_API_NAME);
response = bwsService.echo(request);
logResponse(BWS_API_NAME, response.returnStatus.code, response.metadata);
}
catch (WebException e)
{
if (e.Status == WebExceptionStatus.ProtocolError)
{
HttpWebResponse httpWebResponse = (HttpWebResponse)e.Response;
if (httpWebResponse != null &&
httpWebResponse.StatusCode == HttpStatusCode.Unauthorized)
{
returnValue = false;
logMessage("Failed to authenticate with the BWS web service");
logMessage("Exiting {0} with value \"{1}\"", METHOD_NAME, returnValue);
return(returnValue);
}
}
// Log and re-throw exception.
logMessage("Exiting {0} with exception \"{1}\"", METHOD_NAME, e.Message);
throw e;
}
logMessage("Exiting {0} with value \"{1}\"", METHOD_NAME, returnValue);
return(returnValue);
}
private static void ThreadEcho()
{
int count = 10;
var rnd = new Random(DateTime.Now.Millisecond);
while (count > 0)
{
try
{
string message = Guid.NewGuid().ToString();
string echoResp = string.Empty;
using (var client = new HttpClient())
{
var sResp = client.GetAsync("http://localhost/api/echoservice/Echo/" + message + "/2/3").Result;
if (sResp.StatusCode == HttpStatusCode.OK)
{
var stringResult = sResp.Content.ReadAsStringAsync().Result;
EchoResponse echoResponse = JsonConvert.DeserializeObject <EchoResponse>(stringResult);
echoResp = echoResponse.Payload.Message;
}
}
Console.WriteLine(string.Format("[{0}] [{1}] Request completed: {2} ",
DateTime.Now,
System.Threading.Thread.CurrentThread.ManagedThreadId,
echoResp));
}
catch (Exception ex)
{
Console.WriteLine(string.Format("[{0}] [{1}] Error: {2} ",
DateTime.Now,
System.Threading.Thread.CurrentThread.ManagedThreadId,
ex.Message));
}
--count;
System.Threading.Thread.Sleep(rnd.Next(100, 500));
}
}
public object Any(Echo request)
{
_logger.Log(EErrorType.Info, " ****** Call start: Echo");
EchoResponse response = new EchoResponse();
try
{
TransferHeader(request, response);
if (IsValidSessionToken(request))
{
_logger.Log(EErrorType.Info, string.Format("Echo message recieved/sent: {0}\t Session: {1}", request.Message, request.SessionToken));
response.Payload.Message = request.Message;
response.Success = true;
}
else
{
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.InvalidSession, Type = EErrorType.Error, Message = "Invalid session token"
});
}
}
catch (Exception ex)
{
_logger.Log(ex);
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.GeneralError,
Type = EErrorType.Error,
Message = string.Format("Unpexcted error: {0}", ex.Message)
});
}
_logger.Log(EErrorType.Info, " ****** Call end: Echo");
return(response);
}
internal static SMB1Message GetUnsolicitedEchoReply()
{
// [MS-CIFS] 3.2.5.1 - If the PID and MID values of the received message are not found in the
// Client.Connection.PIDMIDList, the message MUST be discarded.
SMB1Header header = new SMB1Header();
header.Command = CommandName.SMB_COM_ECHO;
header.Status = NTStatus.STATUS_SUCCESS;
header.Flags = HeaderFlags.CaseInsensitive | HeaderFlags.CanonicalizedPaths | HeaderFlags.Reply;
// [MS-CIFS] SMB_FLAGS2_LONG_NAMES SHOULD be set to 1 when the negotiated dialect is NT LANMAN.
// [MS-CIFS] SMB_FLAGS2_UNICODE SHOULD be set to 1 when the negotiated dialect is NT LANMAN.
header.Flags2 = HeaderFlags2.LongNamesAllowed | HeaderFlags2.NTStatusCode | HeaderFlags2.Unicode;
header.UID = 0xFFFF;
header.TID = 0xFFFF;
header.PID = 0xFFFFFFFF;
header.MID = 0xFFFF;
EchoResponse response = new EchoResponse();
SMB1Message reply = new SMB1Message();
reply.Header = header;
reply.Commands.Add(response);
return(reply);
}
private void HandleEchoRequest(RPCContext context)
{
if (this.m_rpcConnection == null)
{
LogAdapter.Log(LogLevel.Error, "HandleEchoRequest with null RPC Connection");
return;
}
EchoRequest echoRequest = EchoRequest.ParseFrom(context.Payload);
EchoResponse echoResponse = new EchoResponse();
if (echoRequest.HasTime)
{
echoResponse.SetTime(echoRequest.Time);
}
if (echoRequest.HasPayload)
{
echoResponse.SetPayload(echoRequest.Payload);
}
EchoResponse message = echoResponse;
this.m_rpcConnection.QueueResponse(context, message);
Console.WriteLine(string.Empty);
Console.WriteLine("[*]send echo response");
}
public override void CallServerMethod(uint token, uint methodId, CodedInputStream stream)
{
switch (methodId)
{
case 1:
{
ConnectRequest request = ConnectRequest.Parser.ParseFrom(stream);
ConnectResponse response = new ConnectResponse();
BattlenetRpcErrorCode status = HandleConnect(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Connect(bgs.protocol.connection.v1.ConnectRequest: {1}) returned bgs.protocol.connection.v1.ConnectResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 2:
{
BindRequest request = new BindRequest();
request.MergeFrom(stream);
BindResponse response = new BindResponse();
BattlenetRpcErrorCode status = HandleBind(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Bind(bgs.protocol.connection.v1.BindRequest: {1}) returned bgs.protocol.connection.v1.BindResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 3:
{
EchoRequest request = new EchoRequest();
request.MergeFrom(stream);
EchoResponse response = new EchoResponse();
BattlenetRpcErrorCode status = HandleEcho(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Echo(bgs.protocol.connection.v1.EchoRequest: {1}) returned bgs.protocol.connection.v1.EchoResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 4:
{
DisconnectNotification request = DisconnectNotification.Parser.ParseFrom(stream);
BattlenetRpcErrorCode status = HandleForceDisconnect(request);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.ForceDisconnect(bgs.protocol.connection.v1.DisconnectNotification: {1}) status: {2}.",
GetCallerInfo(), request.ToString(), status);
if (status != 0)
{
SendResponse(token, status);
}
break;
}
case 5:
{
NoData request = NoData.Parser.ParseFrom(stream);
BattlenetRpcErrorCode status = HandleKeepAlive(request);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.KeepAlive(bgs.protocol.NoData: {1}) status: {2}.",
GetCallerInfo(), request.ToString(), status);
if (status != 0)
{
SendResponse(token, status);
}
break;
}
case 6:
{
EncryptRequest request = EncryptRequest.Parser.ParseFrom(stream);
NoData response = new NoData();
BattlenetRpcErrorCode status = HandleEncrypt(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Encrypt(bgs.protocol.connection.v1.EncryptRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 7:
{
DisconnectRequest request = DisconnectRequest.Parser.ParseFrom(stream);
BattlenetRpcErrorCode status = HandleRequestDisconnect(request);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.RequestDisconnect(bgs.protocol.connection.v1.DisconnectRequest: {1}) status: {2}.",
GetCallerInfo(), request.ToString(), status);
if (status != 0)
{
SendResponse(token, status);
}
break;
}
default:
Log.outError(LogFilter.ServiceProtobuf, "Bad method id {0}.", methodId);
SendResponse(token, BattlenetRpcErrorCode.RpcInvalidMethod);
break;
}
}
/// <summary> /// Provides a safe way to invoke the <see cref="EchoReceived" /> event. /// </summary> /// <param name="value"></param> public void RaiseEchoReceived(EchoResponse value) => EchoReceived?.Invoke(this, value);
BattlenetRpcErrorCode HandleEcho(EchoRequest request, EchoResponse response)
{
Log.outError(LogFilter.ServiceProtobuf, "{0} Client tried to call not implemented method ConnectionService.Echo: {1}", GetCallerInfo(), request.ToString());
return(BattlenetRpcErrorCode.RpcNotImplemented);
}
public EchoResponse PostEcho(Echo request)
{
EchoResponse response = Post <Echo, EchoResponse>("Echo", request);
return(response);
}
