lua-tg.c

/*
    This file is part of telegram-cli.

    Telegram-cli 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-cli 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-cli.  If not, see <http://www.gnu.org/licenses/>.

    Copyright Vitaly Valtman 2013-2015
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef USE_LUA
#include "lua-tg.h"

#include <string.h>
#include <stdlib.h>


#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
#ifdef EVENT_V2
#include <event2/event.h>
#else
#include <event.h>
#include "event-old.h"
#endif
lua_State *luaState;

//#include "interface.h"
//#include "auto/constants.h"
#include <tgl/tgl.h>
#include "interface.h"

#include <assert.h>
extern int verbosity;
extern struct tgl_state *TLS;

static int have_file;

void print_start (void);
void print_end (void);

int ps_lua_pcall (lua_State *l, int a, int b, int c) {
  print_start ();
  int r = lua_pcall (l, a, b, c);
  print_end ();
  return r;
}

#define my_lua_checkstack(L,x) assert (lua_checkstack (L, x))
void push_user (tgl_peer_t *P);
void push_peer (tgl_peer_id_t id, tgl_peer_t *P);

void lua_add_string_field (const char *name, const char *value) {
  assert (name && strlen (name));
  if (!value || !strlen (value)) { return; }
  my_lua_checkstack (luaState, 3);
  lua_pushstring (luaState, name);
  lua_pushstring (luaState, value);
  lua_settable (luaState, -3);
}

void lua_add_lstring_field (const char *name, const char *value, int len) {
  assert (name && strlen (name));
  if (!value || !len) { return; }
  my_lua_checkstack (luaState, 3);
  lua_pushstring (luaState, name);
  lua_pushlstring (luaState, len, value);
  lua_settable (luaState, -3);
}

void lua_add_string_field_arr (int num, const char *value) {
  if (!value || !strlen (value)) { return; }
  my_lua_checkstack (luaState, 3);
  lua_pushnumber (luaState, num);
  lua_pushstring (luaState, value);
  lua_settable (luaState, -3);
}

void lua_add_num_field (const char *name, double value) {
  assert (name && strlen (name));
  my_lua_checkstack (luaState, 3);
  lua_pushstring (luaState, name);
  lua_pushnumber (luaState, value);
  lua_settable (luaState, -3);
}

void push_tgl_peer_type (int x) {
  switch (x) {
  case TGL_PEER_USER:
    lua_pushstring (luaState, "user");
    break;
  case TGL_PEER_CHAT:
    lua_pushstring (luaState, "chat");
    break;
  case TGL_PEER_ENCR_CHAT:
    lua_pushstring (luaState, "encr_chat");
    break;
  case TGL_PEER_CHANNEL:
    lua_pushstring (luaState, "channel");
    break;
  default:
    assert (0);
  }
}

void push_user (tgl_peer_t *P) {
  my_lua_checkstack (luaState, 4);
  lua_add_string_field ("first_name", P->user.first_name);
  lua_add_string_field ("last_name", P->user.last_name);
  lua_add_string_field ("real_first_name", P->user.real_first_name);
  lua_add_string_field ("real_last_name", P->user.real_last_name);
  lua_add_string_field ("phone", P->user.phone);
  lua_add_string_field ("username", P->user.username);
  if (P->user.access_hash) {
    lua_add_num_field ("access_hash", 1);
  }
}

void push_chat (tgl_peer_t *P) {
  my_lua_checkstack (luaState, 4);
  assert (P->chat.title);
  lua_add_string_field ("title", P->chat.title);
  lua_add_num_field ("members_num", P->chat.users_num);
  if (P->chat.user_list) {
    lua_pushstring (luaState, "members");
    lua_newtable (luaState);
    int i;
    for (i = 0; i < P->chat.users_num; i++) {
      lua_pushnumber (luaState, i);
      tgl_peer_id_t id = TGL_MK_USER (P->chat.user_list[i].user_id);
      push_peer (id, tgl_peer_get (TLS, id));
      lua_settable (luaState, -3);
    }
    lua_settable (luaState, -3);
  }
}

void push_encr_chat (tgl_peer_t *P) {
  my_lua_checkstack (luaState, 4);
  lua_pushstring (luaState, "user");
  push_peer (TGL_MK_USER (P->encr_chat.user_id), tgl_peer_get (TLS, TGL_MK_USER (P->encr_chat.user_id)));
  lua_settable (luaState, -3);
}

void push_channel (tgl_peer_t *P) {
  my_lua_checkstack (luaState, 4);
  lua_add_string_field (luaState, "title", P->channel.title);
  lua_add_string_field (luaState, "about", P->channel.about);
  lua_add_num_field (luaState, "participants_count", P->channel.participants_count);
  lua_add_num_field (luaState, "admins_count", P->channel.admins_count);
  lua_add_num_field (luaState, "kicked_count", P->channel.kicked_count);
}

void push_update_types (unsigned flags) {
  my_lua_checkstack (luaState, 4);
  lua_newtable (luaState);
  int cc = 0;
  
  
  if (flags & TGL_UPDATE_CREATED) {
    lua_add_string_field_arr (cc++, "created");
  }  
  if (flags & TGL_UPDATE_DELETED) {
    lua_add_string_field_arr (cc++, "deleted");
  }  
  if (flags & TGL_UPDATE_PHONE) {
    lua_add_string_field_arr (cc++, "phone");
  }
  if (flags & TGL_UPDATE_CONTACT) {
    lua_add_string_field_arr (cc++, "contact");
  }
  if (flags & TGL_UPDATE_PHOTO) {
    lua_add_string_field_arr (cc++, "photo");
  }
  if (flags & TGL_UPDATE_BLOCKED) {
    lua_add_string_field_arr (cc++, "blocked");
  }
  if (flags & TGL_UPDATE_REAL_NAME) {
    lua_add_string_field_arr (cc++, "real_name");
  }
  if (flags & TGL_UPDATE_NAME) {
    lua_add_string_field_arr (cc++, "name");
  }
  if (flags & TGL_UPDATE_REQUESTED) {
    lua_add_string_field_arr (cc++, "requested");
  }
  if (flags & TGL_UPDATE_WORKING) {
    lua_add_string_field_arr (cc++, "working");
  }
  if (flags & TGL_UPDATE_FLAGS) {
    lua_add_string_field_arr (cc++, "flags");
  }
  if (flags & TGL_UPDATE_TITLE) {
    lua_add_string_field_arr (cc++, "title");
  }
  if (flags & TGL_UPDATE_ADMIN) {
    lua_add_string_field_arr (cc++, "admin");
  }
  if (flags & TGL_UPDATE_MEMBERS) {
    lua_add_string_field_arr (cc++, "members");
  }
  if (flags & TGL_UPDATE_ACCESS_HASH) {
    lua_add_string_field_arr (cc++, "access_hash");
  }
  if (flags & TGL_UPDATE_USERNAME) {
    lua_add_string_field_arr (cc++, "username");
  }

}

void push_peer (tgl_peer_id_t id, tgl_peer_t *P) {
  lua_newtable (luaState);
  
  lua_add_lstring_field ("id", print_permanent_peer_id (P->id));
  lua_add_string_field (luaState, "type", tgl_get_peer_type (id));

  if (!P || !(P->flags & TGLPF_CREATED)) {
    lua_pushstring (luaState, "print_name"); 
    static char s[100];
    switch (tgl_get_peer_type (id)) {
    case TGL_PEER_USER:
      sprintf (s, "user#%d", tgl_get_peer_id (id));
      break;
    case TGL_PEER_CHAT:
      sprintf (s, "chat#%d", tgl_get_peer_id (id));
      break;
    case TGL_PEER_ENCR_CHAT:
      sprintf (s, "encr_chat#%d", tgl_get_peer_id (id));
      break;
    case TGL_PEER_CHANNEL:
      sprintf (s, "channel#%d", tgl_get_peer_id (id));
      break;
    default:
      assert (0);
    }
    lua_pushstring (luaState, s); 
    lua_settable (luaState, -3); // flags
  
    return;
  }
  
  lua_add_string_field ("print_name", P->print_name);
  lua_add_num_field ("flags", P->flags);
  
  switch (tgl_get_peer_type (id)) {
  case TGL_PEER_USER:
    push_user (P);
    break;
  case TGL_PEER_CHAT:
    push_chat (P);
    break;
  case TGL_PEER_ENCR_CHAT:
    push_encr_chat (P);
    break;
  default:
    assert (0);
  }
}

void push_media (struct tgl_message_media *M) {
  my_lua_checkstack (luaState, 4);

  switch (M->type) {
  case tgl_message_media_photo:
    lua_newtable (luaState);
    lua_add_string_field ("type", "photo");
    lua_add_string_field ("caption", M->caption);
    break;
  case tgl_message_media_document:
  case tgl_message_media_document_encr:
    lua_newtable (luaState);
    lua_add_string_field ("type", "document");
    break;
  case tgl_message_media_unsupported:
    lua_newtable (luaState);
    lua_add_string_field ("type", "unsupported");
    break;
  case tgl_message_media_geo:
    lua_newtable (luaState);
    lua_add_string_field ("type", "geo");
    lua_add_num_field ("longitude", M->geo.longitude);
    lua_add_num_field ("latitude", M->geo.latitude);
    break;
  case tgl_message_media_contact:
    lua_newtable (luaState);
    lua_add_string_field ("type", "contact");
    lua_add_string_field ("phone", M->phone);
    lua_add_string_field ("first_name", M->first_name);
    lua_add_string_field ("last_name", M->last_name);
    lua_add_num_field ("user_id", M->user_id);
    break;
  case tgl_message_media_webpage:
    lua_newtable (luaState);
    lua_add_string_field ("type", "webpage");
    lua_add_string_field ("url", M->webpage->url);
    lua_add_string_field ("title", M->webpage->title);
    lua_add_string_field ("description", M->webpage->description);
    lua_add_string_field ("author", M->webpage->author);
    break;
  case tgl_message_media_venue:
    lua_newtable (luaState);
    lua_add_string_field ("type", "venue");
    lua_add_num_field ("longitude", M->venue.geo.longitude);
    lua_add_num_field ("latitude", M->venue.geo.latitude);
    lua_add_string_field ("title", M->venue.title);
    lua_add_string_field ("address", M->venue.address);
    lua_add_string_field ("provider", M->venue.provider);
    lua_add_string_field ("venue_id", M->venue.venue_id);
    break;
  default:
    lua_pushstring (luaState, "???");
  }
}

void push_service (struct tgl_message *M) {
  my_lua_checkstack (luaState, 4);
  switch (M->action.type) {
  case tgl_message_action_geo_chat_create:
    lua_newtable (luaState);
    lua_add_string_field ("type", "geo_created");
    break;
  case tgl_message_action_geo_chat_checkin:
    lua_newtable (luaState);
    lua_add_string_field ("type", "geo_checkin");
    break;
  case tgl_message_action_chat_create:
    lua_newtable (luaState);
    lua_add_string_field ("type", "chat_created");
    lua_add_string_field ("title", M->action.title);
    break;
  case tgl_message_action_chat_edit_title:
    lua_newtable (luaState);
    lua_add_string_field ("type", "chat_rename");
    lua_add_string_field ("title", M->action.title);
    break;
  case tgl_message_action_chat_edit_photo:
    lua_newtable (luaState);
    lua_add_string_field ("type", "chat_change_photo");
    break;
  case tgl_message_action_chat_delete_photo:
    lua_newtable (luaState);
    lua_add_string_field ("type", "chat_delete_photo");
    break;
  case tgl_message_action_chat_add_user:
    lua_newtable (luaState);
    lua_add_string_field ("type", "chat_add_user");
    
    lua_pushstring (luaState, "user");
    push_peer (tgl_set_peer_id (TGL_PEER_USER, M->action.user), tgl_peer_get (TLS, tgl_set_peer_id (TGL_PEER_USER, M->action.user)));
    lua_settable (luaState, -3);
    break;
  case tgl_message_action_chat_add_user_by_link:
    lua_newtable (luaState);
    lua_add_string_field ("type", "chat_add_user_link");
    
    lua_pushstring (luaState, "link_issuer");
    push_peer (tgl_set_peer_id (TGL_PEER_USER, M->action.user), tgl_peer_get (TLS, tgl_set_peer_id (TGL_PEER_USER, M->action.user)));
    lua_settable (luaState, -3);
    break;
  case tgl_message_action_chat_delete_user:
    lua_newtable (luaState);
    lua_add_string_field ("type", "chat_del_user");
    
    lua_pushstring (luaState, "user");
    push_peer (tgl_set_peer_id (TGL_PEER_USER, M->action.user), tgl_peer_get (TLS, tgl_set_peer_id (TGL_PEER_USER, M->action.user)));
    lua_settable (luaState, -3);
    break;
  case tgl_message_action_set_message_ttl:
    lua_newtable (luaState);
    lua_add_string_field ("type", "set_ttl");
    lua_add_num_field ("ttl", M->action.ttl);
    break;
  case tgl_message_action_read_messages:
    lua_newtable (luaState);
    lua_add_string_field ("type", "read");
    lua_add_num_field ("count", M->action.read_cnt);
    break;
  case tgl_message_action_delete_messages:
    lua_newtable (luaState);
    lua_add_string_field ("type", "delete");
    lua_add_num_field ("count", M->action.delete_cnt);
    break;
  case tgl_message_action_screenshot_messages:
    lua_newtable (luaState);
    lua_add_string_field ("type", "screenshot");
    lua_add_num_field ("count", M->action.screenshot_cnt);
    break;
  case tgl_message_action_flush_history:
    lua_newtable (luaState);
    lua_add_string_field ("type", "flush");
    break;
  case tgl_message_action_resend:
    lua_newtable (luaState);
    lua_add_string_field ("type", "resend");
    break;
  case tgl_message_action_notify_layer:
    lua_newtable (luaState);
    lua_add_string_field ("type", "set_layer");
    lua_add_num_field ("layer", M->action.layer);
    break;
  case tgl_message_action_typing:    
    lua_newtable (luaState);
    lua_add_string_field ("type", "typing");
    break;
  case tgl_message_action_noop:
    lua_newtable (luaState);
    lua_add_string_field ("type", "nop");
    break;
  case tgl_message_action_request_key:
    lua_newtable (luaState);
    lua_add_string_field ("type", "request_rekey");
    break;
  case tgl_message_action_accept_key:
    lua_newtable (luaState);
    lua_add_string_field ("type", "accept_rekey");
    break;
  case tgl_message_action_commit_key:
    lua_newtable (luaState);
    lua_add_string_field ("type", "commit_rekey");
    break;
  case tgl_message_action_abort_key:
    lua_newtable (luaState);
    lua_add_string_field ("type", "abort_rekey");
    break;
  case tgl_message_action_channel_create:
    lua_newtable (luaState);
    lua_add_string_field ("type", "channel_created");
    lua_add_string_field ("title", M->action.title);
    break;
  /*default:
    lua_pushstring (luaState, "???");
    break;*/
  }
}

