void PingServerJob::makeJob()
{
if(session)
{
gg_ping(session);
}
}
int
GaduSession::ping()
{
if ( isConnected() ) {
return gg_ping( session_ );
}
return 1;
}
void GGWrapper::sendPing()
{
if(mpSession == NULL)
return;
auto timeNow = boost::posix_time::second_clock::local_time();
boost::posix_time::time_duration durationSinceLastPing(timeNow - mTimeSinceLastPing);
if(durationSinceLastPing.minutes() > 2)
{
gg_ping(mpSession);
mTimeSinceLastPing = timeNow;
}
}
gboolean session_ping(gpointer data){
Session *s;
debug("Ping...");
g_assert(data!=NULL);
s=(Session *)data;
if (s->waiting_for_pong){
gg_ping(s->ggs); /* send ping, even if server doesn't respond
this one will be not counted for the ping delay*/
return TRUE;
}
if (!s->ping_timer) s->ping_timer=g_timer_new();
else g_timer_reset(s->ping_timer);
g_timer_start(s->ping_timer);
gg_ping(s->ggs);
s->waiting_for_pong=TRUE;
if (s->timeout_func) g_source_remove(s->timeout_func);
s->timeout_func=g_timeout_add(pong_timeout*1000,session_timeout,s);
return TRUE;
}
static
gboolean gnomegadu_protocol_ping(gpointer data)
{
if (gnomegadu_gadugadu_session)
gg_ping (gnomegadu_gadugadu_session);
else
{
g_printerr("Ping disabled");
return FALSE;
}
return TRUE;
}
static VOID CALLBACK gg_keepalive(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime)
{
int i;
//Search for GGPROTO* context
for(i = 0; i < MAX_TIMERS; i++)
if(g_timers[i]->timer == idEvent)
break;
if(i < MAX_TIMERS)
{
GGPROTO *gg = g_timers[i];
if (gg_isonline(gg))
{
#ifdef DEBUGMODE
gg_netlog(gg, "Sending keep-alive");
#endif
EnterCriticalSection(&gg->sess_mutex);
gg_ping(gg->sess);
LeaveCriticalSection(&gg->sess_mutex);
}
}
}
int main(int argc, char **argv)
{
struct gg_session *gs;
struct gg_login_params glp;
struct gg_dcc7 *gd = NULL;
time_t ping = 0, last = 0;
int once = 0;
if (argc != 2)
usage(argv[0]);
/* strtol() ? */
if (!(argv[1][0] >= '0' && argv[1][0] <= '9'))
usage(argv[0]);
if (atoi(argv[1]) >= TEST_MODE_LAST)
usage(argv[0]);
test_mode = atoi(argv[1]);
signal(SIGPIPE, SIG_IGN);
gg_debug_file = stdout;
gg_debug_level = ~0;
if (config_read() == -1 || config_peer == 0) {
perror("config");
exit(1);
}
memset(&glp, 0, sizeof(glp));
glp.uin = config_uin;
glp.password = config_password;
glp.async = 1;
glp.status = GG_STATUS_AVAIL;
#if 0
glp.client_addr = config_ip;
glp.client_port = config_port;
#endif
glp.protocol_version = 0x2a;
glp.has_audio = 1;
glp.last_sysmsg = -1;
gg_dcc_ip = config_ip;
debug("Connecting...\n");
if (!(gs = gg_login(&glp))) {
perror("gg_login");
exit(1);
}
for (;;) {
fd_set rds, wds;
struct timeval tv;
time_t now;
int res, maxfd = -1;
FD_ZERO(&rds);
FD_ZERO(&wds);
tv.tv_sec = 1;
tv.tv_usec = 0;
maxfd = gs->fd;
if ((gs->check & GG_CHECK_READ))
FD_SET(gs->fd, &rds);
if ((gs->check & GG_CHECK_WRITE))
FD_SET(gs->fd, &wds);
if (gd && gd->fd != -1) {
if (gd->fd > maxfd)
maxfd = gd->fd;
if ((gd->check & GG_CHECK_READ))
FD_SET(gd->fd, &rds);
if ((gd->check & GG_CHECK_WRITE))
FD_SET(gd->fd, &wds);
}
if (voice_fd != -1) {
FD_SET(voice_fd, &rds);
if (voice_fd > maxfd)
maxfd = voice_fd;
}
if ((res = select(maxfd + 1, &rds, &wds, NULL, &tv)) == -1) {
if (errno == EINTR)
continue;
perror("select");
exit(1);
}
now = time(NULL);
if (last != now) {
if (gs->timeout != -1 && gs->timeout-- == 0 && !gs->soft_timeout) {
debug("Timeout\n");
exit(1);
}
/* vvvv XXX */
if (gd && gd->timeout && gd->timeout != -1 && gd->timeout-- == 0 && !gd->soft_timeout) {
debug("Timeout\n");
exit(1);
}
last = now;
}
if (gs->state == GG_STATE_CONNECTED && ping && now - ping > 60) {
ping = now;
gg_ping(gs);
}
if (FD_ISSET(gs->fd, &rds) || FD_ISSET(gs->fd, &wds) || (gs->timeout == 0 && gs->soft_timeout)) {
struct gg_event *ge;
uin_t uin;
int status;
if (!(ge = gg_watch_fd(gs))) {
debug("Connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_CONN_SUCCESS:
debug("Connected\n");
connected = 1;
gg_notify(gs, &config_peer, 1);
ping = time(NULL);
break;
case GG_EVENT_CONN_FAILED:
debug("Connection failed\n");
exit(1);
case GG_EVENT_NONE:
break;
case GG_EVENT_MSG:
debug("Message from %d: %s\n", ge->event.msg.sender, ge->event.msg.message);
break;
case GG_EVENT_DISCONNECT:
debug("Forced to disconnect\n");
exit(1);
case GG_EVENT_NOTIFY60:
uin = ge->event.notify60[0].uin;
status = ge->event.notify60[0].status;
/* fall-through */
case GG_EVENT_STATUS60:
if (ge->type == GG_EVENT_STATUS60) {
uin = ge->event.status60.uin;
status = ge->event.status60.status;
}
if (!once && uin == config_peer && (GG_S_A(status) ||
GG_S_B(status)) && test_mode == TEST_MODE_SEND)
{
debug("Sending voice request...\n");
if (voice_open_ext("/dev/dsp", 8000, 16, 2, EKG_CODEC_GSM) == -1) {
printf("voice_open_ext('/dev/dsp', "
"8000, 16, 2, CODEC_GSM) failed\n");
exit(1);
}
printf("+OK\n");
gd = gg_dcc7_voice_chat(gs, config_peer, 0x00);
if (!gd) {
perror("gg_dcc7_voice_chat");
exit(1);
}
once = 1;
}
gg_change_status(gs, GG_STATUS_AVAIL); /* XXX, libgadu sobie nie radzi */
break;
case GG_EVENT_DCC7_NEW:
debug("Incoming direct connection\n");
if (test_mode == TEST_MODE_RECEIVE) {
gd = ge->event.dcc7_new;
if (voice_open_ext("/dev/dsp", 8000, 16, 2, EKG_CODEC_GSM) == -1) {
printf("voice_open_ext('/dev/dsp', "
"8000, 16, 2, CODEC_GSM) failed\n");
exit(1);
}
printf("+OK\n");
gg_dcc7_accept_voice(gd, 0x00);
}
break;
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_ACCEPT:
debug("Accepted\n");
break;
case GG_EVENT_DCC7_REJECT:
debug("Rejected\n");
exit(1);
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (gd && gd->fd != -1 && (FD_ISSET(gd->fd, &rds) ||
FD_ISSET(gd->fd, &wds) || (gd->timeout == 0 && gd->soft_timeout)))
{
struct gg_event *ge;
if (!(ge = gg_dcc7_watch_fd(gd))) {
debug("Direct connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_CONNECTED:
debug("Direct connection established\n");
break;
case GG_EVENT_DCC7_DONE:
debug("Finished");
gg_event_free(ge);
gg_dcc7_free(gd);
gg_free_session(gs);
config_free();
exit(1);
case GG_EVENT_DCC7_VOICE_DATA:
gg_debug(GG_DEBUG_MISC,
"## GG_EVENT_DCC7_VOICE_DATA [%u]\n",
ge->event.dcc7_voice_data.length);
printf("## GG_EVENT_DCC7_VOICE_DATA [%u]\n",
ge->event.dcc7_voice_data.length);
if (voice_fd == -1) {
printf("voice_fd == -1\n");
exit(1);
}
if (ge->event.dcc7_voice_data.length == GG_DCC7_VOICE_FRAME_GSM_LENGTH)
voice_play(ge->event.dcc7_voice_data.data,
ge->event.dcc7_voice_data.length, EKG_CODEC_GSM);
else if (ge->event.dcc7_voice_data.length == GG_DCC7_VOICE_FRAME_SPEEX_LENGTH)
voice_play(ge->event.dcc7_voice_data.data,
ge->event.dcc7_voice_data.length, EKG_CODEC_SPEEX);
else if (ge->event.dcc7_voice_data.length == GG_DCC7_VOICE_FRAME_MELP_LENGTH)
voice_play(ge->event.dcc7_voice_data.data,
ge->event.dcc7_voice_data.length, EKG_CODEC_MELP);
break;
case GG_EVENT_NONE:
break;
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (voice_fd != -1 && FD_ISSET(voice_fd, &rds)) {
char buf[GG_DCC_VOICE_FRAME_LENGTH]; /* dłuższy z buforów */
int length = GG_DCC_VOICE_FRAME_LENGTH;
if (gd) {
if (gd->state == GG_STATE_READING_VOICE_DATA) {
/* XXX, implementowac speex */
length = GG_DCC7_VOICE_FRAME_GSM_LENGTH;
voice_record(buf, length, EKG_CODEC_GSM);
if (1)
gg_dcc7_voice_send(gd, buf, length);
else {
/* ten pakiet mamy wysylac co 1s */
gg_dcc7_voice_mic_off(gd);
}
} else
voice_record(buf, length, EKG_CODEC_NONE);
} else
voice_record(buf, length, EKG_CODEC_NONE);
}
}
if (gg_debug_file != stdout) /* w sumie stdout, tez moglibysmy zamknac.. czemu nie. */
fclose(gg_debug_file);
return 0;
}
void GaduProtocol::everyMinuteActions()
{
auto writableSessionToken = Connection->writableSessionToken();
gg_ping(writableSessionToken.rawSession());
}
int main(int argc, char **argv)
{
struct gg_session *gs;
struct gg_login_params glp;
struct gg_dcc7 *gd = NULL;
time_t ping = 0, last = 0;
int fds[2] = { -1, -1 };
if (argc != 2 || atoi(argv[1]) >= TEST_MODE_LAST) {
fprintf(stderr, "usage: %s <mode>\n"
"\n"
"mode: 0 - send file\n"
" 1 - send file, simulate NAT\n"
" 2 - receive file\n"
" 3 - receive file, simulate NAT\n"
" 4 - receive file, resume at the end\n"
"\n", argv[0]);
exit(1);
}
test_mode = atoi(argv[1]);
if (config_read() == -1 || config_peer == 0) {
perror("config");
exit(1);
}
#ifdef _WIN32
gg_win32_init_network();
gg_win32_hook(connect, my_connect, &connect_hook);
#else
signal(SIGPIPE, SIG_IGN);
#endif
gg_debug_file = stdout;
gg_debug_level = ~0;
if (!config_file && socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) == -1) {
perror("pipe");
exit(1);
}
memset(&glp, 0, sizeof(glp));
glp.uin = config_uin;
glp.password = config_password;
glp.async = 1;
glp.client_addr = config_ip;
glp.client_port = config_port;
glp.protocol_version = GG_PROTOCOL_VERSION_100;
if (config_dir && (test_mode == TEST_MODE_RECEIVE ||
test_mode == TEST_MODE_RECEIVE_NAT ||
test_mode == TEST_MODE_RECEIVE_RESUME))
{
if (chdir(config_dir) == -1) {
perror("chdir");
exit(1);
}
}
debug("Connecting...\n");
if (!(gs = gg_login(&glp))) {
perror("gg_login");
exit(1);
}
for (;;) {
fd_set rds, wds;
struct timeval tv;
time_t now;
int res, maxfd = -1;
FD_ZERO(&rds);
FD_ZERO(&wds);
tv.tv_sec = 1;
tv.tv_usec = 0;
maxfd = gs->fd;
if ((gs->check & GG_CHECK_READ))
FD_SET(gs->fd, &rds);
if ((gs->check & GG_CHECK_WRITE))
FD_SET(gs->fd, &wds);
if (gd && gd->fd != -1) {
if (gd->fd > maxfd)
maxfd = gd->fd;
if ((gd->check & GG_CHECK_READ))
FD_SET(gd->fd, &rds);
if ((gd->check & GG_CHECK_WRITE))
FD_SET(gd->fd, &wds);
}
if (fds[1] != -1) {
if (fds[1] > maxfd)
maxfd = fds[1];
FD_SET(fds[1], &wds);
}
if ((res = select(maxfd + 1, &rds, &wds, NULL, &tv)) == -1) {
if (errno == EINTR)
continue;
perror("select");
exit(1);
}
now = time(NULL);
if (last != now) {
if (gs->timeout != -1 && gs->timeout-- == 0 && !gs->soft_timeout) {
debug("Timeout\n");
exit(1);
}
if (gd && gd->timeout != -1 && gd->timeout-- == 0 && !gd->soft_timeout) {
debug("Timeout\n");
exit(1);
}
last = now;
}
if (gs->state == GG_STATE_CONNECTED && ping && now - ping > 60) {
ping = now;
gg_ping(gs);
}
if (FD_ISSET(gs->fd, &rds) || FD_ISSET(gs->fd, &wds) || (gs->timeout == 0 && gs->soft_timeout)) {
struct gg_event *ge;
uin_t uin;
int status;
if (!(ge = gg_watch_fd(gs))) {
debug("Connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_CONN_SUCCESS:
debug("Connected\n");
connected = 1;
gg_notify(gs, &config_peer, 1);
if (test_mode == TEST_MODE_RECEIVE_NAT)
gs->client_addr = INADDR_NONE;
ping = time(NULL);
break;
case GG_EVENT_CONN_FAILED:
debug("Connection failed\n");
exit(1);
case GG_EVENT_MSG:
debug("Message from %d: %s\n", ge->event.msg.sender, ge->event.msg.message);
break;
case GG_EVENT_DISCONNECT:
debug("Forced to disconnect\n");
exit(1);
case GG_EVENT_USER_DATA:
debug("User data\n");
break;
case GG_EVENT_NOTIFY60:
uin = ge->event.notify60[0].uin;
status = ge->event.notify60[0].status;
/* fall-through */
case GG_EVENT_STATUS60:
if (ge->type == GG_EVENT_STATUS60) {
uin = ge->event.status60.uin;
status = ge->event.status60.status;
}
if (uin == config_peer &&
(GG_S_A(status) || GG_S_B(status)) &&
(test_mode == TEST_MODE_SEND || test_mode == TEST_MODE_SEND_NAT))
{
debug("Sending file...\n");
if (config_file) {
gd = gg_dcc7_send_file(gs, config_peer,
config_file, NULL, NULL);
} else {
gd = gg_dcc7_send_file_fd(gs, config_peer, fds[0],
config_size, "test.bin", "DummySHA1HashOfAAAAA");
}
if (!gd) {
perror("gg_dcc7_send_file");
exit(1);
}
}
break;
case GG_EVENT_DCC7_NEW:
debug("Incoming direct connection\n");
if (test_mode == TEST_MODE_RECEIVE ||
test_mode == TEST_MODE_RECEIVE_NAT ||
test_mode == TEST_MODE_RECEIVE_RESUME)
{
gd = ge->event.dcc7_new;
if (config_dir) {
gd->file_fd = open((char*) gd->filename,
O_WRONLY | O_CREAT, 0600);
#if 0
lseek(gd->file_fd, gd->size, SEEK_SET);
#endif
} else
gd->file_fd = open("/dev/null", O_WRONLY);
if (gd->file_fd == -1) {
perror("open");
exit(1);
}
if (test_mode != TEST_MODE_RECEIVE_RESUME)
gg_dcc7_accept(gd, 0);
else
gg_dcc7_accept(gd, gd->size);
}
break;
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_ACCEPT:
debug("Accepted\n");
break;
case GG_EVENT_DCC7_REJECT:
debug("Rejected\n");
exit(1);
case GG_EVENT_DCC7_PENDING:
debug("Pending\n");
break;
case GG_EVENT_NONE:
break;
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (gd && gd->fd != -1 && (FD_ISSET(gd->fd, &rds) ||
FD_ISSET(gd->fd, &wds) || (gd->timeout == 0 && gd->soft_timeout)))
{
struct gg_event *ge;
if (!(ge = gg_dcc7_watch_fd(gd))) {
debug("Direct connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_CONNECTED:
debug("Direct connection established\n");
break;
case GG_EVENT_DCC7_DONE:
debug("Finished");
gg_event_free(ge);
gg_dcc7_free(gd);
gg_free_session(gs);
config_free();
exit(1);
case GG_EVENT_NONE:
break;
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (fds[1] != -1 && FD_ISSET(fds[1], &wds)) {
char buf[4096];
memset(buf, 'A', sizeof(buf));
if (write(fds[1], buf, sizeof(buf)) < 1) {
perror("write");
exit(1);
}
}
}
return 0;
}
gboolean
gnomegadu_protocol_loop (GIOChannel * source, GIOCondition condition, gpointer data)
{
static gint prev_check = GG_CHECK_READ;
gboolean ret = TRUE;
struct gg_event *e = NULL;
/* w przypadku bledu/utraty polaczenia postap tak jak w przypadku disconnect */
if (!gnomegadu_gadugadu_session || !(e = gg_watch_fd (gnomegadu_gadugadu_session)) || (condition & G_IO_ERR) ||
((condition & G_IO_HUP)
&& ((gnomegadu_gadugadu_session->state != GG_STATE_CONNECTING_GG) && (gnomegadu_gadugadu_session->check != GG_CHECK_WRITE))))
{
g_printerr ("gnomegadu_protocol_loop(): some kind of problem while processing\n");
gnomegadu_gadugadu_disconnect ();
prev_check = GG_CHECK_READ;
return FALSE;
}
switch (e->type)
{
case GG_EVENT_NONE:
g_print ("GG_EVENT_NONE\n");
break;
case GG_EVENT_PONG:
g_print ("GG_EVENT_PONG\n");
gg_ping (gnomegadu_gadugadu_session);
break;
case GG_EVENT_CONN_FAILED:
g_print ("GG_EVENT_CONN_FAILED\n");
gnomegadu_gadugadu_disconnect ();
ret = FALSE;
break;
case GG_EVENT_DISCONNECT:
g_print ("GG_EVENT_DISCONNECT\n");
gnomegadu_gadugadu_disconnect ();
ret = FALSE;
break;
case GG_EVENT_CONN_SUCCESS:
{
g_print ("GG_EVENT_CONN_SUCCESS\n");
//wysyłam swoją listę
gint i, j = 0;
uint32_t *uins;
GSList *contacts_list = gnomegadu_conf_get_contacts ();
GSList *contacts_list_start = contacts_list;
gnomegadu_protocol_is_connected = TRUE;
if (!contacts_list)
break;
i = g_slist_length (contacts_list);
uins = g_malloc0 (i * sizeof (uint32_t));
while (contacts_list)
{
gchar *uin_str;
gchar *path = (gchar *) contacts_list->data;
gchar *uin_path = g_strconcat (path, "/uin", NULL);
uin_str = gconf_client_get_string (gconf, uin_path, NULL);
uins[j++] = g_strtod (uin_str, NULL);
g_free (uin_path);
contacts_list = g_slist_next(contacts_list);
}
if (j > 0)
gg_notify (gnomegadu_gadugadu_session, uins, i);
/* pingpong */
g_timeout_add(100000, gnomegadu_protocol_ping, NULL);
g_slist_foreach (contacts_list_start, gnomegadu_conf_free_list_of_string, NULL);
g_slist_free (contacts_list_start);
g_free (uins);
}
break;
// case GG_EVENT_NOTIFY_DESCR:
case GG_EVENT_NOTIFY:
{
gint i;
g_print ("GG_EVENT_NOTIFY\n");
for (i = 0; e->event.notify[i].uin; i++)
{
gchar *uin_str = g_strdup_printf ("%d", e->event.notify[i].uin);
gint new_status = gnomegadu_gadugadu_from_protocol_status (e->event.notify[i].status);
gnomegadu_userlist_set_model_status (uin_str, new_status, NULL); //tutaj dodac obsluge opisów
g_free (uin_str);
}
}
break;
case GG_EVENT_NOTIFY60:
{
gint i;
g_print ("GG_EVENT_NOTIFY60\n");
for (i = 0; e->event.notify60[i].uin; i++)
{
gchar *descr_utf = NULL;
gchar *uin_str = g_strdup_printf ("%d", e->event.notify60[i].uin);
gint new_status = gnomegadu_gadugadu_from_protocol_status (e->event.notify60[i].status);
if (e->event.notify60[i].descr)
descr_utf =
g_convert (e->event.notify60[i].descr, strlen (e->event.notify60[i].descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
gnomegadu_userlist_set_model_status (uin_str, new_status, descr_utf);
g_free (uin_str);
}
}
break;
case GG_EVENT_STATUS:
case GG_EVENT_STATUS60:
{
GdkPixbuf *pix = NULL;
gchar *descr_utf = NULL;
gchar *uuid = NULL;
gchar *display = NULL;
gchar *notify_txt = NULL;
gint new_status;
gchar *uin_str = NULL;
if (e->type == GG_EVENT_STATUS)
{
new_status = gnomegadu_gadugadu_from_protocol_status (e->event.status.status);
uin_str = g_strdup_printf ("%d", e->event.status.uin);
if (e->event.status.descr)
descr_utf = g_convert (e->event.status.descr, strlen (e->event.status.descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
} else {
new_status = gnomegadu_gadugadu_from_protocol_status (e->event.status60.status);
uin_str = g_strdup_printf ("%d", e->event.status60.uin);
if (e->event.status60.descr)
descr_utf = g_convert (e->event.status60.descr, strlen (e->event.status60.descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
}
gnomegadu_userlist_set_model_status (uin_str, new_status, descr_utf);
uuid = gnomegadu_conf_contact_get_uuid_for_uin(uin_str);
display = gnomegadu_conf_contact_get_display_for_uuid(uuid);
pix = gnomegadu_stock_get_pixbuf (gnomegadu_ui_status_get_icon_name (new_status));
notify_txt = g_strdup_printf("Status: %s\n<span size=\"smaller\" style=\"italic\">%s</span>",gnomegadu_protocol_status_txt(new_status),descr_utf ? descr_utf : "");
gnomegadu_ui_notify_show (display, notify_txt, pix);
g_object_unref (pix);
gnomegadu_tray_blinking(2000);
g_free (notify_txt);
g_free (display);
g_free (uuid);
g_free (uin_str);
}
break;
case GG_EVENT_USERLIST:
{
g_print ("GG_EVENT_USERLIST\n");
if (e->event.userlist.type == GG_USERLIST_GET_REPLY)
{
gint i;
gfloat step;
gchar **split_buf = NULL;
GtkWidget *progress = glade_xml_get_widget (gladexml_import_userlist_progress, "ImportUserlistServerProgress");
GtkWidget *progress_window = glade_xml_get_widget (gladexml_import_userlist_progress, "ImportUserlistServerProgressWindow");
if (!progress_window || !progress)
break;
gchar *buf = e->event.userlist.reply;
if (!buf)
{
gtk_widget_destroy(GTK_WIDGET(progress_window));
GtkDialog *msgdialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
"<span weight=\"bold\"size=\"larger\">Lista jest pusta</span>\n\nLista kontaktów na serwerze jest pusta.");
gtk_dialog_run (GTK_DIALOG (msgdialog));
gtk_widget_destroy (GTK_WIDGET (msgdialog));
break;
}
GConfChangeSet *changeset = gconf_change_set_new();
split_buf = g_strsplit (buf, "\r\n", 2048);
step = 1 / (gfloat)g_strv_length (split_buf);
for (i = 0; i < g_strv_length (split_buf); i++)
{
gdouble percentage = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR (progress));
if (percentage < 1)
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), percentage + step);
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL,TRUE);
gnomegadu_ui_import_userlist_process_line (split_buf[i], changeset);
if (!gconf_client_commit_change_set(gconf, changeset, TRUE, NULL))
g_printerr("Some error while import");
}
gconf_change_set_unref(changeset);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), 1);
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL,TRUE);
gtk_widget_destroy(GTK_WIDGET(progress_window));
}
}
break;
case GG_EVENT_MSG:
{
gchar *uin_sender = NULL;
if (e->event.msg.msgclass == GG_CLASS_CHAT)
{
gint i = 0;
uin_sender = g_strdup_printf("%d", e->event.msg.sender);
gchar *txt = g_strdup((gchar *)e->event.msg.message);
gchar *txt_utf = NULL;
GList *list = NULL;
g_print("message from sender: (%s):%s\n",uin_sender,txt);
/* first add sender */
list = g_list_append(list,g_strdup(uin_sender));
if (e->event.msg.recipients_count > 0)
{
gchar *uin_str_2 = NULL;
/* then add recipients */
for (i = 0; i < e->event.msg.recipients_count; i++)
{
uin_str_2 = g_strdup_printf("%d",e->event.msg.recipients[i]);
list = g_list_append(list,g_strdup(uin_str_2));
g_free(uin_str_2);
g_print("conference(%d): %s\n",e->event.msg.recipients_count,uin_str_2);
}
}
g_assert(list);
//chat window
GladeXML *chat_window_xml = gnomegadu_ui_chat_find(list,TRUE);
g_assert(chat_window_xml);
txt_utf = g_convert (txt, strlen (txt), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
gnomegadu_ui_chat_append_text(chat_window_xml,txt_utf,GNOMEGADU_CHAT_RCV, uin_sender);
g_free(txt);
g_free(uin_sender);
}
}
break;
}
gg_free_event (e);
if (gnomegadu_gadugadu_session && prev_check != gnomegadu_gadugadu_session->check)
{
prev_check = gnomegadu_gadugadu_session->check;
if (gnomegadu_gadugadu_session->check == GG_CHECK_READ)
{
g_source_remove (gnomegadu_watch_protocol);
gnomegadu_watch_protocol = g_io_add_watch (gnomegadu_source_chan, G_IO_IN | G_IO_ERR | G_IO_HUP, gnomegadu_protocol_loop, NULL);
ret = FALSE;
}
if (gnomegadu_gadugadu_session->check == GG_CHECK_WRITE)
{
g_source_remove (gnomegadu_watch_protocol);
gnomegadu_watch_protocol = g_io_add_watch (gnomegadu_source_chan, G_IO_OUT | G_IO_ERR | G_IO_HUP, gnomegadu_protocol_loop, NULL);
ret = FALSE;
}
}
return ret;
}
