tg/loop.c

366 lines
8.6 KiB
C
Raw Normal View History

2013-10-23 10:26:17 -04:00
/*
This file is part of telegram-client.
Telegram-client is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
Telegram-client 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this telegram-client. If not, see <http://www.gnu.org/licenses/>.
Copyright Vitaly Valtman 2013
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _GNU_SOURCE
#define READLINE_CALLBACKS
2013-10-03 08:38:25 -04:00
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef READLINE_GNU
2013-10-03 08:38:25 -04:00
#include <readline/readline.h>
#include <readline/history.h>
#else
2013-11-11 06:34:45 -05:00
#include <readline/readline.h>
#include <readline/history.h>
#endif
2013-10-03 08:38:25 -04:00
2013-10-03 12:09:06 -04:00
#include <errno.h>
2013-10-11 16:52:20 -04:00
#include <poll.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
2013-10-03 12:09:06 -04:00
2014-08-15 10:57:43 -04:00
#include <event2/event.h>
2013-10-03 08:38:25 -04:00
#include "interface.h"
2013-10-11 16:52:20 -04:00
#include "telegram.h"
2013-11-04 12:34:27 -05:00
#include "loop.h"
2014-01-11 19:43:29 -05:00
#include "lua-tg.h"
2014-08-13 08:56:55 -04:00
#include "tgl.h"
2013-10-11 16:52:20 -04:00
2014-08-15 10:57:43 -04:00
int verbosity;
2013-10-03 08:38:25 -04:00
extern char *default_username;
extern char *auth_token;
void set_default_username (const char *s);
2013-11-12 19:11:25 -05:00
extern int binlog_enabled;
2013-10-03 08:38:25 -04:00
2013-10-23 06:24:59 -04:00
extern int unknown_user_list_pos;
extern int unknown_user_list[];
2013-11-21 14:35:49 -05:00
int register_mode;
extern int safe_quit;
extern int queries_num;
2013-10-03 08:38:25 -04:00
void got_it (char *line, int len);
2014-08-15 10:57:43 -04:00
static void stdin_read_callback (evutil_socket_t fd, short what, void *arg) {
if (((long)arg) & 1) {
rl_callback_read_char ();
} else {
char *line = 0;
size_t len = 0;
assert (getline (&line, &len, stdin) >= 0);
got_it (line, strlen (line));
}
}
2013-10-11 16:52:20 -04:00
void net_loop (int flags, int (*is_end)(void)) {
2014-08-15 10:57:43 -04:00
struct event *ev = 0;
if (flags & 3) {
ev = event_new (tgl_state.ev_base, 0, EV_READ | EV_PERSIST, stdin_read_callback, (void *)(long)flags);
event_add (ev, 0);
}
while (!is_end || !is_end ()) {
event_base_loop (tgl_state.ev_base, EVLOOP_ONCE);
2013-10-03 08:38:25 -04:00
2014-01-11 19:43:29 -05:00
#ifdef USE_LUA
lua_do_all ();
#endif
if (safe_quit && !queries_num) {
printf ("All done. Exit\n");
rl_callback_handler_remove ();
exit (0);
}
2013-10-23 06:24:59 -04:00
if (unknown_user_list_pos) {
2014-08-15 10:57:43 -04:00
int i;
for (i = 0; i < unknown_user_list_pos; i++) {
tgl_do_get_user_info (TGL_MK_USER (unknown_user_list[i]), 0, 0, 0);
}
2013-10-23 06:24:59 -04:00
unknown_user_list_pos = 0;
}
2013-10-03 12:09:06 -04:00
}
2014-08-15 10:57:43 -04:00
if (ev) {
event_free (ev);
}
2013-10-11 16:52:20 -04:00
}
char **_s;
size_t *_l;
int got_it_ok;
void got_it (char *line, int len) {
2013-12-18 10:21:49 -05:00
assert (len > 0);
line[-- len] = 0; // delete end of line
*_s = line;
*_l = len;
got_it_ok = 1;
}
int is_got_it (void) {
return got_it_ok;
}
int net_getline (char **s, size_t *l) {
fflush (stdout);
// rl_already_prompted = 1;
got_it_ok = 0;
_s = s;
_l = l;
// rl_callback_handler_install (0, got_it);
net_loop (2, is_got_it);
return 0;
}
2013-10-11 16:52:20 -04:00
int main_loop (void) {
2014-08-15 10:57:43 -04:00
net_loop (1, 0);
2013-10-03 12:09:06 -04:00
return 0;
2013-10-03 08:38:25 -04:00
}
2014-08-15 10:57:43 -04:00
struct dc *cur_a_dc;
int is_authorized (void) {
return tgl_authorized_dc (cur_a_dc);
}
int config_got;
int got_config (void) {
return config_got;
}
void on_get_config (void *extra, int success) {
if (!success) {
logprintf ("Can not get config.\n");
exit (1);
}
config_got = 1;
2013-10-11 16:52:20 -04:00
}
2014-08-15 10:57:43 -04:00
int should_register;
char *hash;
void sign_in_callback (void *extra, int success, int registered, const char *mhash) {
if (!success) {
logprintf ("Can not send code\n");
exit (1);
}
should_register = !registered;
hash = strdup (mhash);
}
int signed_in_ok;
void sign_in_result (void *extra, int success, struct tgl_user *U) {
if (!success) {
logprintf ("Can not login\n");
exit (1);
}
signed_in_ok = 1;
}
2014-08-15 10:57:43 -04:00
int signed_in (void) {
return signed_in_ok;
}
int sent_code (void) {
return hash != 0;
2013-11-04 12:34:27 -05:00
}
2014-08-15 10:57:43 -04:00
int dc_signed_in (void) {
return tgl_signed_dc (cur_a_dc);
}
void export_auth_callback (void *DC, int success) {
if (!success) {
logprintf ("Can not export auth\n");
exit (1);
}
}
int zero[512];
int readline_active;
int new_dc_num;
int wait_dialog_list;
2013-10-03 08:38:25 -04:00
int loop (void) {
2014-08-14 14:03:33 -04:00
//on_start ();
tgl_init ();
2014-08-15 10:57:43 -04:00
double t = tglt_get_double_time ();
2014-08-14 14:03:33 -04:00
logprintf ("replay log start\n");
tgl_replay_log ();
2014-08-15 10:57:43 -04:00
logprintf ("replay log end in %lf seconds\n", tglt_get_double_time () - t);
2014-08-14 14:03:33 -04:00
tgl_reopen_binlog_for_writing ();
#ifdef USE_LUA
lua_binlog_end ();
#endif
update_prompt ();
2014-08-15 10:57:43 -04:00
if (!tgl_authorized_dc (tgl_state.DC_working)) {
cur_a_dc = tgl_state.DC_working;
tgl_dc_authorize (tgl_state.DC_working);
net_loop (0, is_authorized);
}
2014-08-15 10:57:43 -04:00
tgl_do_help_get_config (on_get_config, 0);
net_loop (0, got_config);
if (verbosity) {
logprintf ("DC_info: %d new DC got\n", new_dc_num);
}
2014-08-15 10:57:43 -04:00
int i;
2014-08-15 10:57:43 -04:00
for (i = 0; i <= tgl_state.max_dc_num; i++) if (tgl_state.DC_list[i] && !tgl_authorized_dc (tgl_state.DC_list[i])) {
cur_a_dc = tgl_state.DC_list[i];
tgl_dc_authorize (cur_a_dc);
net_loop (0, is_authorized);
2013-10-11 16:52:20 -04:00
}
2014-08-15 10:57:43 -04:00
if (!tgl_signed_dc (tgl_state.DC_working)) {
2013-10-11 16:52:20 -04:00
if (!default_username) {
size_t size = 0;
char *user = 0;
if (!user) {
2013-10-11 16:52:20 -04:00
printf ("Telephone number (with '+' sign): ");
if (net_getline (&user, &size) == -1) {
2013-10-11 16:52:20 -04:00
perror ("getline()");
exit (EXIT_FAILURE);
}
set_default_username (user);
}
2013-10-03 12:10:53 -04:00
}
2014-08-15 10:57:43 -04:00
tgl_do_send_code (default_username, sign_in_callback, 0);
net_loop (0, sent_code);
logprintf ("%s\n", should_register ? "phone not registered" : "phone registered");
if (!should_register) {
char *code = 0;
size_t size = 0;
2014-02-24 06:27:30 -05:00
printf ("Code from sms (if you did not receive an SMS and want to be called, type \"call\"): ");
while (1) {
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
2014-02-24 06:27:30 -05:00
if (!strcmp (code, "call")) {
2014-02-25 15:31:27 -05:00
printf ("You typed \"call\", switching to phone system.\n");
2014-08-15 10:57:43 -04:00
tgl_do_phone_call (default_username, hash, 0, 0);
printf ("Calling you! Code: ");
continue;
}
2014-08-15 10:57:43 -04:00
if (tgl_do_send_code_result (default_username, hash, code, sign_in_result, 0) >= 0) {
break;
}
printf ("Invalid code. Try again: ");
2014-08-15 10:57:43 -04:00
free (code);
}
} else {
printf ("User is not registered. Do you want to register? [Y/n] ");
char *code;
size_t size;
if (net_getline (&code, &size) == -1) {
2013-10-11 16:52:20 -04:00
perror ("getline()");
exit (EXIT_FAILURE);
}
2013-11-01 15:57:57 -04:00
if (!*code || *code == 'y' || *code == 'Y') {
printf ("Ok, starting registartion.\n");
} else {
printf ("Then try again\n");
exit (EXIT_SUCCESS);
}
char *first_name;
printf ("First name: ");
if (net_getline (&first_name, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
2013-10-11 16:52:20 -04:00
}
char *last_name;
printf ("Last name: ");
if (net_getline (&last_name, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
2014-02-24 06:27:30 -05:00
printf ("Code from sms (if you did not receive an SMS and want to be called, type \"call\"): ");
while (1) {
if (net_getline (&code, &size) == -1) {
perror ("getline()");
exit (EXIT_FAILURE);
}
2014-02-24 06:27:30 -05:00
if (!strcmp (code, "call")) {
2014-02-25 15:31:27 -05:00
printf ("You typed \"call\", switching to phone system.\n");
2014-08-15 10:57:43 -04:00
tgl_do_phone_call (default_username, hash, 0, 0);
printf ("Calling you! Code: ");
continue;
}
2014-08-15 10:57:43 -04:00
if (tgl_do_send_code_result_auth (default_username, hash, code, first_name, last_name, sign_in_result, 0) >= 0) {
break;
}
printf ("Invalid code. Try again: ");
2014-08-15 10:57:43 -04:00
free (code);
}
2013-10-11 16:52:20 -04:00
}
2014-08-15 10:57:43 -04:00
net_loop (0, signed_in);
bl_do_dc_signed (tgl_state.DC_working);
2013-10-03 08:38:25 -04:00
}
2013-10-11 16:52:20 -04:00
2014-08-15 10:57:43 -04:00
for (i = 0; i <= tgl_state.max_dc_num; i++) if (tgl_state.DC_list[i] && !tgl_signed_dc (tgl_state.DC_list[i])) {
tgl_do_export_auth (i, export_auth_callback, (void*)(long)tgl_state.DC_list[i]);
cur_a_dc = tgl_state.DC_working;
net_loop (0, dc_signed_in);
}
2014-08-15 10:57:43 -04:00
//write_auth_file ();
2013-10-11 16:52:20 -04:00
fflush (stdout);
fflush (stderr);
2013-10-03 08:38:25 -04:00
2014-08-15 10:57:43 -04:00
//read_state_file ();
//read_secret_chat_file ();
set_interface_callbacks ();
2014-08-15 10:57:43 -04:00
tgl_do_get_difference (0, 0);
2013-11-04 12:34:27 -05:00
net_loop (0, dgot);
2014-01-11 19:43:29 -05:00
#ifdef USE_LUA
lua_diff_end ();
#endif
2014-08-13 11:55:16 -04:00
tglm_send_all_unsent ();
2014-01-11 19:43:29 -05:00
2014-08-13 11:55:16 -04:00
tgl_do_get_dialog_list ();
if (wait_dialog_list) {
dialog_list_got = 0;
net_loop (0, dlgot);
}
2013-10-03 08:38:25 -04:00
return main_loop ();
}