void push_message (struct tgl_message *M) {  
  assert (M);
  my_lua_checkstack (luaState, 10);
  lua_newtable (luaState);

  lua_add_string_field ("id", print_permanent_msg_id (M->permanent_id));
  if (!(M->flags & TGLMF_CREATED)) { return; }
  lua_add_num_field ("flags", M->flags);
 
  if (tgl_get_peer_type (M->fwd_from_id)) {
    lua_pushstring (luaState, "fwd_from");
    push_peer (M->fwd_from_id, tgl_peer_get (TLS, M->fwd_from_id));
    lua_settable (luaState, -3); // fwd_from

    lua_add_num_field ("fwd_date", M->fwd_date);
  }

  if (M->reply_id) {
    lua_add_num_field ("reply_id", M->reply_id);
  }

  if (M->flags & TGLMF_MENTION) {
    lua_pushstring (luaState, "mention");
    lua_pushboolean (luaState, 1);
    lua_settable (luaState, -3); 
  }
 
  lua_pushstring (luaState, "from");
  push_peer (M->from_id, tgl_peer_get (TLS, M->from_id));
  lua_settable (luaState, -3); 
  
  lua_pushstring (luaState, "to");
  push_peer (M->to_id, tgl_peer_get (TLS, M->to_id));
  lua_settable (luaState, -3); 
  
  lua_pushstring (luaState, "out");
  lua_pushboolean (luaState, (M->flags & TGLMF_OUT) != 0);
  lua_settable (luaState, -3); 
  
  lua_pushstring (luaState, "unread");
  lua_pushboolean (luaState, (M->flags & TGLMF_UNREAD) != 0);
  lua_settable (luaState, -3); 
  
  lua_pushstring (luaState, "date");
  lua_pushnumber (luaState, M->date);
  lua_settable (luaState, -3); 
  
  lua_pushstring (luaState, "service");
  lua_pushboolean (luaState, (M->flags & TGLMF_SERVICE) != 0);
  lua_settable (luaState, -3); 

  if (!(M->flags & TGLMF_SERVICE)) {  
    if (M->message_len && M->message) {
      lua_pushstring (luaState, "text");
      lua_pushlstring (luaState, M->message, M->message_len);
      lua_settable (luaState, -3); 
    }
    if (M->media.type && M->media.type != tgl_message_media_none) {
      lua_pushstring (luaState, "media");
      push_media (&M->media);
      lua_settable (luaState, -3); 
    }
  } else {
    lua_pushstring (luaState, "action");
    push_service (M);
    lua_settable (luaState, -3); 
  }
}

