コード例 #1
0
ファイル: RtmpChannel.cs プロジェクト: GodLesZ/svn-dump
		/// <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));
		}
コード例 #2
0
ファイル: RtmpConnection.cs プロジェクト: GodLesZ/svn-dump
		/// <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);
		}
コード例 #3
0
		static ByteBuffer EncodeInvoke(RtmpContext context, Invoke invoke) {
			return EncodeNotifyOrInvoke(context, invoke);
		}
コード例 #4
0
ファイル: FileProvider.cs プロジェクト: GodLesZ/svn-dump
		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;
			}
		}
コード例 #5
0
ファイル: RtmpHandler.cs プロジェクト: GodLesZ/svn-dump
		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;
			}
		}