public TLMessage34 GetMessage(TLObject With, TLInputPeerBase Peer, TLString text, TLMessageMediaBase media) { var broadcast = With as TLBroadcastChat; var channel = With as TLChannel; var toId = channel != null ? new TLPeerChannel { Id = channel.Id } : broadcast != null ? new TLPeerBroadcast { Id = broadcast.Id } : TLUtils.InputPeerToPeer(Peer, StateService.CurrentUserId); var date = TLUtils.DateToUniversalTimeTLInt(MTProtoService.ClientTicksDelta, DateTime.Now); var message = TLUtils.GetMessage( new TLInt(StateService.CurrentUserId), toId, broadcast != null && channel == null ? MessageStatus.Broadcast : MessageStatus.Sending, TLBool.True, TLBool.True, date, text, media, TLLong.Random(), new TLInt(0) ); return(message); }
public void SendRequestAsync <T>(string caption, TLObject obj, int dcId, bool cdn, Action <T> callback, Action <TLRPCError> faultCallback = null) { Debug.WriteLine("Sending " + caption); var flags = RequestFlag.ForceDownload | RequestFlag.FailOnServerError; if (cdn) { flags |= RequestFlag.EnableUnauthorized; } try { var messageToken = _connectionManager.SendRequest(obj, (message, ex) => { if (message.Object is TLRPCError error) { faultCallback?.Invoke(error); } else if (message.Object is TLUnparsedObject unparsed) { callback?.Invoke(TLFactory.Read <T>(unparsed.Reader, unparsed.Constructor)); } else { callback?.Invoke((T)(object)message.Object); } }, null, dcId, ConnectionType.Download, flags); } catch { } }
public UploadableItem(TLLong fileId, TLObject owner, string isoFileName, long isoFileLength) { FileId = fileId; Owner = owner; IsoFileName = isoFileName; IsoFileLength = isoFileLength; }
private UploadableItem GetUploadableItem(TLLong fileId, TLObject owner, string fileName, long fileLength, IList <UploadablePart> parts) { var item = new UploadableItem(fileId, owner, fileName, fileLength); item.Parts = GetItemParts(item, fileLength, parts); return(item); }
public override void OnSend(BinaryWriter writer) { writer.Write(requestCode); TLObject.WriteVector(writer, contacts); Serializers.Bool.Write(writer, replace); }
public ChooseAttachmentViewModel(TLObject with, Action <TLUserBase> openInlineBotAction, Action <StorageFile> sendDocumentAction, Action <StorageFile> sendVideoAction, Action <IReadOnlyList <StorageFile> > sendPhotosAction, System.Action sendLocationAction, System.Action sendContactAction, ICacheService cacheService, ITelegramEventAggregator eventAggregator, INavigationService navigationService, IStateService stateService, bool contactEnabled = true) { InlineBots = new ObservableCollection <TLUserBase>(); _with = with; _openInlineBotAction = openInlineBotAction; _sendDocumentAction = sendDocumentAction; _sendVideoAction = sendVideoAction; _sendPhotosAction = sendPhotosAction; _sendLocationAction = sendLocationAction; _sendContactAction = sendContactAction; _cacheService = cacheService; _stateService = stateService; _navigationService = navigationService; _eventAggregator = eventAggregator; _contactEnabled = contactEnabled; _eventAggregator.Subscribe(this); }
public void DownloadFile(TLEncryptedFile file, TLObject owner) { var inputFile = new TLInputEncryptedFileLocation { Id = file.Id, AccessHash = file.AccessHash }; var downloadableItem = GetDownloadableItem(file.DCId, inputFile, owner, file.Size); lock (_itemsSyncRoot) { bool addFile = true; foreach (var item in _items) { if (item.InputEncryptedFileLocation.LocationEquals(inputFile)) { addFile = false; break; } } if (addFile) { _items.Add(downloadableItem); } } StartAwaitingWorkers(); }
private UploadableItem GetUploadableItem(long fileId, TLObject owner, string isoFileName, long isoFileLength) { var item = new UploadableItem(fileId, owner, isoFileName, isoFileLength); item.Parts = GetItemParts(item, isoFileLength); return(item); }
private void DeleteMessagesInternal(TLObject owner, TLMessageBase lastMessage, IList <TLMessageBase> messages) { var ids = new TLVector <TLInt>(); for (int i = 0; i < messages.Count; i++) { ids.Add(messages[i].Id); } // duplicate: deleting performed through updates CacheService.DeleteMessages(ids); BeginOnUIThread(() => { for (var i = 0; i < messages.Count; i++) { for (var j = 0; j < Items.Count; j++) { var dialog = Items[j] as TLDialog; if (dialog != null && dialog.TopMessage != null && dialog.TopMessage.Id.Value == messages[i].Index) { Items.RemoveAt(j); break; } } } }); EventAggregator.Publish(new DeleteMessagesEventArgs { Owner = owner, Messages = messages }); }
public EditVideoViewModel(Action <CompressingVideoFile> sendVideoAction, Func <string, IList <TLUserBase> > getUsernameHints, TLObject with) { _with = with; _getUsernameHints = getUsernameHints; _sendVideoAction = sendVideoAction; PropertyChanged += (sender, args) => { if (Property.NameEquals(args.PropertyName, () => SelectedQuality)) { UpdateEditedVideoParameters(); NotifyOfPropertyChange(() => EditedVideoParameters); } else if (Property.NameEquals(args.PropertyName, () => IsMuteEnabled)) { UpdateEditedVideoParameters(); NotifyOfPropertyChange(() => EditedVideoParameters); } else if (Property.NameEquals(args.PropertyName, () => Caption)) { LoadMentionHints(Caption); } }; }
public override void OnSend(BinaryWriter writer) { writer.Write(requestCode); TLObject.WriteVector(writer, messages, writer.Write); writer.Write(pts); }
private void SendDocumentInternal(StorageFile storageFile, TLObject obj) { var message = GetDecryptedMessage(obj); if (message == null) { return; } var media = message.Media as TLDecryptedMessageMediaDocument; if (media == null) { return; } var file = media.File as TLEncryptedFile; if (file == null) { return; } UploadDocumentFileManager.UploadFile(file.Id, obj, storageFile, media.Key, media.IV); }
public void DownloadFile(TLFileLocation file, TLObject owner, TLInt fileSize) { var downloadableItem = GetDownloadableItem(file, owner, fileSize); lock (_itemsSyncRoot) { bool addFile = true; foreach (var item in _items) { if (item.Location.VolumeId.Value == file.VolumeId.Value && item.Location.LocalId.Value == file.LocalId.Value && item.Owner == owner) { addFile = false; break; } } if (addFile) { _items.Add(downloadableItem); } } StartAwaitingWorkers(); }
/// <summary> /// Attempts to handle the message on our side in the case it's a backend update /// </summary> /// <param name="Message">The update in question</param> /// <returns>True if the message was handled. Otherwise, false.</returns> private async Task <bool> ProcessUpdate(TLObject Message) { Logger.Log(Logger.Level.Info, $"Beginning internal update processing of \"{(string)Message["body"]["_"]}\""); try { if (((int)Message["seqno"] & 0x01) != 0) { Logger.Log(Logger.Level.Debug, $"Adding \"{(long)Message["msg_id"]}\" to be acked"); PendingAcks.Add((long)Message["msg_id"]); } var args = new object[] { this, new TLObjectEventArgs(new TLObject(Message["body"])) }; UpdateReceivedEvent.RaiseEventSafe(ref args); return((Message["body"].Value <string>("_")) switch { "bad_server_salt" => ProcessBadSalt(Message), "bad_msg_notification" => ProcessBadMsgNotification(Message), "future_salts" => ProcessFutureSalts(Message), "gzip_packed" => await ProcessGzipPacked(Message), "msg_container" => ProcessMessageContainer(Message), "msg_detailed_info" => ProcessMessageDetailedInfo(Message), "msg_new_detailed_info" => ProcessNewMessageDetailedInfo(Message), "msg_resend_req" => ProcessMessageResendRequest(Message), "msgs_ack" => ProcessMessageAck(Message), "msgs_all_info" => ProcessMessageInfoAll(Message), "msgs_state_req" => ProcessMessageStateReqest(Message), "new_session_created" => ProcessNewSessionCreated(Message), "pong" => ProcessPong(Message), "rpc_result" => await ProcessRPCResult(Message), _ => true, }); }
private UploadableItem GetUploadableItem(long fileId, TLObject owner, byte[] bytes) { var item = new UploadableItem(fileId, owner, bytes); item.Parts = GetItemParts(item); return(item); }
/// <summary> /// Sends a request to the server asynchronously. This method will either return the response (if applicable) or throw an exception (if applicable) /// </summary> /// <param name="request">The request to send to the server.</param> /// <returns>A Task that must be awaited to get a response.</returns> public Task <TLObject> Send(TLObject request) { // If we aren't even connected, there's no point in trying if (!CommunicationEstablished) { var sad = new RequestFailedException("Failed to send a request to the server because we are not connected", request); Logger.Log(sad); throw sad; } // Wrap the individual request in preparation to send var state = new RequestState(request); // Add to the send queue. SendQueue.Add(state); // Run un-awaited so as to let it process in the background. // This will take any and all messages out of the queue above // package them together in a container (if applicable) and // send to the server Task.Run(async() => { Logger.Log(Logger.Level.Debug, "Starting send process"); await ProcessSendQueue(); }); // Return the task associated with the request state. // When a response is received, the Task will // be resolved and the response returned return(state.Response.Task); }
public void UploadFile(long fileId, TLObject owner, string fileName, bool forceBigFile) { long fileLength = FileUtils.GetLocalFileLength(fileName); if (fileLength <= 0) { return; } var item = GetUploadableItem(fileId, owner, fileName, fileLength); var uploadedCount = item.Parts.Count(x => x.Status == PartStatus.Processed); var count = item.Parts.Count; var isComplete = uploadedCount == count; if (isComplete) { Execute.BeginOnThreadPool(() => _eventAggregator.Publish(item)); } else { lock (_itemsSyncRoot) { _items.Add(item); } StartAwaitingWorkers(); } }
public static void SendEncryptedService(TLEncryptedChat chat, TLObject obj, IMTProtoService mtProtoService, ICacheService cacheService, Action <TLSentEncryptedMessage> callbak) { var message = GetDecryptedServiceMessage(obj); if (message == null) { return; } cacheService.SyncDecryptedMessage(message, chat, cachedMessage => { mtProtoService.SendEncryptedServiceAsync(new TLInputEncryptedChat { AccessHash = chat.AccessHash, ChatId = chat.Id }, message.RandomId, TLUtils.EncryptMessage(obj, chat), result => { callbak.SafeInvoke(result); message.Status = MessageStatus.Confirmed; message.NotifyOfPropertyChange(() => message.Status); cacheService.SyncSendingDecryptedMessage(chat.Id, result.Date, message.RandomId, m => { }); }, error => { message.Status = MessageStatus.Failed; message.NotifyOfPropertyChange(() => message.Status); Execute.ShowDebugMessage("messages.sendServiceEncrypted error " + error); }); }); }
public static bool IsRequired(TLObject obj) { var userBase = obj as TLUserBase; return (userBase is TLUserRequest && !userBase.RemoveUserAction && userBase.Index != 777000); }
public static string ToJsonString(this TLObject obj, bool indented = false, bool escapeString = false) { using var buffer = new ArrayPoolBufferWriter <byte>(512); using var writer = new Utf8JsonWriter(buffer, new JsonWriterOptions { Indented = indented, Encoder = escapeString ? null : notEscapingEncoder }); writer.WriteTLObjectValue(obj); writer.Flush(); return(Encoding.UTF8.GetString(buffer.WrittenSpan)); }
internal static BaseConverter GetConverterForTLObject(TLObject obj) { if (_rtti_map.TryGetValue(obj.GetType(), out var conv)) { return(conv); } throw new ArgumentException($"unknown type {obj.GetType()}"); }
public MultiImageEditorViewModel(Action <IReadOnlyList <StorageFile> > sendPhotosAction, Func <string, IList <TLUserBase> > getUsernameHints, TLObject with) { _with = with; _sendPhotosAction = sendPhotosAction; _getUsernameHints = getUsernameHints; Items = new ObservableCollection <PhotoFile>(); }
private UploadableItem GetUploadableItem(TLLong fileId, TLObject owner, string fileName, long fileLength) { FileUtils.SwitchIdleDetectionMode(false); var item = new UploadableItem(fileId, owner, fileName, fileLength); item.Parts = GetItemParts(item, fileLength); return item; }
/// <summary> /// Computes v based on the following: /// /// v = pow(g, PH2(password, salt1, salt2)) mod p /// </summary> /// <param name="algo">The TLObject from account.getPassword["current_algo"]</param> /// <param name="password">The cloud password that the user provided</param> public static byte[] DigestPasswordHash(TLObject algo, string password) { var g = new BigInteger(algo["g"].ToString()); var PH2 = new BigInteger(1, PasswordHash(algo, password)); var p = new BigInteger(1, (byte[])algo["p"]); return(NumBytesForHash(g.ModPow(PH2, p).ToByteArrayUnsigned())); }
private void RemoveActionInfoFromFile(TLObject obj) { var actions = GetActionInfoFromFile(); RemoveActionInfoCommon(actions, obj); SaveActionInfoToFile(actions); }
private void SendInformativeMessage <T>(string caption, TLObject obj, Action <T> callback, Action <TLRPCError> faultCallback = null, int?maxAttempt = null, // to send delayed items Action <int> attemptFailed = null) // to send delayed items { Execute.BeginOnThreadPool(() => { SendInformativeMessageInternal(caption, obj, callback, faultCallback, maxAttempt, attemptFailed); }); }
public override TLObject FromBytes(byte[] bytes, ref int position) { bytes.ThrowExceptionIfIncorrect(ref position, Signature); RequestMessageId = GetObject <TLLong>(bytes, ref position); Object = GetObject <TLObject>(bytes, ref position); return(this); }
public UploadableItem(TLLong fileId, TLObject owner, StorageFile file, TLString key, TLString iv) { FileId = fileId; Owner = owner; File = file; Key = key; IV = iv; }
public static bool IsRequired(TLObject obj) { var userBase = obj as TLUserBase; return (userBase != null && userBase.IsRequest && !userBase.RemoveUserAction && userBase.Index != Constants.TelegramNotificationsId); }
// return big-endian authKey public static byte[] GetAuthKey(byte[] bBytes, byte[] g_aData, byte[] dhPrimeData) { int position = 0; var b = new BigInteger(bBytes.Reverse().Concat(new byte[] { 0x00 }).ToArray()); var dhPrime = TLObject.GetObject <TLString>(dhPrimeData, ref position).ToBigInteger(); position = 0; var g_a = TLObject.GetObject <TLString>(g_aData, ref position).ToBigInteger(); var authKey = BigInteger.ModPow(g_a, b, dhPrime).ToByteArray(); // little endian + (may be) zero last byte //remove last zero byte if (authKey[authKey.Length - 1] == 0x00) { authKey = authKey.SubArray(0, authKey.Length - 1); } authKey = authKey.Reverse().ToArray(); if (authKey.Length > 256) { #if DEBUG var authKeyInfo = new StringBuilder(); authKeyInfo.AppendLine("auth_key length > 256: " + authKey.Length); authKeyInfo.AppendLine("g_a=" + g_a); authKeyInfo.AppendLine("b=" + b); authKeyInfo.AppendLine("dhPrime=" + dhPrime); Execute.ShowDebugMessage(authKeyInfo.ToString()); #endif var correctedAuth = new byte[256]; Array.Copy(authKey, authKey.Length - 256, correctedAuth, 0, 256); authKey = correctedAuth; } else if (authKey.Length < 256) { #if DEBUG var authKeyInfo = new StringBuilder(); authKeyInfo.AppendLine("auth_key length < 256: " + authKey.Length); authKeyInfo.AppendLine("g_a=" + g_a); authKeyInfo.AppendLine("b=" + b); authKeyInfo.AppendLine("dhPrime=" + dhPrime); Execute.ShowDebugMessage(authKeyInfo.ToString()); #endif var correctedAuth = new byte[256]; Array.Copy(authKey, 0, correctedAuth, 256 - authKey.Length, authKey.Length); for (var i = 0; i < 256 - authKey.Length; i++) { authKey[i] = 0; } authKey = correctedAuth; } return(authKey); }
/** * Writing tl-object to stream * * @param v tl-object * @param stream destination stream * @throws IOException */ public static void writeTLObject(TLObject v, /*OutputStream*/ StreamWriter stream) { try { v.serialize(stream); } catch (IOException e) { System.Diagnostics.Debug.WriteLine(e.StackTrace); throw e; } }
/** * Writing tl-vector to stream * * @param v tl-vector * @param stream destination stream * @throws IOException */ public static void writeTLVector(/*TLVector*/TLObject v, /*OutputStream*/ StreamWriter stream) { try { writeTLObject(v, stream); } catch(IOException e) { System.Diagnostics.Debug.WriteLine(e.StackTrace); throw e; } }
public ExpressionValue( TLObject value ) { Value = value; }
public void Declare( String identifier, TLObject value ) { myVariables.Add( identifier, value ); }