void lua_binlog_end (void) {
  if (!have_file) { return; }
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);
  lua_getglobal (luaState, "on_binlog_replay_end");
  assert (lua_gettop (luaState) == 1);

  int r = ps_lua_pcall (luaState, 0, 0, 0);
  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }
}

void lua_diff_end (void) {
  if (!have_file) { return; }
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);
  lua_getglobal (luaState, "on_get_difference_end");
  assert (lua_gettop (luaState) == 1);

  int r = ps_lua_pcall (luaState, 0, 0, 0);
  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }
}

void lua_our_id (int id) {
  if (!have_file) { return; }
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);
  lua_getglobal (luaState, "on_our_id");
  lua_pushnumber (luaState, id);
  assert (lua_gettop (luaState) == 2);

  int r = ps_lua_pcall (luaState, 1, 0, 0);
  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }
}

void lua_new_msg (struct tgl_message *M) {
  if (!have_file) { return; }
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);
  lua_getglobal (luaState, "on_msg_receive");
  push_message (M);
  assert (lua_gettop (luaState) == 2);

  int r = ps_lua_pcall (luaState, 1, 0, 0);
  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }
}

void lua_secret_chat_update (struct tgl_secret_chat *C, unsigned flags) {
  if (!have_file) { return; }
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);
  lua_getglobal (luaState, "on_secret_chat_update");
  push_peer (C->id, (void *)C);
  push_update_types (flags);
  assert (lua_gettop (luaState) == 3);

  int r = ps_lua_pcall (luaState, 2, 0, 0);
  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }
}

