summaryrefslogtreecommitdiff
path: root/protocols/Telegram/tgl/structures.c
diff options
context:
space:
mode:
Diffstat (limited to 'protocols/Telegram/tgl/structures.c')
-rw-r--r--protocols/Telegram/tgl/structures.c2311
1 files changed, 2311 insertions, 0 deletions
diff --git a/protocols/Telegram/tgl/structures.c b/protocols/Telegram/tgl/structures.c
new file mode 100644
index 0000000000..a680e4c415
--- /dev/null
+++ b/protocols/Telegram/tgl/structures.c
@@ -0,0 +1,2311 @@
+/*
+ This file is part of tgl-library
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Copyright Vitaly Valtman 2013-2015
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <string.h>
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#include "tgl-structures.h"
+#include "mtproto-common.h"
+//#include "telegram.h"
+#include "tree.h"
+#include <openssl/aes.h>
+#include <openssl/bn.h>
+#include <openssl/sha.h>
+#include "queries.h"
+#include "tgl-binlog.h"
+#include "tgl-methods-in.h"
+#include "updates.h"
+#include "mtproto-client.h"
+
+#include "tgl.h"
+#include "auto.h"
+#include "auto/auto-types.h"
+#include "auto/auto-skip.h"
+#include "auto/auto-fetch-ds.h"
+#include "auto/auto-free-ds.h"
+
+#define sha1 SHA1
+#if defined(WIN32) || defined(_WIN32)
+#define bzero(b,len) (memset((b), '\0', (len)) )
+#endif
+
+struct random2local {
+ long long random_id;
+ int local_id;
+};
+
+static int id_cmp (struct tgl_message *M1, struct tgl_message *M2);
+#define peer_cmp(a,b) (tgl_cmp_peer_id (a->id, b->id))
+#define peer_cmp_name(a,b) (strcmp (a->print_name, b->print_name))
+
+static int random_id_cmp (struct random2local *L, struct random2local *R) {
+ if (L->random_id < R->random_id) { return -1; }
+ if (L->random_id > R->random_id) { return 1; }
+ return 0;
+}
+
+static int photo_id_cmp (struct tgl_photo *L, struct tgl_photo *R) {
+ if (L->id < R->id) { return -1; }
+ if (L->id > R->id) { return 1; }
+ return 0;
+}
+
+static int document_id_cmp (struct tgl_document *L, struct tgl_document *R) {
+ if (L->id < R->id) { return -1; }
+ if (L->id > R->id) { return 1; }
+ return 0;
+}
+
+static int webpage_id_cmp (struct tgl_webpage *L, struct tgl_webpage *R) {
+ if (L->id < R->id) { return -1; }
+ if (L->id > R->id) { return 1; }
+ return 0;
+}
+
+DEFINE_TREE(peer,tgl_peer_t *,peer_cmp,0)
+DEFINE_TREE(peer_by_name,tgl_peer_t *,peer_cmp_name,0)
+DEFINE_TREE(message,struct tgl_message *,id_cmp,0)
+DEFINE_TREE(random_id,struct random2local *, random_id_cmp,0)
+DEFINE_TREE(photo,struct tgl_photo *,photo_id_cmp,0)
+DEFINE_TREE(document,struct tgl_document *,document_id_cmp,0)
+DEFINE_TREE(webpage,struct tgl_webpage *,webpage_id_cmp,0)
+
+
+char *tgls_default_create_print_name (struct tgl_state *TLS, tgl_peer_id_t id, const char *a1, const char *a2, const char *a3, const char *a4) {
+ const char *d[4];
+ d[0] = a1; d[1] = a2; d[2] = a3; d[3] = a4;
+ static char buf[10000];
+ buf[0] = 0;
+ int i;
+ int p = 0;
+ for (i = 0; i < 4; i++) {
+ if (d[i] && strlen (d[i])) {
+ p += tsnprintf (buf + p, 9999 - p, "%s%s", p ? "_" : "", d[i]);
+ assert (p < 9990);
+ }
+ }
+ char *s = buf;
+ while (*s) {
+ if (((unsigned char)*s) <= ' ') { *s = '_'; }
+ if (*s == '#') { *s = '@'; }
+ s++;
+ }
+ s = buf;
+ int fl = strlen (s);
+ int cc = 0;
+ while (1) {
+ tgl_peer_t *P = tgl_peer_get_by_name (TLS, s);
+ if (!P || !tgl_cmp_peer_id (P->id, id)) {
+ break;
+ }
+ cc ++;
+ assert (cc <= 9999);
+ tsnprintf (s + fl, 9999 - fl, "#%d", cc);
+ }
+ return tstrdup (s);
+}
+
+enum tgl_typing_status tglf_fetch_typing_new (struct tl_ds_send_message_action *DS_SMA) {
+ if (!DS_SMA) { return 0; }
+ switch (DS_SMA->magic) {
+ case CODE_send_message_typing_action:
+ return tgl_typing_typing;
+ case CODE_send_message_cancel_action:
+ return tgl_typing_cancel;
+ case CODE_send_message_record_video_action:
+ return tgl_typing_record_video;
+ case CODE_send_message_upload_video_action:
+ return tgl_typing_upload_video;
+ case CODE_send_message_record_audio_action:
+ return tgl_typing_record_audio;
+ case CODE_send_message_upload_audio_action:
+ return tgl_typing_upload_audio;
+ case CODE_send_message_upload_photo_action:
+ return tgl_typing_upload_photo;
+ case CODE_send_message_upload_document_action:
+ return tgl_typing_upload_document;
+ case CODE_send_message_geo_location_action:
+ return tgl_typing_geo;
+ case CODE_send_message_choose_contact_action:
+ return tgl_typing_choose_contact;
+ default:
+ assert (0);
+ return tgl_typing_none;
+ }
+}
+
+enum tgl_typing_status tglf_fetch_typing (void) {
+ struct tl_ds_send_message_action *DS_SMA = fetch_ds_type_send_message_action (TYPE_TO_PARAM (send_message_action));
+ enum tgl_typing_status res = tglf_fetch_typing_new (DS_SMA);
+ free_ds_type_send_message_action (DS_SMA, TYPE_TO_PARAM (send_message_action));
+ return res;
+}
+
+/* {{{ Fetch */
+
+int tglf_fetch_file_location_new (struct tgl_state *TLS, struct tgl_file_location *loc, struct tl_ds_file_location *DS_FL) {
+ if (!DS_FL) { return 0; }
+ loc->dc = DS_LVAL (DS_FL->dc_id);
+ loc->volume = DS_LVAL (DS_FL->volume_id);
+ loc->local_id = DS_LVAL (DS_FL->local_id);
+ loc->secret = DS_LVAL (DS_FL->secret);
+ return 0;
+}
+
+int tglf_fetch_user_status_new (struct tgl_state *TLS, struct tgl_user_status *S, struct tgl_user *U, struct tl_ds_user_status *DS_US) {
+ if (!DS_US) { return 0; }
+ switch (DS_US->magic) {
+ case CODE_user_status_empty:
+ if (S->online) {
+ tgl_insert_status_update (TLS, U);
+ if (S->online == 1) {
+ tgl_remove_status_expire (TLS, U);
+ }
+ }
+ S->online = 0;
+ S->when = 0;
+ break;
+ case CODE_user_status_online:
+ {
+ if (S->online != 1) {
+ S->when = DS_LVAL (DS_US->expires);
+ if (S->online) {
+ tgl_insert_status_update (TLS, U);
+ }
+ tgl_insert_status_expire (TLS, U);
+ S->online = 1;
+ } else {
+ if (DS_LVAL (DS_US->expires) != S->when) {
+ S->when = DS_LVAL (DS_US->expires);
+ tgl_remove_status_expire (TLS, U);
+ tgl_insert_status_expire (TLS, U);
+ }
+ }
+ }
+ break;
+ case CODE_user_status_offline:
+ if (S->online != -1) {
+ if (S->online) {
+ tgl_insert_status_update (TLS, U);
+ }
+ if (S->online == 1) {
+ tgl_remove_status_expire (TLS, U);
+ }
+ }
+ S->online = -1;
+ S->when = DS_LVAL (DS_US->was_online);
+ break;
+ case CODE_user_status_recently:
+ if (S->online != -2) {
+ if (S->online) {
+ tgl_insert_status_update (TLS, U);
+ }
+ if (S->online == 1) {
+ tgl_remove_status_expire (TLS, U);
+ }
+ }
+ S->online = -2;
+ break;
+ case CODE_user_status_last_week:
+ if (S->online != -3) {
+ if (S->online) {
+ tgl_insert_status_update (TLS, U);
+ }
+ if (S->online == 1) {
+ tgl_remove_status_expire (TLS, U);
+ }
+ }
+ S->online = -3;
+ break;
+ case CODE_user_status_last_month:
+ if (S->online != -4) {
+ if (S->online) {
+ tgl_insert_status_update (TLS, U);
+ }
+ if (S->online == 1) {
+ tgl_remove_status_expire (TLS, U);
+ }
+ }
+ S->online = -4;
+ break;
+ default:
+ assert (0);
+ }
+ return 0;
+}
+
+int tglf_fetch_user_new (struct tgl_state *TLS, struct tgl_user *U, struct tl_ds_user *DS_U) {
+ if (!DS_U) { return 0; }
+ U->id = TGL_MK_USER (DS_LVAL (DS_U->id));
+ if (DS_U->magic == CODE_user_empty) {
+ return 0;
+ }
+
+ int flags = U->flags & 0xffff;
+
+ if (DS_LVAL (DS_U->flags) & (1 << 10)) {
+ bl_do_set_our_id (TLS, tgl_get_peer_id (U->id));
+ flags |= TGLUF_SELF;
+ }
+
+ if (DS_LVAL (DS_U->flags) & (1 << 11)) {
+ flags |= TGLUF_CONTACT;
+ }
+
+ if (DS_LVAL (DS_U->flags) & (1 << 12)) {
+ flags |= TGLUF_MUTUAL_CONTACT;
+ }
+
+
+ if (DS_LVAL (DS_U->flags) & (1 << 14)) {
+ flags |= TGLUF_BOT;
+ }
+ /*
+ if (DS_LVAL (DS_U->flags) & (1 << 15)) {
+ flags |= TGLUF_BOT_FULL_ACCESS;
+ }
+
+ if (DS_LVAL (DS_U->flags) & (1 << 16)) {
+ flags |= TGLUF_BOT_NO_GROUPS;
+ }*/
+
+ if (!(flags & TGLUF_CREATED)) {
+ flags |= TGLUF_CREATE | TGLUF_CREATED;
+ }
+
+ bl_do_user_new (TLS, tgl_get_peer_id (U->id),
+ DS_U->access_hash,
+ DS_STR (DS_U->first_name),
+ DS_STR (DS_U->last_name),
+ DS_STR (DS_U->phone),
+ DS_STR (DS_U->username),
+ NULL,
+ NULL, 0, NULL, 0,
+ DS_U->photo,
+ NULL, NULL,
+ NULL,
+ flags
+ );
+
+ if (DS_U->status) {
+ assert (tglf_fetch_user_status_new (TLS, &U->status, U, DS_U->status) >= 0);
+ }
+
+ if (DS_LVAL (DS_U->flags) & (1 << 13)) {
+ if (!(U->flags & TGLUF_DELETED)) {
+ bl_do_user_delete (TLS, U);
+ }
+ }
+
+ return 0;
+}
+
+void tglf_fetch_user_full_new (struct tgl_state *TLS, struct tgl_user *U, struct tl_ds_user_full *DS_UF) {
+ if (!DS_UF) { return; }
+
+ tglf_fetch_user_new (TLS, U, DS_UF->user);
+
+ int flags = U->flags & 0xffff;
+
+ if (DS_BVAL (DS_UF->blocked)) {
+ flags |= TGLUF_BLOCKED;
+ } else {
+ flags &= ~TGLUF_BLOCKED;
+ }
+
+ bl_do_user_new (TLS, tgl_get_peer_id (U->id),
+ NULL,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ DS_UF->profile_photo,
+ //DS_STR (DS_UF->real_first_name), DS_STR (DS_UF->real_last_name),
+ NULL, 0, NULL, 0,
+ NULL,
+ NULL, NULL,
+ DS_UF->bot_info,
+ flags
+ );
+}
+
+void str_to_256 (unsigned char *dst, char *src, int src_len) {
+ if (src_len >= 256) {
+ memcpy (dst, src + src_len - 256, 256);
+ } else {
+ bzero (dst, 256 - src_len);
+ memcpy (dst + 256 - src_len, src, src_len);
+ }
+}
+
+void str_to_32 (unsigned char *dst, char *src, int src_len) {
+ if (src_len >= 32) {
+ memcpy (dst, src + src_len - 32, 32);
+ } else {
+ bzero (dst, 32 - src_len);
+ memcpy (dst + 32 - src_len, src, src_len);
+ }
+}
+
+void tglf_fetch_encrypted_chat_new (struct tgl_state *TLS, struct tgl_secret_chat *U, struct tl_ds_encrypted_chat *DS_EC) {
+ if (!DS_EC) { return; }
+ U->id = TGL_MK_ENCR_CHAT (DS_LVAL (DS_EC->id));
+ if (DS_EC->magic == CODE_encrypted_chat_empty) {
+ return;
+ }
+ int new = !(U->flags & TGLPF_CREATED);
+
+ if (DS_EC->magic == CODE_encrypted_chat_discarded) {
+ if (new) {
+ vlogprintf (E_WARNING, "Unknown chat in deleted state. May be we forgot something...\n");
+ return;
+ }
+ bl_do_encr_chat_delete (TLS, U);
+ //write_secret_chat_file ();
+ return;
+ }
+
+ static unsigned char g_key[256];
+ if (new) {
+ if (DS_EC->magic != CODE_encrypted_chat_requested) {
+ vlogprintf (E_WARNING, "Unknown chat. May be we forgot something...\n");
+ return;
+ }
+
+ str_to_256 (g_key, DS_STR (DS_EC->g_a));
+
+ int user_id = DS_LVAL (DS_EC->participant_id) + DS_LVAL (DS_EC->admin_id) - TLS->our_id;
+ int r = sc_request;
+ bl_do_encr_chat_new (TLS, tgl_get_peer_id (U->id),
+ DS_EC->access_hash,
+ DS_EC->date,
+ DS_EC->admin_id,
+ &user_id,
+ NULL,
+ (void *)g_key,
+ NULL,
+ &r,
+ NULL, NULL, NULL, NULL, NULL,
+ NULL,
+ TGLECF_CREATE | TGLECF_CREATED
+ );
+ } else {
+ if (DS_EC->magic == CODE_encrypted_chat_waiting) {
+ int r = sc_waiting;
+ bl_do_encr_chat_new (TLS, tgl_get_peer_id (U->id),
+ DS_EC->access_hash,
+ DS_EC->date,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &r,
+ NULL, NULL, NULL, NULL, NULL,
+ NULL,
+ TGL_FLAGS_UNCHANGED
+ );
+ return; // We needed only access hash from here
+ }
+
+ str_to_256 (g_key, DS_STR (DS_EC->g_a_or_b));
+
+ //write_secret_chat_file ();
+ int r = sc_ok;
+ bl_do_encr_chat_new (TLS, tgl_get_peer_id (U->id),
+ DS_EC->access_hash,
+ DS_EC->date,
+ NULL,
+ NULL,
+ NULL,
+ g_key,
+ NULL,
+ &r,
+ NULL, NULL, NULL, NULL, NULL,
+ DS_EC->key_fingerprint,
+ TGL_FLAGS_UNCHANGED
+ );
+ }
+}
+
+void tglf_fetch_chat_new (struct tgl_state *TLS, struct tgl_chat *C, struct tl_ds_chat *DS_C) {
+ if (!DS_C) { return; }
+
+ C->id = TGL_MK_CHAT (DS_LVAL (DS_C->id));
+ if (DS_C->magic == CODE_chat_empty) {
+ return;
+ }
+
+ int flags = C->flags & 0xffff;
+ if (!(flags & TGLCF_CREATED)) {
+ flags |= TGLCF_CREATE | TGLCF_CREATED;
+ }
+
+ bl_do_chat_new (TLS, tgl_get_peer_id (C->id),
+ DS_STR (DS_C->title),
+ DS_C->participants_count,
+ DS_C->date,
+ NULL,
+ NULL,
+ DS_C->photo,
+ NULL,
+ NULL,
+ NULL, NULL,
+ flags
+ );
+}
+
+void tglf_fetch_chat_full_new (struct tgl_state *TLS, struct tgl_chat *C, struct tl_ds_messages_chat_full *DS_MCF) {
+ if (!DS_MCF) { return; }
+ struct tl_ds_chat_full *DS_CF = DS_MCF->full_chat;
+
+ C->id = TGL_MK_CHAT (DS_LVAL (DS_CF->id));
+
+ bl_do_chat_new (TLS, tgl_get_peer_id (C->id),
+ NULL, 0,
+ NULL,
+ NULL,
+ DS_CF->participants->version,
+ (struct tl_ds_vector *)DS_CF->participants->participants,
+ NULL,
+ DS_CF->chat_photo,
+ DS_CF->participants->admin_id,
+ NULL, NULL,
+ C->flags & 0xffff
+ );
+
+ if (DS_MCF->users) {
+ int i;
+ for (i = 0; i < DS_LVAL (DS_MCF->users->cnt); i++) {
+ tglf_fetch_alloc_user_new (TLS, DS_MCF->users->data[i]);
+ }
+ }
+
+ if (DS_MCF->chats) {
+ int i;
+ for (i = 0; i < DS_LVAL (DS_MCF->chats->cnt); i++) {
+ tglf_fetch_alloc_chat_new (TLS, DS_MCF->chats->data[i]);
+ }
+ }
+
+ if (DS_CF->bot_info) {
+ int n = DS_LVAL (DS_CF->bot_info->cnt);
+ int i;
+ for (i = 0; i < n; i++) {
+ struct tl_ds_bot_info *DS_BI = DS_CF->bot_info->data[i];
+
+ tgl_peer_t *P = tgl_peer_get (TLS, TGL_MK_USER (DS_LVAL (DS_BI->user_id)));
+ if (P && (P->flags & TGLCF_CREATED)) {
+ bl_do_user_new (TLS, tgl_get_peer_id (P->id),
+ NULL,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ NULL,
+ NULL, 0, NULL, 0,
+ NULL,
+ NULL, NULL,
+ DS_BI,
+ TGL_FLAGS_UNCHANGED
+ );
+ }
+ }
+ }
+}
+
+void tglf_fetch_photo_size_new (struct tgl_state *TLS, struct tgl_photo_size *S, struct tl_ds_photo_size *DS_PS) {
+ memset (S, 0, sizeof (*S));
+
+ S->type = DS_STR_DUP (DS_PS->type);
+ S->w = DS_LVAL (DS_PS->w);
+ S->h = DS_LVAL (DS_PS->h);
+ S->size = DS_LVAL (DS_PS->size);
+ if (DS_PS->bytes) {
+ S->size = DS_PS->bytes->len;
+ }
+
+ tglf_fetch_file_location_new (TLS, &S->loc, DS_PS->location);
+}
+
+void tglf_fetch_geo_new (struct tgl_state *TLS, struct tgl_geo *G, struct tl_ds_geo_point *DS_GP) {
+ G->longitude = DS_LVAL (DS_GP->longitude);
+ G->latitude = DS_LVAL (DS_GP->latitude);
+}
+
+struct tgl_photo *tglf_fetch_alloc_photo_new (struct tgl_state *TLS, struct tl_ds_photo *DS_P) {
+ if (!DS_P) { return NULL; }
+ if (DS_P->magic == CODE_photo_empty) { return NULL; }
+
+ struct tgl_photo *P = tgl_photo_get (TLS, DS_LVAL (DS_P->id));
+ if (P) {
+ P->refcnt ++;
+ return P;
+ }
+
+
+ P = talloc0 (sizeof (*P));
+ P->id = DS_LVAL (DS_P->id);
+ P->refcnt = 1;
+
+ tgl_photo_insert (TLS, P);
+
+ P->access_hash = DS_LVAL (DS_P->access_hash);
+ P->user_id = DS_LVAL (DS_P->user_id);
+ P->date = DS_LVAL (DS_P->date);
+ P->caption = NULL;//DS_STR_DUP (DS_P->caption);
+ tglf_fetch_geo_new (TLS, &P->geo, DS_P->geo);
+
+ P->sizes_num = DS_LVAL (DS_P->sizes->cnt);
+ P->sizes = talloc (sizeof (struct tgl_photo_size) * P->sizes_num);
+ int i;
+ for (i = 0; i < P->sizes_num; i++) {
+ tglf_fetch_photo_size_new (TLS, &P->sizes[i], DS_P->sizes->data[i]);
+ }
+
+ return P;
+}
+
+struct tgl_document *tglf_fetch_alloc_video_new (struct tgl_state *TLS, struct tl_ds_video *DS_V) {
+ if (!DS_V) { return NULL; }
+
+ if (DS_V->magic == CODE_video_empty) { return NULL; }
+
+ struct tgl_document *D = tgl_document_get (TLS, DS_LVAL (DS_V->id));
+ if (D) {
+ D->refcnt ++;
+ return D;
+ }
+
+
+ D = talloc0 (sizeof (*D));
+ D->id = DS_LVAL (DS_V->id);
+ D->refcnt = 1;
+
+ tgl_document_insert (TLS, D);
+
+ D->flags = TGLDF_VIDEO;
+
+ D->access_hash = DS_LVAL (DS_V->access_hash);
+ D->user_id = DS_LVAL (DS_V->user_id);
+ D->date = DS_LVAL (DS_V->date);
+ D->caption = NULL;//DS_STR_DUP (DS_V->caption);
+ D->duration = DS_LVAL (DS_V->duration);
+ D->mime_type = tstrdup ("video/");//DS_STR_DUP (DS_V->mime_type);
+ D->size = DS_LVAL (DS_V->size);
+ tglf_fetch_photo_size_new (TLS, &D->thumb, DS_V->thumb);
+
+ D->dc_id = DS_LVAL (DS_V->dc_id);
+ D->w = DS_LVAL (DS_V->w);
+ D->h = DS_LVAL (DS_V->h);
+ return D;
+}
+
+struct tgl_document *tglf_fetch_alloc_audio_new (struct tgl_state *TLS, struct tl_ds_audio *DS_A) {
+ if (!DS_A) { return NULL; }
+
+ if (DS_A->magic == CODE_audio_empty) { return NULL; }
+
+ struct tgl_document *D = tgl_document_get (TLS, DS_LVAL (DS_A->id));
+ if (D) {
+ D->refcnt ++;
+ return D;
+ }
+
+
+ D = talloc0 (sizeof (*D));
+ D->id = DS_LVAL (DS_A->id);
+ D->refcnt = 1;
+
+ tgl_document_insert (TLS, D);
+
+ D->flags = TGLDF_AUDIO;
+
+ D->access_hash = DS_LVAL (DS_A->access_hash);
+ D->user_id = DS_LVAL (DS_A->user_id);
+ D->date = DS_LVAL (DS_A->date);
+ D->duration = DS_LVAL (DS_A->duration);
+ D->mime_type = DS_STR_DUP (DS_A->mime_type);
+ D->size = DS_LVAL (DS_A->size);
+ D->dc_id = DS_LVAL (DS_A->dc_id);
+
+ return D;
+}
+
+void tglf_fetch_document_attribute_new (struct tgl_state *TLS, struct tgl_document *D, struct tl_ds_document_attribute *DS_DA) {
+ switch (DS_DA->magic) {
+ case CODE_document_attribute_image_size:
+ D->flags |= TGLDF_IMAGE;
+ D->w = DS_LVAL (DS_DA->w);
+ D->h = DS_LVAL (DS_DA->h);
+ return;
+ case CODE_document_attribute_animated:
+ D->flags |= TGLDF_ANIMATED;
+ return;
+ case CODE_document_attribute_sticker:
+ case CODE_document_attribute_sticker_l28:
+ D->flags |= TGLDF_STICKER;
+ return;
+ case CODE_document_attribute_video:
+ D->flags |= TGLDF_VIDEO;
+ D->duration = DS_LVAL (DS_DA->duration);
+ D->w = DS_LVAL (DS_DA->w);
+ D->h = DS_LVAL (DS_DA->h);
+ return;
+ case CODE_document_attribute_audio:
+ D->flags |= TGLDF_AUDIO;
+ D->duration = DS_LVAL (DS_DA->duration);
+ return;
+ case CODE_document_attribute_filename:
+ D->caption = DS_STR_DUP (DS_DA->file_name);
+ return;
+ default:
+ assert (0);
+ }
+}
+
+struct tgl_document *tglf_fetch_alloc_document_new (struct tgl_state *TLS, struct tl_ds_document *DS_D) {
+ if (!DS_D) { return NULL; }
+
+ if (DS_D->magic == CODE_document_empty) { return NULL; }
+
+ struct tgl_document *D = tgl_document_get (TLS, DS_LVAL (DS_D->id));
+ if (D) {
+ D->refcnt ++;
+ return D;
+ }
+
+
+ D = talloc0 (sizeof (*D));
+ D->id = DS_LVAL (DS_D->id);
+ D->refcnt = 1;
+
+ tgl_document_insert (TLS, D);
+
+ D->access_hash = DS_LVAL (DS_D->access_hash);
+ D->user_id = DS_LVAL (DS_D->user_id);
+ D->date = DS_LVAL (DS_D->date);
+ D->caption = DS_STR_DUP (DS_D->file_name);
+ D->mime_type = DS_STR_DUP (DS_D->mime_type);
+ D->size = DS_LVAL (DS_D->size);
+ D->dc_id = DS_LVAL (DS_D->dc_id);
+
+ tglf_fetch_photo_size_new (TLS, &D->thumb, DS_D->thumb);
+
+ if (DS_D->attributes) {
+ int i;
+ for (i = 0; i < DS_LVAL (DS_D->attributes->cnt); i++) {
+ tglf_fetch_document_attribute_new (TLS, D, DS_D->attributes->data[i]);
+ }
+ }
+ return D;
+}
+
+struct tgl_webpage *tglf_fetch_alloc_webpage_new (struct tgl_state *TLS, struct tl_ds_web_page *DS_W) {
+ if (!DS_W) { return NULL; }
+
+ struct tgl_webpage *W = tgl_webpage_get (TLS, DS_LVAL (DS_W->id));
+ if (W) {
+ W->refcnt ++;
+ } else {
+ W = talloc0 (sizeof (*W));
+ W->id = DS_LVAL (DS_W->id);
+ W->refcnt = 1;
+
+ tgl_webpage_insert (TLS, W);
+ }
+
+ if (!W->url) {
+ W->url = DS_STR_DUP (DS_W->url);
+ }
+
+ if (!W->display_url) {
+ W->display_url = DS_STR_DUP (DS_W->display_url);
+ }
+
+ if (!W->type) {
+ W->type = DS_STR_DUP (DS_W->type);
+ }
+
+ if (!W->site_name) {
+ W->site_name = DS_STR_DUP (DS_W->site_name);
+ }
+
+ if (!W->title) {
+ W->title = DS_STR_DUP (DS_W->title);
+ }
+
+ if (!W->photo) {
+ W->photo = tglf_fetch_alloc_photo_new (TLS, DS_W->photo);
+ }
+
+ if (!W->description) {
+ W->description = DS_STR_DUP (DS_W->description);
+ }
+
+ if (!W->embed_url) {
+ W->embed_url = DS_STR_DUP (DS_W->embed_url);
+ }
+
+ if (!W->embed_type) {
+ W->embed_type = DS_STR_DUP (DS_W->embed_type);
+ }
+
+ W->embed_width = DS_LVAL (DS_W->embed_width);
+
+ W->embed_height = DS_LVAL (DS_W->embed_height);
+
+ W->duration = DS_LVAL (DS_W->duration);
+
+ if (!W->author) {
+ W->author = DS_STR_DUP (DS_W->author);
+ }
+ return W;
+}
+
+void tglf_fetch_message_action_new (struct tgl_state *TLS, struct tgl_message_action *M, struct tl_ds_message_action *DS_MA) {
+ if (!DS_MA) { return; }
+ memset (M, 0, sizeof (*M));
+
+ switch (DS_MA->magic) {
+ case CODE_message_action_empty:
+ M->type = tgl_message_action_none;
+ break;
+ case CODE_message_action_geo_chat_create:
+ {
+ M->type = tgl_message_action_geo_chat_create;
+ assert (0);
+ }
+ break;
+ case CODE_message_action_geo_chat_checkin:
+ M->type = tgl_message_action_geo_chat_checkin;
+ break;
+ case CODE_message_action_chat_create:
+ {
+ M->type = tgl_message_action_chat_create;
+ M->title = DS_STR_DUP (DS_MA->title);
+
+ M->user_num = DS_LVAL (DS_MA->users->cnt);
+ M->users = talloc (M->user_num * 4);
+ int i;
+ for (i = 0; i < M->user_num; i++) {
+ M->users[i] = DS_LVAL (DS_MA->users->data[i]);
+ }
+ }
+ break;
+ case CODE_message_action_chat_edit_title:
+ M->type = tgl_message_action_chat_edit_title;
+ M->new_title = DS_STR_DUP (DS_MA->title);
+ break;
+ case CODE_message_action_chat_edit_photo:
+ M->type = tgl_message_action_chat_edit_photo;
+ M->photo = tglf_fetch_alloc_photo_new (TLS, DS_MA->photo);
+ break;
+ case CODE_message_action_chat_delete_photo:
+ M->type = tgl_message_action_chat_delete_photo;
+ break;
+ case CODE_message_action_chat_add_user:
+ M->type = tgl_message_action_chat_add_user;
+ M->user = DS_LVAL (DS_MA->user_id);
+ break;
+ case CODE_message_action_chat_delete_user:
+ M->type = tgl_message_action_chat_delete_user;
+ M->user = DS_LVAL (DS_MA->user_id);
+ break;
+ case CODE_message_action_chat_joined_by_link:
+ M->type = tgl_message_action_chat_add_user_by_link;
+ M->user = DS_LVAL (DS_MA->inviter_id);
+ break;
+ default:
+ assert (0);
+ }
+}
+
+void tglf_fetch_message_short_new (struct tgl_state *TLS, struct tgl_message *M, struct tl_ds_updates *DS_U) {
+ tgl_peer_t *P = tgl_peer_get (TLS, TGL_MK_USER (DS_LVAL (DS_U->user_id)));
+ if (!P || !(P->flags & TGLPF_CREATED)) {
+ tgl_do_get_difference (TLS, 0, 0, 0);
+ return;
+ }
+
+ int flags = M->flags & 0xffff;
+
+ if (M->flags & TGLMF_PENDING) {
+ M->flags ^= TGLMF_PENDING;
+ }
+
+ if (!(flags & TGLMF_CREATED)) {
+ flags |= TGLMF_CREATE | TGLMF_CREATED;
+ }
+
+ int f = DS_LVAL (DS_U->flags);
+
+ if (f & 1) {
+ flags |= TGLMF_UNREAD;
+ }
+ if (f & 2) {
+ flags |= TGLMF_OUT;
+ }
+ if (f & 16) {
+ flags |= TGLMF_MENTION;
+ }
+
+ struct tl_ds_message_media A;
+ A.magic = CODE_message_media_empty;
+ int type = TGL_PEER_USER;
+
+ bl_do_create_message_new (TLS, DS_LVAL (DS_U->id),
+ (f & 2) ? &TLS->our_id : DS_U->user_id,
+ &type, (f & 2) ? DS_U->user_id : &TLS->our_id,
+ DS_U->fwd_from_id,
+ DS_U->fwd_date,
+ DS_U->date,
+ DS_STR (DS_U->message),
+ &A,
+ NULL,
+ DS_U->reply_to_msg_id,
+ NULL,
+ flags
+ );
+}
+
+void tglf_fetch_message_short_chat_new (struct tgl_state *TLS, struct tgl_message *M, struct tl_ds_updates *DS_U) {
+ tgl_peer_t *P = tgl_peer_get (TLS, TGL_MK_USER (DS_LVAL (DS_U->from_id)));
+ if (!P || !(P->flags & TGLPF_CREATED)) {
+ tgl_do_get_difference (TLS, 0, 0, 0);
+ return;
+ }
+ P = tgl_peer_get (TLS, TGL_MK_CHAT (DS_LVAL (DS_U->chat_id)));
+ if (!P || !(P->flags & TGLPF_CREATED)) {
+ tgl_do_get_difference (TLS, 0, 0, 0);
+ return;
+ }
+
+ int flags = M->flags & 0xffff;
+
+ if (M->flags & TGLMF_PENDING) {
+ M->flags ^= TGLMF_PENDING;
+ }
+
+ if (!(flags & TGLMF_CREATED)) {
+ flags |= TGLMF_CREATE | TGLMF_CREATED;
+ }
+
+ int f = DS_LVAL (DS_U->flags);
+
+ if (f & 1) {
+ flags |= TGLMF_UNREAD;
+ }
+ if (f & 2) {
+ flags |= TGLMF_OUT;
+ }
+ if (f & 16) {
+ flags |= TGLMF_MENTION;
+ }
+
+ struct tl_ds_message_media A;
+ A.magic = CODE_message_media_empty;
+
+ int type = TGL_PEER_CHAT;
+ bl_do_create_message_new (TLS, DS_LVAL (DS_U->id),
+ DS_U->from_id,
+ &type, DS_U->chat_id,
+ DS_U->fwd_from_id,
+ DS_U->fwd_date,
+ DS_U->date,
+ DS_STR (DS_U->message),
+ &A,
+ NULL,
+ DS_U->reply_to_msg_id,
+ NULL,
+ flags
+ );
+}
+
+
+void tglf_fetch_message_media_new (struct tgl_state *TLS, struct tgl_message_media *M, struct tl_ds_message_media *DS_MM) {
+ if (!DS_MM) { return; }
+ memset (M, 0, sizeof (*M));
+ switch (DS_MM->magic) {
+ case CODE_message_media_empty:
+ M->type = tgl_message_media_none;
+ break;
+ case CODE_message_media_photo:
+ case CODE_message_media_photo_l27:
+ M->type = tgl_message_media_photo;
+ M->photo = tglf_fetch_alloc_photo_new (TLS, DS_MM->photo);
+ M->caption = DS_STR_DUP (DS_MM->caption);
+ break;
+ case CODE_message_media_video:
+ case CODE_message_media_video_l27:
+ M->type = tgl_message_media_video;
+ M->document = tglf_fetch_alloc_video_new (TLS, DS_MM->video);
+ M->caption = DS_STR_DUP (DS_MM->caption);
+ break;
+ case CODE_message_media_audio:
+ M->type = tgl_message_media_audio;
+ M->document = tglf_fetch_alloc_audio_new (TLS, DS_MM->audio);
+ break;
+ case CODE_message_media_document:
+ M->type = tgl_message_media_document;
+ M->document = tglf_fetch_alloc_document_new (TLS, DS_MM->document);
+ break;
+ case CODE_message_media_geo:
+ M->type = tgl_message_media_geo;
+ tglf_fetch_geo_new (TLS, &M->geo, DS_MM->geo);
+ break;
+ case CODE_message_media_contact:
+ M->type = tgl_message_media_contact;
+ M->phone = DS_STR_DUP (DS_MM->phone_number);
+ M->first_name = DS_STR_DUP (DS_MM->first_name);
+ M->last_name = DS_STR_DUP (DS_MM->last_name);
+ M->user_id = DS_LVAL (DS_MM->user_id);
+ break;
+ //case CODE_message_media_unsupported:
+ //case CODE_message_media_unsupported_l22:
+ // M->type = tgl_message_media_unsupported;
+ // break;
+ case CODE_message_media_web_page:
+ M->type = tgl_message_media_webpage;
+ M->webpage = tglf_fetch_alloc_webpage_new (TLS, DS_MM->webpage);
+ break;
+ case CODE_message_media_venue:
+ M->type = tgl_message_media_venue;
+ tglf_fetch_geo_new (TLS, &M->venue.geo, DS_MM->geo);
+ M->venue.title = DS_STR_DUP (DS_MM->title);
+ M->venue.address = DS_STR_DUP (DS_MM->address);
+ M->venue.provider = DS_STR_DUP (DS_MM->provider);
+ M->venue.venue_id = DS_STR_DUP (DS_MM->venue_id);
+ break;
+ default:
+ assert (0);
+ }
+}
+
+void tglf_fetch_message_media_encrypted_new (struct tgl_state *TLS, struct tgl_message_media *M, struct tl_ds_decrypted_message_media *DS_DMM) {
+ if (!DS_DMM) { return; }
+
+ memset (M, 0, sizeof (*M));
+ switch (DS_DMM->magic) {
+ case CODE_decrypted_message_media_empty:
+ M->type = tgl_message_media_none;
+ //M->type = CODE_message_media_empty;
+ break;
+ case CODE_decrypted_message_media_photo:
+ case CODE_decrypted_message_media_video:
+ case CODE_decrypted_message_media_video_l12:
+ case CODE_decrypted_message_media_document:
+ case CODE_decrypted_message_media_audio:
+ //M->type = CODE_decrypted_message_media_video;
+ M->type = tgl_message_media_document_encr;
+
+ M->encr_document = talloc0 (sizeof (*M->encr_document));
+
+ switch (DS_DMM->magic) {
+ case CODE_decrypted_message_media_photo:
+ M->encr_document->flags = TGLDF_IMAGE;
+ break;
+ case CODE_decrypted_message_media_video:
+ case CODE_decrypted_message_media_video_l12:
+ M->encr_document->flags = TGLDF_VIDEO;
+ break;
+ case CODE_decrypted_message_media_document:
+ //M->encr_document->flags = TGLDF_DOCUMENT;
+ break;
+ case CODE_decrypted_message_media_audio:
+ M->encr_document->flags = TGLDF_AUDIO;
+ break;
+ }
+
+ M->encr_document->w = DS_LVAL (DS_DMM->w);
+ M->encr_document->h = DS_LVAL (DS_DMM->h);
+ M->encr_document->size = DS_LVAL (DS_DMM->size);
+ M->encr_document->duration = DS_LVAL (DS_DMM->duration);
+ M->encr_document->mime_type = DS_STR_DUP (DS_DMM->mime_type);
+
+ M->encr_document->key = talloc (32);
+ str_to_32 (M->encr_document->key, DS_STR (DS_DMM->key));
+ M->encr_document->iv = talloc (32);
+ str_to_32 (M->encr_document->iv, DS_STR (DS_DMM->iv));
+ break;
+ case CODE_decrypted_message_media_geo_point:
+ M->type = tgl_message_media_geo;
+ M->geo.latitude = DS_LVAL (DS_DMM->latitude);
+ M->geo.longitude = DS_LVAL (DS_DMM->longitude);
+ break;
+ case CODE_decrypted_message_media_contact:
+ M->type = tgl_message_media_contact;
+ M->phone = DS_STR_DUP (DS_DMM->phone_number);
+ M->first_name = DS_STR_DUP (DS_DMM->first_name);
+ M->last_name = DS_STR_DUP (DS_DMM->last_name);
+ M->user_id = DS_LVAL (DS_DMM->user_id);
+ break;
+ default:
+ assert (0);
+ }
+}
+
+void tglf_fetch_message_action_encrypted_new (struct tgl_state *TLS, struct tgl_message_action *M, struct tl_ds_decrypted_message_action *DS_DMA) {
+ if (!DS_DMA) { return; }
+
+ switch (DS_DMA->magic) {
+ case CODE_decrypted_message_action_set_message_t_t_l:
+ M->type = tgl_message_action_set_message_ttl;
+ M->ttl = DS_LVAL (DS_DMA->ttl_seconds);
+ break;
+ case CODE_decrypted_message_action_read_messages:
+ M->type = tgl_message_action_read_messages;
+ {
+ M->read_cnt = DS_LVAL (DS_DMA->random_ids->cnt);
+
+ int i;
+ for (i = 0; i < M->read_cnt; i++) {
+ struct tgl_message *N = tgl_message_get (TLS, DS_LVAL (DS_DMA->random_ids->data[i]));
+ if (N) {
+ N->flags &= ~TGLMF_UNREAD;
+ }
+ }
+ }
+ break;
+ case CODE_decrypted_message_action_delete_messages:
+ M->type = tgl_message_action_delete_messages;
+ break;
+ case CODE_decrypted_message_action_screenshot_messages:
+ M->type = tgl_message_action_screenshot_messages;
+ {
+ M->screenshot_cnt = DS_LVAL (DS_DMA->random_ids->cnt);
+ }
+ break;
+ case CODE_decrypted_message_action_notify_layer:
+ M->type = tgl_message_action_notify_layer;
+ M->layer = DS_LVAL (DS_DMA->layer);
+ break;
+ case CODE_decrypted_message_action_flush_history:
+ M->type = tgl_message_action_flush_history;
+ break;
+ case CODE_decrypted_message_action_typing:
+ M->type = tgl_message_action_typing;
+ M->typing = tglf_fetch_typing_new (DS_DMA->action);
+ break;
+ case CODE_decrypted_message_action_resend:
+ M->type = tgl_message_action_resend;
+ M->start_seq_no = DS_LVAL (DS_DMA->start_seq_no);
+ M->end_seq_no = DS_LVAL (DS_DMA->end_seq_no);
+ break;
+ case CODE_decrypted_message_action_noop:
+ M->type = tgl_message_action_noop;
+ break;
+ case CODE_decrypted_message_action_request_key:
+ M->type = tgl_message_action_request_key;
+
+ M->exchange_id = DS_LVAL (DS_DMA->exchange_id);
+ M->g_a = talloc (256);
+ str_to_256 (M->g_a, DS_STR (DS_DMA->g_a));
+ break;
+ case CODE_decrypted_message_action_accept_key:
+ M->type = tgl_message_action_accept_key;
+
+ M->exchange_id = DS_LVAL (DS_DMA->exchange_id);
+ M->g_a = talloc (256);
+ str_to_256 (M->g_a, DS_STR (DS_DMA->g_b));
+ M->key_fingerprint = DS_LVAL (DS_DMA->key_fingerprint);
+ break;
+ case CODE_decrypted_message_action_commit_key:
+ M->type = tgl_message_action_commit_key;
+
+ M->exchange_id = DS_LVAL (DS_DMA->exchange_id);
+ M->key_fingerprint = DS_LVAL (DS_DMA->key_fingerprint);
+ break;
+ case CODE_decrypted_message_action_abort_key:
+ M->type = tgl_message_action_abort_key;
+
+ M->exchange_id = DS_LVAL (DS_DMA->exchange_id);
+ break;
+ default:
+ assert (0);
+ }
+}
+
+tgl_peer_id_t tglf_fetch_peer_id_new (struct tgl_state *TLS, struct tl_ds_peer *DS_P) {
+ if (DS_P->magic == CODE_peer_user) {
+ return TGL_MK_USER (DS_LVAL (DS_P->user_id));
+ } else {
+ return TGL_MK_CHAT (DS_LVAL (DS_P->chat_id));
+ }
+}
+
+void tglf_fetch_message_new (struct tgl_state *TLS, struct tgl_message *M, struct tl_ds_message *DS_M) {
+ if (!DS_M || DS_M->magic == CODE_message_empty) { return; }
+
+ assert (M->id == DS_LVAL (DS_M->id));
+
+ tgl_peer_id_t to_id = tglf_fetch_peer_id_new (TLS, DS_M->to_id);
+ {
+ tgl_peer_t *P = tgl_peer_get (TLS, to_id);
+ if (!P || !(P->flags & TGLPF_CREATED)) {
+ tgl_do_get_difference (TLS, 0, 0, 0);
+ return;
+ }
+ P = tgl_peer_get (TLS, TGL_MK_USER (DS_LVAL (DS_M->from_id)));
+ if (!P || !(P->flags & TGLPF_CREATED)) {
+ tgl_do_get_difference (TLS, 0, 0, 0);
+ return;
+ }
+ }
+
+ int new = !(M->flags & TGLMF_CREATED);
+
+ if (new) {
+ int peer_id = tgl_get_peer_id (to_id);
+ int peer_type = tgl_get_peer_type (to_id);
+
+ int flags = 0;
+ if (DS_LVAL (DS_M->flags) & 1) {
+ flags |= TGLMF_UNREAD;
+ }
+ if (DS_LVAL (DS_M->flags) & 2) {
+ flags |= TGLMF_OUT;
+ }
+ if (DS_LVAL (DS_M->flags) & 16) {
+ flags |= TGLMF_MENTION;
+ }
+
+ bl_do_create_message_new (TLS, DS_LVAL (DS_M->id),
+ DS_M->from_id,
+ &peer_type, &peer_id,
+ DS_M->fwd_from_id, DS_M->fwd_date,
+ DS_M->date,
+ DS_STR (DS_M->message),
+ DS_M->media,
+ DS_M->action,
+ DS_M->reply_to_msg_id,
+ DS_M->reply_markup,
+ flags | TGLMF_CREATE | TGLMF_CREATED
+ );
+ }
+}
+
+static int *decr_ptr;
+static int *decr_end;
+
+static int decrypt_encrypted_message (struct tgl_secret_chat *E) {
+ int *msg_key = decr_ptr;
+ decr_ptr += 4;
+ assert (decr_ptr < decr_end);
+ static unsigned char sha1a_buffer[20];
+ static unsigned char sha1b_buffer[20];
+ static unsigned char sha1c_buffer[20];
+ static unsigned char sha1d_buffer[20];
+
+ static unsigned char buf[64];
+
+ int *e_key = E->exchange_state != tgl_sce_committed ? E->key : E->exchange_key;
+
+ memcpy (buf, msg_key, 16);
+ memcpy (buf + 16, e_key, 32);
+ sha1 (buf, 48, sha1a_buffer);
+
+ memcpy (buf, e_key + 8, 16);
+ memcpy (buf + 16, msg_key, 16);
+ memcpy (buf + 32, e_key + 12, 16);
+ sha1 (buf, 48, sha1b_buffer);
+
+ memcpy (buf, e_key + 16, 32);
+ memcpy (buf + 32, msg_key, 16);
+ sha1 (buf, 48, sha1c_buffer);
+
+ memcpy (buf, msg_key, 16);
+ memcpy (buf + 16, e_key + 24, 32);
+ sha1 (buf, 48, sha1d_buffer);
+
+ static unsigned char key[32];
+ memcpy (key, sha1a_buffer + 0, 8);
+ memcpy (key + 8, sha1b_buffer + 8, 12);
+ memcpy (key + 20, sha1c_buffer + 4, 12);
+
+ static unsigned char iv[32];
+ memcpy (iv, sha1a_buffer + 8, 12);
+ memcpy (iv + 12, sha1b_buffer + 0, 8);
+ memcpy (iv + 20, sha1c_buffer + 16, 4);
+ memcpy (iv + 24, sha1d_buffer + 0, 8);
+
+ AES_KEY aes_key;
+ AES_set_decrypt_key (key, 256, &aes_key);
+ AES_ige_encrypt ((void *)decr_ptr, (void *)decr_ptr, 4 * (decr_end - decr_ptr), &aes_key, iv, 0);
+ memset (&aes_key, 0, sizeof (aes_key));
+
+ int x = *(decr_ptr);
+ if (x < 0 || (x & 3)) {
+ return -1;
+ }
+ assert (x >= 0 && !(x & 3));
+ sha1 ((void *)decr_ptr, 4 + x, sha1a_buffer);
+
+ if (memcmp (sha1a_buffer + 4, msg_key, 16)) {
+ return -1;
+ }
+ return 0;
+}
+
+void tglf_fetch_encrypted_message_new (struct tgl_state *TLS, struct tgl_message *M, struct tl_ds_encrypted_message *DS_EM) {
+ if (!DS_EM) { return; }
+
+ int new = !(M->flags & TGLMF_CREATED);
+ if (!new) {
+ return;
+ }
+
+ tgl_peer_t *P = tgl_peer_get (TLS, TGL_MK_ENCR_CHAT (DS_LVAL (DS_EM->chat_id)));
+ if (!P || P->encr_chat.state != sc_ok) {
+ vlogprintf (E_WARNING, "Encrypted message to unknown chat. Dropping\n");
+ return;
+ }
+
+ decr_ptr = (void *)DS_EM->bytes->data;
+ decr_end = decr_ptr + (DS_EM->bytes->len / 4);
+
+ if (P->encr_chat.exchange_state == tgl_sce_committed && P->encr_chat.key_fingerprint == *(long long *)decr_ptr) {
+ tgl_do_confirm_exchange (TLS, (void *)P, 0);
+ assert (P->encr_chat.exchange_state == tgl_sce_none);
+ }
+
+ long long key_fingerprint = P->encr_chat.exchange_state != tgl_sce_committed ? P->encr_chat.key_fingerprint : P->encr_chat.exchange_key_fingerprint;
+ if (*(long long *)decr_ptr != key_fingerprint) {
+ vlogprintf (E_WARNING, "Encrypted message with bad fingerprint to chat %s\n", P->print_name);
+ return;
+ }
+
+ decr_ptr += 2;
+
+ if (decrypt_encrypted_message (&P->encr_chat) < 0) {
+ vlogprintf (E_WARNING, "can not decrypt message\n");
+ return;
+ }
+
+ int *save_in_ptr = in_ptr;
+ int *save_in_end = in_end;
+
+ in_ptr = decr_ptr;
+ int ll = *in_ptr;
+ in_end = in_ptr + ll / 4 + 1;
+ assert (fetch_int () == ll);
+
+ if (skip_type_decrypted_message_layer (TYPE_TO_PARAM (decrypted_message_layer)) < 0 || in_ptr != in_end) {
+ vlogprintf (E_WARNING, "can not fetch message\n");
+ in_ptr = save_in_ptr;
+ in_end = save_in_end;
+ return;
+ }
+
+ in_ptr = decr_ptr;
+ assert (fetch_int () == ll);
+
+ struct tl_ds_decrypted_message_layer *DS_DML = fetch_ds_type_decrypted_message_layer (TYPE_TO_PARAM (decrypted_message_layer));
+ assert (DS_DML);
+
+ in_ptr = save_in_ptr;
+ in_end = save_in_end;
+
+ //bl_do_encr_chat_set_layer (TLS, (void *)P, DS_LVAL (DS_DML->layer));
+ bl_do_encr_chat_new (TLS, tgl_get_peer_id (P->id),
+ NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL,
+ NULL, DS_DML->layer, NULL, NULL, NULL, NULL,
+ TGL_FLAGS_UNCHANGED
+ );
+
+ int in_seq_no = DS_LVAL (DS_DML->out_seq_no);
+ int out_seq_no = DS_LVAL (DS_DML->in_seq_no);
+
+ if (in_seq_no / 2 != P->encr_chat.in_seq_no) {
+ vlogprintf (E_WARNING, "Hole in seq in secret chat. in_seq_no = %d, expect_seq_no = %d\n", in_seq_no / 2, P->encr_chat.in_seq_no);
+ free_ds_type_decrypted_message_layer (DS_DML, TYPE_TO_PARAM(decrypted_message_layer));
+ return;
+ }
+
+ if ((in_seq_no & 1) != 1 - (P->encr_chat.admin_id == TLS->our_id) ||
+ (out_seq_no & 1) != (P->encr_chat.admin_id == TLS->our_id)) {
+ vlogprintf (E_WARNING, "Bad msg admin\n");
+ free_ds_type_decrypted_message_layer (DS_DML, TYPE_TO_PARAM(decrypted_message_layer));
+ return;
+ }
+ if (out_seq_no / 2 > P->encr_chat.out_seq_no) {
+ vlogprintf (E_WARNING, "In seq no is bigger than our's out seq no (out_seq_no = %d, our_out_seq_no = %d). Drop\n", out_seq_no / 2, P->encr_chat.out_seq_no);
+ free_ds_type_decrypted_message_layer (DS_DML, TYPE_TO_PARAM(decrypted_message_layer));
+ return;
+ }
+ if (out_seq_no / 2 < P->encr_chat.last_in_seq_no) {
+ vlogprintf (E_WARNING, "Clients in_seq_no decreased (out_seq_no = %d, last_out_seq_no = %d). Drop\n", out_seq_no / 2, P->encr_chat.last_in_seq_no);
+ free_ds_type_decrypted_message_layer (DS_DML, TYPE_TO_PARAM(decrypted_message_layer));
+ return;
+ }
+
+ struct tl_ds_decrypted_message *DS_DM = DS_DML->message;
+ if (M->id != DS_LVAL (DS_DM->random_id)) {
+ vlogprintf (E_ERROR, "Incorrect message: id = %"_PRINTF_INT64_"d, new_id = %"_PRINTF_INT64_"d\n", M->id, DS_LVAL (DS_DM->random_id));
+ free_ds_type_decrypted_message_layer (DS_DML, TYPE_TO_PARAM(decrypted_message_layer));
+ return;
+ }
+
+ int peer_type = TGL_PEER_ENCR_CHAT;
+ int peer_id = tgl_get_peer_id (P->id);
+
+ bl_do_create_message_encr_new (TLS, M->id, &P->encr_chat.user_id, &peer_type, &peer_id, DS_EM->date, DS_STR (DS_DM->message), DS_DM->media, DS_DM->action, DS_EM->file, TGLMF_CREATE | TGLMF_CREATED | TGLMF_ENCRYPTED);
+
+ if (in_seq_no >= 0 && out_seq_no >= 0) {
+ //bl_do_encr_chat_update_seq (TLS, (void *)P, in_seq_no / 2 + 1, out_seq_no / 2);
+ in_seq_no = in_seq_no / 2 + 1;
+ out_seq_no = out_seq_no / 2;
+ bl_do_encr_chat_new (TLS, tgl_get_peer_id (P->id),
+ NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL,
+ NULL, NULL, &in_seq_no, &out_seq_no, NULL, NULL,
+ TGL_FLAGS_UNCHANGED
+ );
+ assert (P->encr_chat.in_seq_no == in_seq_no);
+ }
+
+ free_ds_type_decrypted_message_layer (DS_DML, TYPE_TO_PARAM(decrypted_message_layer));
+}
+
+void tglf_fetch_encrypted_message_file_new (struct tgl_state *TLS, struct tgl_message_media *M, struct tl_ds_encrypted_file *DS_EF) {
+ if (DS_EF->magic == CODE_encrypted_file_empty) {
+ assert (M->type != tgl_message_media_document_encr);
+ } else {
+ assert (M->type == tgl_message_media_document_encr);
+ assert (M->encr_document);
+
+ M->encr_document->id = DS_LVAL (DS_EF->id);
+ M->encr_document->access_hash = DS_LVAL (DS_EF->access_hash);
+ if (!M->encr_document->size) {
+ M->encr_document->size = DS_LVAL (DS_EF->size);
+ }
+ M->encr_document->dc_id = DS_LVAL (DS_EF->dc_id);
+ M->encr_document->key_fingerprint = DS_LVAL (DS_EF->key_fingerprint);
+ }
+}
+
+static int id_cmp (struct tgl_message *M1, struct tgl_message *M2) {
+ if (M1->id < M2->id) { return -1; }
+ else if (M1->id > M2->id) { return 1; }
+ else { return 0; }
+}
+
+static void increase_peer_size (struct tgl_state *TLS) {
+ if (TLS->peer_num == TLS->peer_size) {
+ int new_size = TLS->peer_size ? 2 * TLS->peer_size : 10;
+ int old_size = TLS->peer_size;
+ if (old_size) {
+ TLS->Peers = trealloc (TLS->Peers, old_size * sizeof (void *), new_size * sizeof (void *));
+ } else {
+ TLS->Peers = talloc (new_size * sizeof (void *));
+ }
+ TLS->peer_size = new_size;
+ }
+}
+
+struct tgl_user *tglf_fetch_alloc_user_new (struct tgl_state *TLS, struct tl_ds_user *DS_U) {
+ tgl_peer_t *U = tgl_peer_get (TLS, TGL_MK_USER (DS_LVAL (DS_U->id)));
+ if (!U) {
+ TLS->users_allocated ++;
+ U = talloc0 (sizeof (*U));
+ U->id = TGL_MK_USER (DS_LVAL (DS_U->id));
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, U, lrand48 ());
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = U;
+ }
+ tglf_fetch_user_new (TLS, &U->user, DS_U);
+ return &U->user;
+}
+
+struct tgl_secret_chat *tglf_fetch_alloc_encrypted_chat_new (struct tgl_state *TLS, struct tl_ds_encrypted_chat *DS_EC) {
+ tgl_peer_t *U = tgl_peer_get (TLS, TGL_MK_ENCR_CHAT (DS_LVAL (DS_EC->id)));
+ if (!U) {
+ U = talloc0 (sizeof (*U));
+ U->id = TGL_MK_ENCR_CHAT (DS_LVAL (DS_EC->id));
+ TLS->encr_chats_allocated ++;
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, U, lrand48 ());
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = U;
+ }
+ tglf_fetch_encrypted_chat_new (TLS, &U->encr_chat, DS_EC);
+ return &U->encr_chat;
+}
+
+struct tgl_user *tglf_fetch_alloc_user_full_new (struct tgl_state *TLS, struct tl_ds_user_full *DS_U) {
+ tgl_peer_t *U = tgl_peer_get (TLS, TGL_MK_USER (DS_LVAL (DS_U->user->id)));
+ if (U) {
+ tglf_fetch_user_full_new (TLS, &U->user, DS_U);
+ return &U->user;
+ } else {
+ TLS->users_allocated ++;
+ U = talloc0 (sizeof (*U));
+ U->id = TGL_MK_USER (DS_LVAL (DS_U->user->id));
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, U, lrand48 ());
+ tglf_fetch_user_full_new (TLS, &U->user, DS_U);
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = U;
+ return &U->user;
+ }
+}
+
+struct tgl_message *tglf_fetch_alloc_message_new (struct tgl_state *TLS, struct tl_ds_message *DS_M) {
+ struct tgl_message *M = tgl_message_get (TLS, DS_LVAL (DS_M->id));
+
+ if (!M) {
+ M = tglm_message_alloc (TLS, DS_LVAL (DS_M->id));
+ }
+ tglf_fetch_message_new (TLS, M, DS_M);
+ return M;
+}
+
+struct tgl_message *tglf_fetch_alloc_encrypted_message_new (struct tgl_state *TLS, struct tl_ds_encrypted_message *DS_EM) {
+ struct tgl_message *M = tgl_message_get (TLS, DS_LVAL (DS_EM->random_id));
+
+ if (!M) {
+ M = talloc0 (sizeof (*M));
+ M->id = DS_LVAL (DS_EM->random_id);
+ tglm_message_insert_tree (TLS, M);
+ TLS->messages_allocated ++;
+ assert (tgl_message_get (TLS, M->id) == M);
+ }
+ tglf_fetch_encrypted_message_new (TLS, M, DS_EM);
+
+ if (M->flags & TGLMF_CREATED) {
+ tgl_peer_t *_E = tgl_peer_get (TLS, M->to_id);
+ assert (_E);
+ struct tgl_secret_chat *E = &_E->encr_chat;
+ if (M->action.type == tgl_message_action_request_key) {
+ if (E->exchange_state == tgl_sce_none || (E->exchange_state == tgl_sce_requested && E->exchange_id > M->action.exchange_id )) {
+ tgl_do_accept_exchange (TLS, E, M->action.exchange_id, M->action.g_a);
+ } else {
+ vlogprintf (E_WARNING, "Exchange: Incorrect state (received request, state = %d)\n", E->exchange_state);
+ }
+ }
+ if (M->action.type == tgl_message_action_accept_key) {
+ if (E->exchange_state == tgl_sce_requested && E->exchange_id == M->action.exchange_id) {
+ tgl_do_commit_exchange (TLS, E, M->action.g_a);
+ } else {
+ vlogprintf (E_WARNING, "Exchange: Incorrect state (received accept, state = %d)\n", E->exchange_state);
+ }
+ }
+ if (M->action.type == tgl_message_action_commit_key) {
+ if (E->exchange_state == tgl_sce_accepted && E->exchange_id == M->action.exchange_id) {
+ tgl_do_confirm_exchange (TLS, E, 1);
+ } else {
+ vlogprintf (E_WARNING, "Exchange: Incorrect state (received commit, state = %d)\n", E->exchange_state);
+ }
+ }
+ if (M->action.type == tgl_message_action_abort_key) {
+ if (E->exchange_state != tgl_sce_none && E->exchange_id == M->action.exchange_id) {
+ tgl_do_abort_exchange (TLS, E);
+ } else {
+ vlogprintf (E_WARNING, "Exchange: Incorrect state (received abort, state = %d)\n", E->exchange_state);
+ }
+ }
+ if (M->action.type == tgl_message_action_notify_layer) {
+ bl_do_encr_chat_new (TLS, tgl_get_peer_id (E->id),
+ NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL,
+ NULL, &M->action.layer, NULL, NULL, NULL, NULL,
+ TGL_FLAGS_UNCHANGED
+ );
+ }
+ if (M->action.type == tgl_message_action_set_message_ttl) {
+ //bl_do_encr_chat_set_ttl (TLS, E, M->action.ttl);
+ bl_do_encr_chat_new (TLS, tgl_get_peer_id (E->id),
+ NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL,
+ &M->action.ttl, NULL, NULL, NULL, NULL, NULL,
+ TGL_FLAGS_UNCHANGED
+ );
+ }
+ }
+ return M;
+}
+
+struct tgl_message *tglf_fetch_alloc_message_short_new (struct tgl_state *TLS, struct tl_ds_updates *DS_U) {
+ int id = DS_LVAL (DS_U->id);
+ struct tgl_message *M = tgl_message_get (TLS, id);
+
+ if (!M) {
+ M = talloc0 (sizeof (*M));
+ M->id = id;
+ tglm_message_insert_tree (TLS, M);
+ TLS->messages_allocated ++;
+ }
+ tglf_fetch_message_short_new (TLS, M, DS_U);
+ return M;
+}
+
+struct tgl_message *tglf_fetch_alloc_message_short_chat_new (struct tgl_state *TLS, struct tl_ds_updates *DS_U) {
+ int id = DS_LVAL (DS_U->id);
+ struct tgl_message *M = tgl_message_get (TLS, id);
+
+ if (!M) {
+ M = talloc0 (sizeof (*M));
+ M->id = id;
+ tglm_message_insert_tree (TLS, M);
+ TLS->messages_allocated ++;
+ }
+ tglf_fetch_message_short_chat_new (TLS, M, DS_U);
+ return M;
+}
+
+struct tgl_chat *tglf_fetch_alloc_chat_new (struct tgl_state *TLS, struct tl_ds_chat *DS_C) {
+ tgl_peer_t *U = tgl_peer_get (TLS, TGL_MK_CHAT (DS_LVAL (DS_C->id)));
+ if (!U) {
+ TLS->chats_allocated ++;
+ U = talloc0 (sizeof (*U));
+ U->id = TGL_MK_CHAT (DS_LVAL (DS_C->id));
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, U, lrand48 ());
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = U;
+ }
+ tglf_fetch_chat_new (TLS, &U->chat, DS_C);
+ return &U->chat;
+}
+
+struct tgl_chat *tglf_fetch_alloc_chat_full_new (struct tgl_state *TLS, struct tl_ds_messages_chat_full *DS_MCF) {
+ tgl_peer_t *U = tgl_peer_get (TLS, TGL_MK_CHAT (DS_LVAL (DS_MCF->full_chat->id)));
+ if (U) {
+ tglf_fetch_chat_full_new (TLS, &U->chat, DS_MCF);
+ return &U->chat;
+ } else {
+ TLS->chats_allocated ++;
+ U = talloc0 (sizeof (*U));
+ U->id = TGL_MK_CHAT (DS_LVAL (DS_MCF->full_chat->id));
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, U, lrand48 ());
+ tglf_fetch_chat_full_new (TLS, &U->chat, DS_MCF);
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = U;
+ return &U->chat;
+ }
+}
+
+struct tgl_bot_info *tglf_fetch_alloc_bot_info (struct tgl_state *TLS, struct tl_ds_bot_info *DS_BI) {
+ if (!DS_BI || DS_BI->magic == CODE_bot_info_empty) { return NULL; }
+ struct tgl_bot_info *B = talloc (sizeof (*B));
+ B->version = DS_LVAL (DS_BI->version);
+ B->share_text = DS_STR_DUP (DS_BI->share_text);
+ B->description = DS_STR_DUP (DS_BI->description);
+
+ B->commands_num = DS_LVAL (DS_BI->commands->cnt);
+ B->commands = talloc (sizeof (struct tgl_bot_command) * B->commands_num);
+ int i;
+ for (i = 0; i < B->commands_num; i++) {
+ struct tl_ds_bot_command *BC = DS_BI->commands->data[i];
+ B->commands[i].command = DS_STR_DUP (BC->command);
+ B->commands[i].description = DS_STR_DUP (BC->description);
+ }
+ return B;
+}
+
+struct tgl_message_reply_markup *tglf_fetch_alloc_reply_markup (struct tgl_state *TLS, struct tgl_message *M, struct tl_ds_reply_markup *DS_RM) {
+ if (!DS_RM) { return NULL; }
+
+ struct tgl_message_reply_markup *R = talloc0 (sizeof (*R));
+ R->flags = DS_LVAL (DS_RM->flags);
+ R->refcnt = 1;
+
+ R->rows = DS_RM->rows ? DS_LVAL (DS_RM->rows->cnt) : 0;
+
+ int total = 0;
+ R->row_start = talloc ((R->rows + 1) * 4);
+ R->row_start[0] = 0;
+ int i;
+ for (i = 0; i < R->rows; i++) {
+ struct tl_ds_keyboard_button_row *DS_K = DS_RM->rows->data[i];
+ total += DS_LVAL (DS_K->buttons->cnt);
+ R->row_start[i + 1] = total;
+ }
+ R->buttons = talloc (sizeof (void *) * total);
+ int r = 0;
+ for (i = 0; i < R->rows; i++) {
+ struct tl_ds_keyboard_button_row *DS_K = DS_RM->rows->data[i];
+ int j;
+ for (j = 0; j < DS_LVAL (DS_K->buttons->cnt); j++) {
+ struct tl_ds_keyboard_button *DS_KB = DS_K->buttons->data[j];
+ R->buttons[r ++] = DS_STR_DUP (DS_KB->text);
+ }
+ }
+ assert (r == total);
+ return R;
+}
+/* }}} */
+
+void tglp_insert_encrypted_chat (struct tgl_state *TLS, tgl_peer_t *P) {
+ TLS->encr_chats_allocated ++;
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, P, lrand48 ());
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = P;
+}
+
+void tglp_insert_user (struct tgl_state *TLS, tgl_peer_t *P) {
+ TLS->users_allocated ++;
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, P, lrand48 ());
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = P;
+}
+
+void tglp_insert_chat (struct tgl_state *TLS, tgl_peer_t *P) {
+ TLS->chats_allocated ++;
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, P, lrand48 ());
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = P;
+}
+
+void tgl_insert_empty_user (struct tgl_state *TLS, int uid) {
+ tgl_peer_id_t id = TGL_MK_USER (uid);
+ if (tgl_peer_get (TLS, id)) { return; }
+ tgl_peer_t *P = talloc0 (sizeof (*P));
+ P->id = id;
+ tglp_insert_user (TLS, P);
+}
+
+void tgl_insert_empty_chat (struct tgl_state *TLS, int cid) {
+ tgl_peer_id_t id = TGL_MK_CHAT (cid);
+ if (tgl_peer_get (TLS, id)) { return; }
+ tgl_peer_t *P = talloc0 (sizeof (*P));
+ P->id = id;
+ tglp_insert_chat (TLS, P);
+}
+
+/* {{{ Free */
+
+void tgls_free_photo_size (struct tgl_state *TLS, struct tgl_photo_size *S) {
+ tfree_str (S->type);
+ if (S->data) {
+ tfree (S->data, S->size);
+ }
+}
+
+void tgls_free_photo (struct tgl_state *TLS, struct tgl_photo *P) {
+ if (--P->refcnt) {
+ assert (P->refcnt > 0);
+ return;
+ }
+ if (P->caption) { tfree_str (P->caption); }
+ if (P->sizes) {
+ int i;
+ for (i = 0; i < P->sizes_num; i++) {
+ tgls_free_photo_size (TLS, &P->sizes[i]);
+ }
+ tfree (P->sizes, sizeof (struct tgl_photo_size) * P->sizes_num);
+ }
+ TLS->photo_tree = tree_delete_photo (TLS->photo_tree, P);
+ tfree (P, sizeof (*P));
+}
+
+void tgls_free_document (struct tgl_state *TLS, struct tgl_document *D) {
+ if (--D->refcnt) {
+ assert (D->refcnt);
+ return;
+ }
+ if (D->mime_type) { tfree_str (D->mime_type);}
+ if (D->caption) {tfree_str (D->caption);}
+ tgls_free_photo_size (TLS, &D->thumb);
+
+ TLS->document_tree = tree_delete_document (TLS->document_tree, D);
+ tfree (D, sizeof (*D));
+}
+
+void tgls_free_webpage (struct tgl_state *TLS, struct tgl_webpage *W) {
+ if (--W->refcnt) {
+ assert (W->refcnt);
+ return;
+ }
+ if (W->url) { tfree_str (W->url); }
+ if (W->display_url) { tfree_str (W->display_url); }
+ if (W->title) { tfree_str (W->title); }
+ if (W->site_name) { tfree_str (W->site_name); }
+ if (W->type) { tfree_str (W->type); }
+ if (W->description) { tfree_str (W->description); }
+ if (W->photo) { tgls_free_photo (TLS, W->photo); }
+ if (W->embed_url) { tfree_str (W->embed_url); }
+ if (W->embed_type) { tfree_str (W->embed_type); }
+ if (W->author) { tfree_str (W->author); }
+
+ TLS->webpage_tree = tree_delete_webpage (TLS->webpage_tree, W);
+ tfree (W, sizeof (*W));
+}
+
+void tgls_free_message_media (struct tgl_state *TLS, struct tgl_message_media *M) {
+ switch (M->type) {
+ case tgl_message_media_none:
+ case tgl_message_media_geo:
+ return;
+ case tgl_message_media_photo:
+ tgls_free_photo (TLS, M->photo);
+ M->photo = NULL;
+ return;
+ case tgl_message_media_contact:
+ tfree_str (M->phone);
+ tfree_str (M->first_name);
+ tfree_str (M->last_name);
+ return;
+ case tgl_message_media_document:
+ case tgl_message_media_video:
+ case tgl_message_media_audio:
+ tgls_free_document (TLS, M->document);
+ return;
+ case tgl_message_media_unsupported:
+ tfree (M->data, M->data_size);
+ return;
+ case tgl_message_media_document_encr:
+ tfree_secure (M->encr_document->key, 32);
+ tfree_secure (M->encr_document->iv, 32);
+ tfree (M->encr_document, sizeof (*M->encr_document));
+ return;
+ case tgl_message_media_webpage:
+ tgls_free_webpage (TLS, M->webpage);
+ return;
+ case tgl_message_media_venue:
+ if (M->venue.title) { tfree_str (M->venue.title); }
+ if (M->venue.address) { tfree_str (M->venue.address); }
+ if (M->venue.provider) { tfree_str (M->venue.provider); }
+ if (M->venue.venue_id) { tfree_str (M->venue.venue_id); }
+ return;
+ default:
+ vlogprintf (E_ERROR, "type = 0x%08x\n", M->type);
+ assert (0);
+ }
+}
+
+void tgls_free_message_action (struct tgl_state *TLS, struct tgl_message_action *M) {
+ switch (M->type) {
+ case tgl_message_action_none:
+ return;
+ case tgl_message_action_chat_create:
+ tfree_str (M->title);
+ tfree (M->users, M->user_num * 4);
+ return;
+ case tgl_message_action_chat_edit_title:
+ tfree_str (M->new_title);
+ return;
+ case tgl_message_action_chat_edit_photo:
+ tgls_free_photo (TLS, M->photo);
+ M->photo = NULL;
+ return;
+ case tgl_message_action_chat_delete_photo:
+ case tgl_message_action_chat_add_user:
+ case tgl_message_action_chat_add_user_by_link:
+ case tgl_message_action_chat_delete_user:
+ case tgl_message_action_geo_chat_create:
+ case tgl_message_action_geo_chat_checkin:
+ case tgl_message_action_set_message_ttl:
+ case tgl_message_action_read_messages:
+ case tgl_message_action_delete_messages:
+ case tgl_message_action_screenshot_messages:
+ case tgl_message_action_flush_history:
+ case tgl_message_action_typing:
+ case tgl_message_action_resend:
+ case tgl_message_action_notify_layer:
+ case tgl_message_action_commit_key:
+ case tgl_message_action_abort_key:
+ case tgl_message_action_noop:
+ return;
+ case tgl_message_action_request_key:
+ case tgl_message_action_accept_key:
+ tfree (M->g_a, 256);
+ return;
+/* default:
+ vlogprintf (E_ERROR, "type = 0x%08x\n", M->type);
+ assert (0);*/
+ }
+ vlogprintf (E_ERROR, "type = 0x%08x\n", M->type);
+ assert (0);
+}
+
+void tgls_clear_message (struct tgl_state *TLS, struct tgl_message *M) {
+ if (!(M->flags & TGLMF_SERVICE)) {
+ if (M->message) { tfree (M->message, M->message_len + 1); }
+ tgls_free_message_media (TLS, &M->media);
+ } else {
+ tgls_free_message_action (TLS, &M->action);
+ }
+}
+
+void tgls_free_reply_markup (struct tgl_state *TLS, struct tgl_message_reply_markup *R) {
+ if (!--R->refcnt) {
+ tfree (R->buttons, R->row_start[R->rows] * sizeof (void *));
+ tfree (R->row_start, 4 * (R->rows + 1));
+ tfree (R, sizeof (*R));
+ } else {
+ assert (R->refcnt > 0);
+ }
+}
+
+void tgls_free_message (struct tgl_state *TLS, struct tgl_message *M) {
+ tgls_clear_message (TLS, M);
+ if (M->reply_markup) {
+ tgls_free_reply_markup (TLS, M->reply_markup);
+ }
+ tfree (M, sizeof (*M));
+}
+
+void tgls_free_chat (struct tgl_state *TLS, struct tgl_chat *U) {
+ if (U->title) { tfree_str (U->title); }
+ if (U->print_title) { tfree_str (U->print_title); }
+ if (U->user_list) {
+ tfree (U->user_list, U->user_list_size * 12);
+ }
+ if (U->photo) { tgls_free_photo (TLS, U->photo); }
+ tfree (U, sizeof (*U));
+}
+
+void tgls_free_user (struct tgl_state *TLS, struct tgl_user *U) {
+ if (U->first_name) { tfree_str (U->first_name); }
+ if (U->last_name) { tfree_str (U->last_name); }
+ if (U->print_name) { tfree_str (U->print_name); }
+ if (U->phone) { tfree_str (U->phone); }
+ if (U->real_first_name) { tfree_str (U->real_first_name); }
+ if (U->real_last_name) { tfree_str (U->real_last_name); }
+ if (U->status.ev) { tgl_remove_status_expire (TLS, U); }
+ if (U->photo) { tgls_free_photo (TLS, U->photo); }
+ tfree (U, sizeof (*U));
+}
+
+void tgls_free_encr_chat (struct tgl_state *TLS, struct tgl_secret_chat *U) {
+ if (U->print_name) { tfree_str (U->print_name); }
+ if (U->g_key) { tfree (U->g_key, 256); }
+ tfree (U, sizeof (*U));
+}
+
+void tgls_free_peer (struct tgl_state *TLS, tgl_peer_t *P) {
+ if (tgl_get_peer_type (P->id) == TGL_PEER_USER) {
+ tgls_free_user (TLS, (void *)P);
+ } else if (tgl_get_peer_type (P->id) == TGL_PEER_CHAT) {
+ tgls_free_chat (TLS, (void *)P);
+ } else if (tgl_get_peer_type (P->id) == TGL_PEER_ENCR_CHAT) {
+ tgls_free_encr_chat (TLS, (void *)P);
+ } else {
+ assert (0);
+ }
+}
+
+void tgls_free_bot_info (struct tgl_state *TLS, struct tgl_bot_info *B) {
+ if (!B) { return; }
+ int i;
+ for (i = 0; i < B->commands_num; i++) {
+ tfree_str (B->commands[i].command);
+ tfree_str (B->commands[i].description);
+ }
+ tfree (B->commands, sizeof (struct tgl_bot_command) * B->commands_num);
+ tfree_str (B->share_text);
+ tfree_str (B->description);
+ tfree (B, sizeof (*B));
+}
+/* }}} */
+
+/* Messages {{{ */
+
+void tglm_message_del_use (struct tgl_state *TLS, struct tgl_message *M) {
+ M->next_use->prev_use = M->prev_use;
+ M->prev_use->next_use = M->next_use;
+}
+
+void tglm_message_add_use (struct tgl_state *TLS, struct tgl_message *M) {
+ M->next_use = TLS->message_list.next_use;
+ M->prev_use = &TLS->message_list;
+ M->next_use->prev_use = M;
+ M->prev_use->next_use = M;
+}
+
+void tglm_message_add_peer (struct tgl_state *TLS, struct tgl_message *M) {
+ tgl_peer_id_t id;
+ if (!tgl_cmp_peer_id (M->to_id, TGL_MK_USER (TLS->our_id))) {
+ id = M->from_id;
+ } else {
+ id = M->to_id;
+ }
+ tgl_peer_t *P = tgl_peer_get (TLS, id);
+ if (!P) {
+ P = talloc0 (sizeof (*P));
+ P->id = id;
+ switch (tgl_get_peer_type (id)) {
+ case TGL_PEER_USER:
+ TLS->users_allocated ++;
+ break;
+ case TGL_PEER_CHAT:
+ TLS->chats_allocated ++;
+ break;
+ case TGL_PEER_GEO_CHAT:
+ TLS->geo_chats_allocated ++;
+ break;
+ case TGL_PEER_ENCR_CHAT:
+ TLS->encr_chats_allocated ++;
+ break;
+ }
+ TLS->peer_tree = tree_insert_peer (TLS->peer_tree, P, lrand48 ());
+ increase_peer_size (TLS);
+ TLS->Peers[TLS->peer_num ++] = P;
+ }
+ if (!P->last) {
+ P->last = M;
+ M->prev = M->next = 0;
+ } else {
+ if (tgl_get_peer_type (P->id) != TGL_PEER_ENCR_CHAT) {
+ struct tgl_message *N = P->last;
+ struct tgl_message *NP = 0;
+ while (N && N->id > M->id) {
+ NP = N;
+ N = N->next;
+ }
+ if (N) {
+ assert (N->id < M->id);
+ }
+ M->next = N;
+ M->prev = NP;
+ if (N) { N->prev = M; }
+ if (NP) { NP->next = M; }
+ else { P->last = M; }
+ } else {
+ struct tgl_message *N = P->last;
+ struct tgl_message *NP = 0;
+ M->next = N;
+ M->prev = NP;
+ if (N) { N->prev = M; }
+ if (NP) { NP->next = M; }
+ else { P->last = M; }
+ }
+ }
+}
+
+void tglm_message_del_peer (struct tgl_state *TLS, struct tgl_message *M) {
+ tgl_peer_id_t id;
+ if (!tgl_cmp_peer_id (M->to_id, TGL_MK_USER (TLS->our_id))) {
+ id = M->from_id;
+ } else {
+ id = M->to_id;
+ }
+ tgl_peer_t *P = tgl_peer_get (TLS, id);
+ if (M->prev) {
+ M->prev->next = M->next;
+ }
+ if (M->next) {
+ M->next->prev = M->prev;
+ }
+ if (P && P->last == M) {
+ P->last = M->next;
+ }
+}
+
+struct tgl_message *tglm_message_alloc (struct tgl_state *TLS, long long id) {
+ struct tgl_message *M = talloc0 (sizeof (*M));
+ M->id = id;
+ tglm_message_insert_tree (TLS, M);
+ TLS->messages_allocated ++;
+ return M;
+}
+
+void tglm_message_insert_tree (struct tgl_state *TLS, struct tgl_message *M) {
+ assert (M->id);
+ TLS->message_tree = tree_insert_message (TLS->message_tree, M, lrand48 ());
+}
+
+void tglm_message_remove_tree (struct tgl_state *TLS, struct tgl_message *M) {
+ assert (M->id);
+ TLS->message_tree = tree_delete_message (TLS->message_tree, M);
+}
+
+void tglm_message_insert (struct tgl_state *TLS, struct tgl_message *M) {
+ tglm_message_add_use (TLS, M);
+ tglm_message_add_peer (TLS, M);
+}
+
+void tglm_message_insert_unsent (struct tgl_state *TLS, struct tgl_message *M) {
+ TLS->message_unsent_tree = tree_insert_message (TLS->message_unsent_tree, M, lrand48 ());
+}
+
+void tglm_message_remove_unsent (struct tgl_state *TLS, struct tgl_message *M) {
+ TLS->message_unsent_tree = tree_delete_message (TLS->message_unsent_tree, M);
+}
+
+static void __send_msg (struct tgl_message *M, void *_TLS) {
+ struct tgl_state *TLS = _TLS;
+ vlogprintf (E_NOTICE, "Resending message...\n");
+ //print_message (M);
+
+ if (M->media.type != tgl_message_media_none) {
+ assert (M->flags & TGLMF_ENCRYPTED);
+ bl_do_message_delete (TLS, M);
+ } else {
+ tgl_do_send_msg (TLS, M, 0, 0);
+ }
+}
+
+void tglm_send_all_unsent (struct tgl_state *TLS) {
+ tree_act_ex_message (TLS->message_unsent_tree, __send_msg, TLS);
+}
+/* }}} */
+
+struct tgl_photo *tgl_photo_get (struct tgl_state *TLS, long long id) {
+ struct tgl_photo P;
+ P.id = id;
+ return tree_lookup_photo (TLS->photo_tree, &P);
+}
+
+void tgl_photo_insert (struct tgl_state *TLS, struct tgl_photo *P) {
+ TLS->photo_tree = tree_insert_photo (TLS->photo_tree, P, lrand48 ());
+}
+
+struct tgl_document *tgl_document_get (struct tgl_state *TLS, long long id) {
+ struct tgl_document P;
+ P.id = id;
+ return tree_lookup_document (TLS->document_tree, &P);
+}
+
+void tgl_document_insert (struct tgl_state *TLS, struct tgl_document *P) {
+ TLS->document_tree = tree_insert_document (TLS->document_tree, P, lrand48 ());
+}
+
+struct tgl_webpage *tgl_webpage_get (struct tgl_state *TLS, long long id) {
+ struct tgl_webpage P;
+ P.id = id;
+ return tree_lookup_webpage (TLS->webpage_tree, &P);
+}
+
+void tgl_webpage_insert (struct tgl_state *TLS, struct tgl_webpage *P) {
+ TLS->webpage_tree = tree_insert_webpage (TLS->webpage_tree, P, lrand48 ());
+}
+
+void tglp_peer_insert_name (struct tgl_state *TLS, tgl_peer_t *P) {
+ TLS->peer_by_name_tree = tree_insert_peer_by_name (TLS->peer_by_name_tree, P, lrand48 ());
+}
+
+void tglp_peer_delete_name (struct tgl_state *TLS, tgl_peer_t *P) {
+ TLS->peer_by_name_tree = tree_delete_peer_by_name (TLS->peer_by_name_tree, P);
+}
+
+tgl_peer_t *tgl_peer_get (struct tgl_state *TLS, tgl_peer_id_t id) {
+ static tgl_peer_t U;
+ U.id = id;
+ return tree_lookup_peer (TLS->peer_tree, &U);
+}
+
+struct tgl_message *tgl_message_get (struct tgl_state *TLS, long long id) {
+ struct tgl_message M;
+ M.id = id;
+ return tree_lookup_message (TLS->message_tree, &M);
+}
+
+tgl_peer_t *tgl_peer_get_by_name (struct tgl_state *TLS, const char *s) {
+ static tgl_peer_t P;
+ P.print_name = (void *)s;
+ tgl_peer_t *R = tree_lookup_peer_by_name (TLS->peer_by_name_tree, &P);
+ return R;
+}
+
+void tgl_peer_iterator_ex (struct tgl_state *TLS, void (*it)(tgl_peer_t *P, void *extra), void *extra) {
+ tree_act_ex_peer (TLS->peer_tree, it, extra);
+}
+
+int tgl_complete_user_list (struct tgl_state *TLS, int index, const char *text, int len, char **R) {
+ index ++;
+ while (index < TLS->peer_num && (!TLS->Peers[index]->print_name || strncmp (TLS->Peers[index]->print_name, text, len) || tgl_get_peer_type (TLS->Peers[index]->id) != TGL_PEER_USER)) {
+ index ++;
+ }
+ if (index < TLS->peer_num) {
+ *R = strdup (TLS->Peers[index]->print_name);
+ assert (*R);
+ return index;
+ } else {
+ return -1;
+ }
+}
+
+int tgl_complete_chat_list (struct tgl_state *TLS, int index, const char *text, int len, char **R) {
+ index ++;
+ while (index < TLS->peer_num && (!TLS->Peers[index]->print_name || strncmp (TLS->Peers[index]->print_name, text, len) || tgl_get_peer_type (TLS->Peers[index]->id) != TGL_PEER_CHAT)) {
+ index ++;
+ }
+ if (index < TLS->peer_num) {
+ *R = strdup (TLS->Peers[index]->print_name);
+ assert (*R);
+ return index;
+ } else {
+ return -1;
+ }
+}
+
+int tgl_complete_encr_chat_list (struct tgl_state *TLS, int index, const char *text, int len, char **R) {
+ index ++;
+ while (index < TLS->peer_num && (!TLS->Peers[index]->print_name || strncmp (TLS->Peers[index]->print_name, text, len) || tgl_get_peer_type (TLS->Peers[index]->id) != TGL_PEER_ENCR_CHAT)) {
+ index ++;
+ }
+ if (index < TLS->peer_num) {
+ *R = strdup (TLS->Peers[index]->print_name);
+ assert (*R);
+ return index;
+ } else {
+ return -1;
+ }
+}
+
+int tgl_complete_peer_list (struct tgl_state *TLS, int index, const char *text, int len, char **R) {
+ index ++;
+ while (index < TLS->peer_num && (!TLS->Peers[index]->print_name || strncmp (TLS->Peers[index]->print_name, text, len))) {
+ index ++;
+ }
+ if (index < TLS->peer_num) {
+ *R = strdup (TLS->Peers[index]->print_name);
+ assert (*R);
+ return index;
+ } else {
+ return -1;
+ }
+}
+
+int tgl_secret_chat_for_user (struct tgl_state *TLS, tgl_peer_id_t user_id) {
+ int index = 0;
+ while (index < TLS->peer_num && (tgl_get_peer_type (TLS->Peers[index]->id) != TGL_PEER_ENCR_CHAT || TLS->Peers[index]->encr_chat.user_id != tgl_get_peer_id (user_id) || TLS->Peers[index]->encr_chat.state != sc_ok)) {
+ index ++;
+ }
+ if (index < TLS->peer_num) {
+ return tgl_get_peer_id (TLS->Peers[index]->encr_chat.id);
+ } else {
+ return -1;
+ }
+}
+
+void tgls_free_peer_gw (tgl_peer_t *P, void *TLS) {
+ tgls_free_peer (TLS, P);
+}
+
+void tgls_free_message_gw (struct tgl_message *M, void *TLS) {
+ tgls_free_message (TLS, M);
+}
+
+void tgl_free_all (struct tgl_state *TLS) {
+ tree_act_ex_peer (TLS->peer_tree, tgls_free_peer_gw, TLS);
+ TLS->peer_tree = tree_clear_peer (TLS->peer_tree);
+ TLS->peer_by_name_tree = tree_clear_peer_by_name (TLS->peer_by_name_tree);
+ tree_act_ex_message (TLS->message_tree, tgls_free_message_gw, TLS);
+ TLS->message_tree = tree_clear_message (TLS->message_tree);
+ tree_act_ex_message (TLS->message_unsent_tree, tgls_free_message_gw, TLS);
+ TLS->message_unsent_tree = tree_clear_message (TLS->message_unsent_tree);
+ tglq_query_free_all (TLS);
+
+ if (TLS->encr_prime) { tfree (TLS->encr_prime, 256); }
+
+
+ if (TLS->binlog_name) { tfree_str (TLS->binlog_name); }
+ if (TLS->auth_file) { tfree_str (TLS->auth_file); }
+ if (TLS->downloads_directory) { tfree_str (TLS->downloads_directory); }
+
+ int i;
+ for (i = 0; i < TLS->rsa_key_num; i++) {
+ tfree_str (TLS->rsa_key_list[i]);
+ }
+
+ for (i = 0; i <= TLS->max_dc_num; i++) if (TLS->DC_list[i]) {
+ tgls_free_dc (TLS, TLS->DC_list[i]);
+ }
+ BN_CTX_free (TLS->BN_ctx);
+ tgls_free_pubkey (TLS);
+
+ if (TLS->ev_login) { TLS->timer_methods->free (TLS->ev_login); }
+ if (TLS->online_updates_timer) { TLS->timer_methods->free (TLS->online_updates_timer); }
+}
+
+int tgl_print_stat (struct tgl_state *TLS, char *s, int len) {
+ return tsnprintf (s, len,
+ "users_allocated\t%d\n"
+ "chats_allocated\t%d\n"
+ "encr_chats_allocated\t%d\n"
+ "peer_num\t%d\n"
+ "messages_allocated\t%d\n",
+ TLS->users_allocated,
+ TLS->chats_allocated,
+ TLS->encr_chats_allocated,
+ TLS->peer_num,
+ TLS->messages_allocated
+ );
+}
+
+void tglf_fetch_int_array (int *dst, struct tl_ds_vector *src, int len) {
+ int i;
+ assert (len <= *src->f1);
+ for (i = 0; i < len; i++) {
+ dst[i] = *(int *)src->f2[i];
+ }
+}
+
+void tglf_fetch_int_tuple (int *dst, int **src, int len) {
+ int i;
+ for (i = 0; i < len; i++) {
+ dst[i] = *src[i];
+ }
+}
+
+
+void tgls_messages_mark_read (struct tgl_state *TLS, struct tgl_message *M, int out, int seq) {
+ while (M && M->id > seq) {
+ if ((M->flags & TGLMF_OUT) == out) {
+ if (!(M->flags & TGLMF_UNREAD)) {
+ return;
+ }
+ }
+ M = M->next;
+ }
+ while (M) {
+ if ((M->flags & TGLMF_OUT) == out) {
+ if (M->flags & TGLMF_UNREAD) {
+ M->flags &= ~TGLMF_UNREAD;
+ TLS->callback.marked_read (TLS, 1, &M);
+ } else {
+ return;
+ }
+ }
+ M = M->next;
+ }
+}
+
+void tgls_insert_random2local (struct tgl_state *TLS, long long random_id, int local_id) {
+ struct random2local *X = talloc (sizeof (*X));
+ X->random_id = random_id;
+ X->local_id = local_id;
+
+ struct random2local *R = tree_lookup_random_id (TLS->random_id_tree, X);
+ assert (!R);
+
+ TLS->random_id_tree = tree_insert_random_id (TLS->random_id_tree, X, lrand48 ());
+}
+
+int tgls_get_local_by_random (struct tgl_state *TLS, long long random_id) {
+ struct random2local X;
+ X.random_id = random_id;
+ struct random2local *Y = tree_lookup_random_id (TLS->random_id_tree, &X);
+ if (Y) {
+ TLS->random_id_tree = tree_delete_random_id (TLS->random_id_tree, Y);
+ int y = Y->local_id;
+ tfree (Y, sizeof (*Y));
+ return y;
+ } else {
+ return 0;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-26 19:32:17 +0000