public void Invoke(IServiceCall serviceCall, byte channel)
{
FluorineFx.Messaging.Rtmp.Event.Invoke message = new FluorineFx.Messaging.Rtmp.Event.Invoke {
ServiceCall = serviceCall,
InvokeId = this.InvokeId
};
if (serviceCall is IPendingServiceCall)
{
lock (((ICollection)this._pendingCalls).SyncRoot)
{
this._pendingCalls[message.InvokeId] = serviceCall;
}
}
this.GetChannel(channel).Write(message);
}
public override void ConnectionOpened(RtmpConnection connection)
{
try
{
RtmpChannel channel = connection.GetChannel(3);
PendingCall serviceCall = new PendingCall("connect", this._connectArguments);
FluorineFx.Messaging.Rtmp.Event.Invoke message = new FluorineFx.Messaging.Rtmp.Event.Invoke(serviceCall)
{
ConnectionParameters = this._connectionParameters,
InvokeId = connection.InvokeId
};
serviceCall.RegisterCallback(this);
connection.RegisterPendingCall(message.InvokeId, serviceCall);
channel.Write(message);
}
catch (Exception exception)
{
this._netConnection.RaiseNetStatus(exception);
}
}
protected override void OnInvoke(RtmpConnection connection, RtmpChannel channel, RtmpHeader header, Notify invoke)
{
IServiceCall serviceCall = invoke.ServiceCall;
// If it's a callback for server remote call then pass it over to callbacks handler
// and return
if(serviceCall.ServiceMethodName.Equals("_result") || serviceCall.ServiceMethodName.Equals("_error"))
{
HandlePendingCallResult(connection, invoke);
return;
}
bool disconnectOnReturn = false;
string action = null;
if (serviceCall.ServiceName == null)
{
action = serviceCall.ServiceMethodName;
switch (action)
{
case ACTION_CONNECT:
{
if (!connection.IsConnected)
{
IDictionary parameters = invoke.ConnectionParameters;
string host = null;
if( parameters.Contains("tcUrl") )
host = GetHostname(parameters["tcUrl"] as string);
if (host != null && host.IndexOf(":") != -1)
{
// Remove default port from connection string
host = host.Substring(0, host.IndexOf(":"));
}
string app = parameters["app"] as string;
string path = parameters["app"] as string;
// App name as path, but without query string if there is one
if (path != null && path.IndexOf("?") != -1)
{
int idx = path.IndexOf("?");
parameters["queryString"] = path.Substring(idx);
path = path.Substring(0, idx);
}
parameters["path"] = path;
connection.Setup(host, path, parameters);
try
{
//IGlobalScope global = this.Endpoint.LookupGlobal(host, path);
IGlobalScope global = this.Endpoint.GetMessageBroker().GlobalScope;
if (global == null)
{
serviceCall.Status = Call.STATUS_SERVICE_NOT_FOUND;
if (serviceCall is IPendingServiceCall)
{
StatusASO status = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_INVALID_APPLICATION, connection.ObjectEncoding);
status.description = "No global scope on this server.";
(serviceCall as IPendingServiceCall).Result = status;
}
log.Info(string.Format("No application scope found for {0} on host {1}. Misspelled or missing application folder?", path, host));
disconnectOnReturn = true;
}
else
{
IScopeContext context = global.Context;
IScope scope = null;
try
{
scope = context.ResolveScope(global, path);
}
catch (ScopeNotFoundException /*exception*/)
{
if (log.IsErrorEnabled)
log.Error(__Res.GetString(__Res.Scope_NotFound, path));
serviceCall.Status = Call.STATUS_SERVICE_NOT_FOUND;
if (serviceCall is IPendingServiceCall)
{
StatusASO status = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_REJECTED, connection.ObjectEncoding);
status.description = "No scope \"" + path + "\" on this server.";
(serviceCall as IPendingServiceCall).Result = status;
}
disconnectOnReturn = true;
}
catch (ScopeShuttingDownException)
{
serviceCall.Status = Call.STATUS_APP_SHUTTING_DOWN;
if (serviceCall is IPendingServiceCall)
{
StatusASO status = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_APPSHUTDOWN, connection.ObjectEncoding);
status.description = "Application at \"" + path + "\" is currently shutting down.";
(serviceCall as IPendingServiceCall).Result = status;
}
log.Info(string.Format("Application at {0} currently shutting down on {1}", path, host));
disconnectOnReturn = true;
}
if (scope != null)
{
if (log.IsInfoEnabled)
log.Info(__Res.GetString(__Res.Scope_Connect, scope.Name));
bool okayToConnect;
try
{
//The only way to differentiate NetConnection.connect() and Consumer.subscribe() seems to be the app name
if (app == string.Empty)
{
connection.SetIsFlexClient(true);
okayToConnect = connection.Connect(scope, serviceCall.Arguments);
if (okayToConnect)
{
if (serviceCall.Arguments != null && serviceCall.Arguments.Length >= 3)
{
string credentials = serviceCall.Arguments[2] as string;
if (credentials != null && credentials != string.Empty)
{
MessageBroker messageBroker = this.Endpoint.GetMessageBroker();
AuthenticationService authenticationService = messageBroker.GetService(AuthenticationService.ServiceId) as AuthenticationService;
authenticationService.Authenticate(credentials);
}
}
//FDS 2.0.1 fds.swc
if (serviceCall.Arguments != null && serviceCall.Arguments.Length == 1)
{
string credentials = serviceCall.Arguments[0] as string;
if (credentials != null && credentials != string.Empty)
{
MessageBroker messageBroker = this.Endpoint.GetMessageBroker();
AuthenticationService authenticationService = messageBroker.GetService(AuthenticationService.ServiceId) as AuthenticationService;
authenticationService.Authenticate(credentials);
}
}
}
}
else
{
connection.SetIsFlexClient(false);
okayToConnect = connection.Connect(scope, serviceCall.Arguments);
}
if (okayToConnect)
{
if (log.IsDebugEnabled)
log.Debug("Connected RtmpClient: " + connection.Client.Id);
serviceCall.Status = Call.STATUS_SUCCESS_RESULT;
if (serviceCall is IPendingServiceCall)
{
StatusASO statusASO = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_SUCCESS, connection.ObjectEncoding);
statusASO.Add("id", connection.Client.Id);
(serviceCall as IPendingServiceCall).Result = statusASO;
}
// Measure initial roundtrip time after connecting
connection.GetChannel((byte)2).Write(new Ping(Ping.StreamBegin, 0, -1));
connection.StartRoundTripMeasurement();
}
else
{
if (log.IsDebugEnabled)
log.Debug("Connect failed");
serviceCall.Status = Call.STATUS_ACCESS_DENIED;
if (serviceCall is IPendingServiceCall)
(serviceCall as IPendingServiceCall).Result = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_REJECTED, connection.ObjectEncoding);
disconnectOnReturn = true;
}
}
catch (ClientRejectedException rejected)
{
if (log.IsDebugEnabled)
log.Debug("Connect rejected");
serviceCall.Status = Call.STATUS_ACCESS_DENIED;
if (serviceCall is IPendingServiceCall)
{
StatusASO statusASO = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_REJECTED, connection.ObjectEncoding);
statusASO.Application = rejected.Reason;
(serviceCall as IPendingServiceCall).Result = statusASO;
}
disconnectOnReturn = true;
}
}
}
}
catch (Exception ex)
{
if (log.IsErrorEnabled)
log.Error("Error connecting", ex);
serviceCall.Status = Call.STATUS_GENERAL_EXCEPTION;
if (serviceCall is IPendingServiceCall)
(serviceCall as IPendingServiceCall).Result = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_FAILED, connection.ObjectEncoding);
disconnectOnReturn = true;
}
}
else
{
// Service calls, must be connected.
InvokeCall(connection, serviceCall);
}
}
break;
case ACTION_DISCONNECT:
connection.Close();
break;
case ACTION_CREATE_STREAM:
case ACTION_DELETE_STREAM:
case ACTION_RELEASE_STREAM:
case ACTION_PUBLISH:
case ACTION_PLAY:
case ACTION_SEEK:
case ACTION_PAUSE:
case ACTION_CLOSE_STREAM:
case ACTION_RECEIVE_VIDEO:
case ACTION_RECEIVE_AUDIO:
{
IStreamService streamService = ScopeUtils.GetScopeService(connection.Scope, typeof(IStreamService)) as IStreamService;
StatusASO status = null;
try
{
if (!InvokeCall(connection, serviceCall, streamService))
{
status = StatusASO.GetStatusObject(StatusASO.NS_INVALID_ARGUMENT, connection.ObjectEncoding);
status.description = "Failed to " + action + " (stream ID: " + header.StreamId + ")";
}
}
catch (Exception ex)
{
log.Error("Error while invoking " + action + " on stream service.", ex);
status = StatusASO.GetStatusObject(StatusASO.NS_FAILED, connection.ObjectEncoding);
status.description = "Error while invoking " + action + " (stream ID: " + header.StreamId + ")";
status.details = ex.Message;
}
if (status != null)
channel.SendStatus(status);
}
break;
default:
if (connection.IsConnected)
InvokeCall(connection, serviceCall);
else
{
// Warn user attemps to call service without being connected
if (log.IsWarnEnabled)
log.Warn("Not connected, closing connection");
connection.Close();
}
break;
}
}
/*
if(invoke is FlexInvoke)
{
FlexInvoke reply = new FlexInvoke();
reply.InvokeId = invoke.InvokeId;
reply.SetResponseSuccess();
//TODO
if( serviceCall is IPendingServiceCall )
{
IPendingServiceCall pendingCall = (IPendingServiceCall)serviceCall;
reply.Response = pendingCall.Result;
}
channel.Write(reply);
}
else if(invoke is Invoke)
*/
if (invoke is Invoke)
{
if((header.StreamId != 0)
&& (serviceCall.Status == Call.STATUS_SUCCESS_VOID || serviceCall.Status == Call.STATUS_SUCCESS_NULL))
{
if (log.IsDebugEnabled)
log.Debug("Method does not have return value, do not reply");
return;
}
// The client expects a result for the method call.
Invoke reply = new Invoke();
reply.ServiceCall = serviceCall;
reply.InvokeId = invoke.InvokeId;
//sending reply
channel.Write(reply);
}
if (disconnectOnReturn)
{
connection.Close();
}
if (action == ACTION_CONNECT)
{
connection.Context.ObjectEncoding = connection.ObjectEncoding;
}
}
static ByteBuffer EncodeInvoke(RtmpContext context, Invoke invoke)
{
return EncodeNotifyOrInvoke(context, invoke);
}
public IMessage PullMessage(IPipe pipe)
{
lock (_syncLock)
{
if (_pipe != pipe)
return null;
if (_reader == null)
Init();
if (!_reader.HasMoreTags())
{
// TODO send OOBCM to notify EOF
// Do not unsubscribe as this kills VOD seek while in buffer
// this.pipe.unsubscribe(this);
return null;
}
ITag tag = _reader.ReadTag();
IRtmpEvent msg = null;
int timestamp = tag.Timestamp;
switch (tag.DataType)
{
case Constants.TypeAudioData:
msg = new AudioData(tag.Body);
break;
case Constants.TypeVideoData:
msg = new VideoData(tag.Body);
break;
case Constants.TypeInvoke:
msg = new Invoke(tag.Body);
break;
case Constants.TypeNotify:
msg = new Notify(tag.Body);
break;
case Constants.TypeFlexStreamEnd:
msg = new FlexStreamSend(tag.Body);
break;
default:
log.Warn("Unexpected type " + tag.DataType);
msg = new Unknown(tag.DataType, tag.Body);
break;
}
msg.Timestamp = timestamp;
RtmpMessage rtmpMsg = new RtmpMessage();
rtmpMsg.body = msg;
return rtmpMsg;
}
}
/// <summary>
/// Sends status notification.
/// </summary>
/// <param name="status">Status object.</param>
public void SendStatus(StatusASO status)
{
bool andReturn = !status.code.Equals(StatusASO.NS_DATA_START);
Invoke invoke;
if (andReturn)
{
PendingCall call = new PendingCall(null, "onStatus", new object[] { status });
invoke = new Invoke();
invoke.InvokeId = 1;
invoke.ServiceCall = call;
}
else
{
Call call = new Call(null, "onStatus", new object[] { status });
invoke = (Invoke)new Notify();
invoke.InvokeId = 1;
invoke.ServiceCall = call;
}
// We send directly to the corresponding stream as for
// some status codes, no stream has been created and thus
// "getStreamByChannelId" will fail.
Write(invoke, _connection.GetStreamIdForChannel(_channelId));
}
/// <summary>
/// Invokes service using service call object and channel.
/// </summary>
/// <param name="serviceCall">Service call object.</param>
/// <param name="channel">Channel to use.</param>
public void Invoke(IServiceCall serviceCall, byte channel)
{
// We need to use Invoke for all calls to the client
Invoke invoke = new Invoke();
invoke.ServiceCall = serviceCall;
invoke.InvokeId = this.InvokeId;
if(serviceCall is IPendingServiceCall)
{
_pendingCalls[invoke.InvokeId] = serviceCall;
}
GetChannel(channel).Write(invoke);
}
private void PingOperation()
{
var Message = RtmpUtil.MakeCommandMessage("", CommandMessage.ClientPingOperation, DSId, new ASObject() { TypeName = null });
var inv = new Invoke();
inv.ServiceCall = new PendingCall(null, "connect", new object[] { false, "nil", "", Message });
inv.ConnectionParameters = new Dictionary<string, object>();
inv.ConnectionParameters.Add("app", "");
inv.ConnectionParameters.Add("flashVer", "WIN 10,1,85,3");
inv.ConnectionParameters.Add("swfUrl", "app:/mod_ser.dat");
inv.ConnectionParameters.Add("tcUrl", "rtmps://" + Server + ":2099");
inv.ConnectionParameters.Add("fpad", false);
inv.ConnectionParameters.Add("capabilities", 239);
inv.ConnectionParameters.Add("audioCodecs", 3191);
inv.ConnectionParameters.Add("videoCodecs", 252);
inv.ConnectionParameters.Add("videoFunction", 1);
inv.ConnectionParameters.Add("pageUrl", null);
inv.ConnectionParameters.Add("objectEncoding", 3);
inv.EventType = (EventType)2;
Notify reply = base.Call(inv);
ASObject args = reply.ServiceCall.Arguments[0] as ASObject;
DSId = args["id"].ToString();
Form1.Log("DSId = " + DSId);
}
protected override void OnInvoke(RtmpConnection connection, RtmpChannel channel, RtmpHeader header, Notify invoke)
{
IServiceCall serviceCall = invoke.ServiceCall;
if ((serviceCall.ServiceMethodName == "_result") || (serviceCall.ServiceMethodName == "_error"))
{
if (serviceCall.ServiceMethodName == "_error")
{
serviceCall.Status = 0x13;
}
if (serviceCall.ServiceMethodName == "_result")
{
serviceCall.Status = 2;
}
base.HandlePendingCallResult(connection, invoke);
}
else if (serviceCall is IPendingServiceCall)
{
IPendingServiceCall call2 = serviceCall as IPendingServiceCall;
MethodInfo methodInfo = MethodHandler.GetMethod(this._netConnection.Client.GetType(), serviceCall.ServiceMethodName, serviceCall.Arguments, false, false);
if (methodInfo != null)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
object[] array = new object[parameters.Length];
serviceCall.Arguments.CopyTo(array, 0);
TypeHelper.NarrowValues(array, parameters);
try
{
object obj2 = new InvocationHandler(methodInfo).Invoke(this._netConnection.Client, array);
if (methodInfo.ReturnType == typeof(void))
{
serviceCall.Status = 4;
}
else
{
serviceCall.Status = (obj2 == null) ? ((byte)3) : ((byte)2);
call2.Result = obj2;
}
}
catch (Exception exception)
{
serviceCall.Exception = exception;
serviceCall.Status = 0x13;
}
}
else
{
string message = __Res.GetString("Invocation_NoSuitableMethod", new object[] { serviceCall.ServiceMethodName });
serviceCall.Status = 0x11;
serviceCall.Exception = new FluorineException(message);
}
if ((serviceCall.Status == 4) || (serviceCall.Status == 3))
{
if (log.get_IsDebugEnabled())
{
log.Debug("Method does not have return value, do not reply");
}
}
else
{
FluorineFx.Messaging.Rtmp.Event.Invoke invoke2 = new FluorineFx.Messaging.Rtmp.Event.Invoke {
ServiceCall = serviceCall,
InvokeId = invoke.InvokeId
};
channel.Write(invoke2);
}
}
}