void lua_user_update (struct tgl_user *U, unsigned flags) {
  if (!have_file) { return; }
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);
  lua_getglobal (luaState, "on_user_update");
  push_peer (U->id, (void *)U);
  push_update_types (flags);
  assert (lua_gettop (luaState) == 3);

  int r = ps_lua_pcall (luaState, 2, 0, 0);
  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }
}

void lua_chat_update (struct tgl_chat *C, unsigned flags) {
  if (!have_file) { return; }
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);
  lua_getglobal (luaState, "on_chat_update");
  push_peer (C->id, (void *)C);
  push_update_types (flags);
  assert (lua_gettop (luaState) == 3);

  int r = ps_lua_pcall (luaState, 2, 0, 0);
  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }
}

//extern tgl_peer_t *Peers[];
//extern int peer_num;

#define MAX_LUA_COMMANDS 1000
void *lua_ptr[MAX_LUA_COMMANDS];
static int pos;

static inline tgl_peer_t *get_peer (const char *s) { 
  return tgl_peer_get_by_name (TLS, s);
}
  
enum lua_query_type {
  lq_contact_list,
  lq_dialog_list,
  lq_msg,
  lq_send_typing,
  lq_send_typing_abort,
  lq_rename_chat,
  lq_send_photo,
  lq_chat_set_photo,
  lq_set_profile_photo,
  lq_set_profile_name,
  lq_send_video,
  lq_send_text,
  lq_fwd,
  lq_fwd_media,
  lq_load_photo,
  lq_load_video_thumb,
  lq_load_video,
  lq_chat_info,
  lq_user_info,
  lq_history,
  lq_chat_add_user,
  lq_chat_del_user,
  lq_add_contact,
  lq_del_contact,
  lq_rename_contact,
  lq_search,
  lq_global_search,
  lq_mark_read,
  lq_create_secret_chat,
  lq_create_group_chat,
  lq_send_audio,
  lq_send_document,
  lq_send_file,
  lq_load_audio,
  lq_load_document,
  lq_load_document_thumb,
  lq_delete_msg,
  lq_restore_msg,
  lq_accept_secret_chat,
  lq_send_contact,
  lq_status_online,
  lq_status_offline,
  lq_send_location,
  lq_extf,
  lq_import_chat_link
};

struct lua_query_extra {
  int func;
  int param;
};

void lua_empty_cb (struct tgl_state *TLSR, void *cb_extra, int success) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  assert (lua_gettop (luaState) == 3);

  int r = ps_lua_pcall (luaState, 2, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_contact_list_cb (struct tgl_state *TLSR, void *cb_extra, int success, int num, struct tgl_user **UL) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  if (success) {
    lua_newtable (luaState);
    int i;
    for (i = 0; i < num; i++) {
      lua_pushnumber (luaState, i);
      push_peer (UL[i]->id, (void *)UL[i]);
      lua_settable (luaState, -3);
    }
  } else {
    lua_pushboolean (luaState, 0);
  }

  assert (lua_gettop (luaState) == 4);

  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_dialog_list_cb (struct tgl_state *TLSR, void *cb_extra, int success, int num, tgl_peer_id_t peers[], int msgs[], int unread[]) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);
  if (success) {
    lua_newtable (luaState);
    int i;
    for (i = 0; i < num; i++) {
      lua_pushnumber (luaState, i);

      lua_newtable (luaState);

      lua_pushstring (luaState, "peer");
      push_peer (peers[i], tgl_peer_get (TLS, peers[i]));
      lua_settable (luaState, -3);

      struct tgl_message *M = tgl_message_get (TLS, msgs[i]);
      if (M && (M->flags & TGLMF_CREATED)) {
        lua_pushstring (luaState, "message");
        push_message (M);
        lua_settable (luaState, -3);
      }

      lua_pushstring (luaState, "unread");
      lua_pushnumber (luaState, unread[i]);
      lua_settable (luaState, -3);

      lua_settable (luaState, -3);
    }
  } else {
    lua_pushboolean (luaState, 0);
  }
  assert (lua_gettop (luaState) == 4);


  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_msg_cb (struct tgl_state *TLSR, void *cb_extra, int success, struct tgl_message *M) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  if (success && M && (M->flags & TGLMF_CREATED)) {
    push_message (M);
  } else {
    lua_pushboolean (luaState, 0);
  }

  assert (lua_gettop (luaState) == 4);

  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_msg_list_cb (struct tgl_state *TLSR, void *cb_extra, int success, int num, struct tgl_message *M[]) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  if (success) {
    lua_newtable (luaState);
    int i;
    for (i = 0; i < num; i++) {
      lua_pushnumber (luaState, i);
      push_message (M[i]);
      lua_settable (luaState, -3);
    }
  } else {
    lua_pushboolean (luaState, 0);
  }

  assert (lua_gettop (luaState) == 4);

  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_file_cb (struct tgl_state *TLSR, void *cb_extra, int success, const char *file_name) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  if (success) {
    lua_pushstring (luaState, file_name);
  } else {
    lua_pushboolean (luaState, 0);
  }

  assert (lua_gettop (luaState) == 4);

  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_chat_cb (struct tgl_state *TLSR, void *cb_extra, int success, struct tgl_chat *C) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  if (success) {
    push_peer (C->id, (void *)C);
  } else {
    lua_pushboolean (luaState, 0);
  }

  assert (lua_gettop (luaState) == 4);

  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_secret_chat_cb (struct tgl_state *TLSR, void *cb_extra, int success, struct tgl_secret_chat *C) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  if (success) {
    push_peer (C->id, (void *)C);
  } else {
    lua_pushboolean (luaState, 0);
  }

  assert (lua_gettop (luaState) == 4);

  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }

  free (cb);
}

void lua_user_cb (struct tgl_state *TLSR, void *cb_extra, int success, struct tgl_user *C) {
  assert (TLSR == TLS);
  struct lua_query_extra *cb = cb_extra;
  lua_settop (luaState, 0);
  //lua_checkstack (luaState, 20);
  my_lua_checkstack (luaState, 20);

  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->func);
  lua_rawgeti (luaState, LUA_REGISTRYINDEX, cb->param);

  lua_pushnumber (luaState, success);

  if (success) {
    push_peer (C->id, (void *)C);
  } else {
    lua_pushboolean (luaState, 0);
  }

  assert (lua_gettop (luaState) == 4);

  int r = ps_lua_pcall (luaState, 3, 0, 0);

  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->func);
  luaL_unref (luaState, LUA_REGISTRYINDEX, cb->param);

  if (r) {
    logprintf ("lua: %s\n",  lua_tostring (luaState, -1));
  }