1 /*
2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 *
18 */
19
20 #ifdef HAVE_CONFIG_H
21 # include "config.h"
22 #include "claws-features.h"
23 #endif
24
25 #include "defs.h"
26
27 #include <glib.h>
28 #include <glib/gi18n.h>
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <time.h>
35 #include <errno.h>
36
37 #include "session.h"
38 #include "utils.h"
39 #include "log.h"
40
41 static gint session_connect_cb (SockInfo *sock,
42 gpointer data);
43 static gint session_close (Session *session);
44
45 static gboolean session_timeout_cb (gpointer data);
46
47 static gboolean session_recv_msg_idle_cb (gpointer data);
48 static gboolean session_recv_data_idle_cb (gpointer data);
49
50 static gboolean session_read_msg_cb (SockInfo *source,
51 GIOCondition condition,
52 gpointer data);
53 static gboolean session_read_data_cb (SockInfo *source,
54 GIOCondition condition,
55 gpointer data);
56 static gboolean session_write_msg_cb (SockInfo *source,
57 GIOCondition condition,
58 gpointer data);
59 static gboolean session_write_data_cb (SockInfo *source,
60 GIOCondition condition,
61 gpointer data);
62
63
session_init(Session * session,const void * prefs_account,gboolean is_smtp)64 void session_init(Session *session, const void *prefs_account, gboolean is_smtp)
65 {
66 session->type = SESSION_UNKNOWN;
67 session->sock = NULL;
68 session->server = NULL;
69 session->port = 0;
70 #ifdef USE_GNUTLS
71 session->ssl_type = SSL_NONE;
72 session->use_tls_sni = TRUE;
73 #endif
74 session->nonblocking = TRUE;
75 session->state = SESSION_READY;
76 session->last_access_time = time(NULL);
77
78 session->tv_prev = g_date_time_new_now_local();
79
80 session->conn_id = 0;
81
82 session->io_tag = 0;
83
84 session->read_buf_p = session->read_buf;
85 session->read_buf_len = 0;
86
87 session->read_msg_buf = g_string_sized_new(1024);
88 session->read_data_buf = g_byte_array_new();
89
90 session->write_buf = NULL;
91 session->write_buf_p = NULL;
92 session->write_buf_len = 0;
93
94 session->write_data = NULL;
95 session->write_data_p = NULL;
96 session->write_data_len = 0;
97
98 session->timeout_tag = 0;
99 session->timeout_interval = 0;
100
101 session->data = NULL;
102 session->account = prefs_account;
103 session->is_smtp = is_smtp;
104
105 session->ping_tag = -1;
106
107 session->proxy_info = NULL;
108 }
109
110 /*!
111 *\brief Set up parent and child process
112 * Childloop: Read commands from parent,
113 * send to server, get answer, pass to parent
114 *
115 *\param session Contains session information
116 * server to connect to
117 * port to connect to
118 *
119 *\return 0 : success
120 * -1 : pipe / fork errors (parent)
121 * 1 : connection error (child)
122 */
session_connect(Session * session,const gchar * server,gushort port)123 gint session_connect(Session *session, const gchar *server, gushort port)
124 {
125 session->server = g_strdup(server);
126 session->port = port;
127
128 if (session->proxy_info) {
129 server = session->proxy_info->proxy_host;
130 port = session->proxy_info->proxy_port;
131 }
132
133 #ifdef G_OS_UNIX
134 session->conn_id = sock_connect_async(server, port, session_connect_cb,
135 session);
136 if (session->conn_id < 0) {
137 g_warning("can't connect to server.");
138 session_close(session);
139 if (session->connect_finished)
140 session->connect_finished(session, FALSE);
141 return -1;
142 }
143
144 return 0;
145 #else
146 SockInfo *sock;
147
148 sock = sock_connect(server, port);
149 if (sock == NULL) {
150 g_warning("can't connect to server.");
151 session_close(session);
152 if (session->connect_finished)
153 session->connect_finished(session, FALSE);
154 return -1;
155 }
156 sock->is_smtp = session->is_smtp;
157
158 return session_connect_cb(sock, session);
159 #endif
160 }
161
session_connect_cb(SockInfo * sock,gpointer data)162 static gint session_connect_cb(SockInfo *sock, gpointer data)
163 {
164 Session *session = SESSION(data);
165
166 session->conn_id = 0;
167
168 if (!sock) {
169 g_warning("can't connect to server.");
170 session->state = SESSION_ERROR;
171 if (session->connect_finished)
172 session->connect_finished(session, FALSE);
173 return -1;
174 }
175
176 session->sock = sock;
177 sock->account = session->account;
178 sock->is_smtp = session->is_smtp;
179 sock->ssl_cert_auto_accept = session->ssl_cert_auto_accept;
180
181 if (session->proxy_info) {
182 debug_print("connecting through socks\n");
183 sock_set_nonblocking_mode(sock, FALSE);
184 if (proxy_connect(sock, session->server, session->port,
185 session->proxy_info) < 0) {
186 g_warning("can't establish SOCKS connection.");
187 session->state = SESSION_ERROR;
188 return -1;
189 }
190 }
191
192
193 #ifdef USE_GNUTLS
194 sock->gnutls_priority = session->gnutls_priority;
195 sock->use_tls_sni = session->use_tls_sni;
196
197 if (session->ssl_type == SSL_TUNNEL) {
198 sock_set_nonblocking_mode(sock, FALSE);
199 if (!ssl_init_socket(sock)) {
200 g_warning("can't initialize SSL/TLS.");
201 log_error(LOG_PROTOCOL, _("SSL/TLS handshake failed\n"));
202 session->state = SESSION_ERROR;
203 if (session->connect_finished)
204 session->connect_finished(session, FALSE);
205 return -1;
206 }
207 }
208 #endif
209
210 /* we could have gotten a timeout while waiting for user input in
211 * an SSL certificate dialog */
212 if (session->state == SESSION_TIMEOUT) {
213 if (session->connect_finished)
214 session->connect_finished(session, FALSE);
215 return -1;
216 }
217
218 sock_set_nonblocking_mode(sock, session->nonblocking);
219
220 debug_print("session (%p): connected\n", session);
221
222 session->state = SESSION_RECV;
223 session->io_tag = sock_add_watch(session->sock, G_IO_IN,
224 session_read_msg_cb,
225 session);
226
227 if (session->connect_finished)
228 session->connect_finished(session, TRUE);
229 return 0;
230 }
231
232 /*!
233 *\brief child and parent: send DISCONNECT message to other process
234 *
235 *\param session Contains session information
236 *
237 *\return 0 : success
238 */
session_disconnect(Session * session)239 gint session_disconnect(Session *session)
240 {
241 session_close(session);
242 return 0;
243 }
244
245 /*!
246 *\brief parent ?
247 *
248 *\param session Contains session information
249 */
session_destroy(Session * session)250 void session_destroy(Session *session)
251 {
252 cm_return_if_fail(session != NULL);
253 cm_return_if_fail(session->destroy != NULL);
254
255 session_register_ping(session, NULL);
256
257 session_close(session);
258 session->destroy(session);
259 g_free(session->server);
260 g_string_free(session->read_msg_buf, TRUE);
261 g_byte_array_free(session->read_data_buf, TRUE);
262 g_free(session->read_data_terminator);
263 g_free(session->write_buf);
264 #ifdef USE_GNUTLS
265 g_free(session->gnutls_priority);
266 #endif
267 g_date_time_unref(session->tv_prev);
268 debug_print("session (%p): destroyed\n", session);
269
270 g_free(session);
271 }
272
session_is_running(Session * session)273 gboolean session_is_running(Session *session)
274 {
275 return (session->state == SESSION_READY ||
276 session->state == SESSION_SEND ||
277 session->state == SESSION_RECV);
278 }
279
session_is_connected(Session * session)280 gboolean session_is_connected(Session *session)
281 {
282 return (session->state == SESSION_SEND ||
283 session->state == SESSION_RECV);
284 }
285
session_set_access_time(Session * session)286 void session_set_access_time(Session *session)
287 {
288 session->last_access_time = time(NULL);
289 }
290
session_set_timeout(Session * session,guint interval)291 void session_set_timeout(Session *session, guint interval)
292 {
293 if (session->timeout_tag > 0)
294 g_source_remove(session->timeout_tag);
295
296 session->timeout_interval = interval;
297 if (interval > 0) {
298 if (interval % 1000 == 0)
299 session->timeout_tag =
300 g_timeout_add_seconds(interval/1000, session_timeout_cb, session);
301 else
302 session->timeout_tag =
303 g_timeout_add(interval, session_timeout_cb, session);
304 } else
305 session->timeout_tag = 0;
306 }
307
session_timeout_cb(gpointer data)308 static gboolean session_timeout_cb(gpointer data)
309 {
310 Session *session = SESSION(data);
311
312 g_warning("session timeout.");
313
314 if (session->io_tag > 0) {
315 g_source_remove(session->io_tag);
316 session->io_tag = 0;
317 }
318
319 session->timeout_tag = 0;
320 session->state = SESSION_TIMEOUT;
321
322 return FALSE;
323 }
324
session_set_recv_message_notify(Session * session,RecvMsgNotify notify_func,gpointer data)325 void session_set_recv_message_notify(Session *session,
326 RecvMsgNotify notify_func, gpointer data)
327 {
328 session->recv_msg_notify = notify_func;
329 session->recv_msg_notify_data = data;
330 }
331
session_set_recv_data_progressive_notify(Session * session,RecvDataProgressiveNotify notify_func,gpointer data)332 void session_set_recv_data_progressive_notify
333 (Session *session,
334 RecvDataProgressiveNotify notify_func,
335 gpointer data)
336 {
337 session->recv_data_progressive_notify = notify_func,
338 session->recv_data_progressive_notify_data = data;
339 }
340
session_set_recv_data_notify(Session * session,RecvDataNotify notify_func,gpointer data)341 void session_set_recv_data_notify(Session *session, RecvDataNotify notify_func,
342 gpointer data)
343 {
344 session->recv_data_notify = notify_func;
345 session->recv_data_notify_data = data;
346 }
347
session_set_send_data_progressive_notify(Session * session,SendDataProgressiveNotify notify_func,gpointer data)348 void session_set_send_data_progressive_notify
349 (Session *session,
350 SendDataProgressiveNotify notify_func,
351 gpointer data)
352 {
353 session->send_data_progressive_notify = notify_func;
354 session->send_data_progressive_notify_data = data;
355 }
356
session_set_send_data_notify(Session * session,SendDataNotify notify_func,gpointer data)357 void session_set_send_data_notify(Session *session, SendDataNotify notify_func,
358 gpointer data)
359 {
360 session->send_data_notify = notify_func;
361 session->send_data_notify_data = data;
362 }
363
364 /*!
365 *\brief child and parent cleanup (child closes first)
366 *
367 *\param session Contains session information
368 *
369 *\return 0 : success
370 */
session_close(Session * session)371 static gint session_close(Session *session)
372 {
373 cm_return_val_if_fail(session != NULL, -1);
374
375 #ifdef G_OS_UNIX
376 if (session->conn_id > 0) {
377 sock_connect_async_cancel(session->conn_id);
378 session->conn_id = 0;
379 debug_print("session (%p): connection cancelled\n", session);
380 }
381 #endif
382
383 session_set_timeout(session, 0);
384
385 if (session->io_tag > 0) {
386 g_source_remove(session->io_tag);
387 session->io_tag = 0;
388 }
389
390 if (session->sock) {
391 sock_close(session->sock, TRUE);
392 session->sock = NULL;
393 session->state = SESSION_DISCONNECTED;
394 debug_print("session (%p): closed\n", session);
395 }
396
397 return 0;
398 }
399
400 #ifdef USE_GNUTLS
session_start_tls(Session * session)401 gint session_start_tls(Session *session)
402 {
403 gboolean nb_mode;
404
405 nb_mode = sock_is_nonblocking_mode(session->sock);
406
407 session->sock->ssl_cert_auto_accept = session->ssl_cert_auto_accept;
408 session->sock->gnutls_priority = session->gnutls_priority;
409 session->sock->use_tls_sni = session->use_tls_sni;
410
411 if (nb_mode)
412 sock_set_nonblocking_mode(session->sock, FALSE);
413
414 if (!ssl_init_socket(session->sock)) {
415 g_warning("couldn't start STARTTLS session.");
416 if (nb_mode)
417 sock_set_nonblocking_mode(session->sock, session->nonblocking);
418 return -1;
419 }
420
421 if (0 < session->read_buf_len) {
422 g_warning("protocol violation: suffix data after STARTTLS detected.");
423 if (nb_mode)
424 sock_set_nonblocking_mode(session->sock, session->nonblocking);
425 return -1;
426 }
427
428 if (nb_mode)
429 sock_set_nonblocking_mode(session->sock, session->nonblocking);
430
431 return 0;
432 }
433 #endif
434
session_send_msg(Session * session,const gchar * msg)435 gint session_send_msg(Session *session, const gchar *msg)
436 {
437 gboolean ret;
438
439 cm_return_val_if_fail(session->write_buf == NULL, -1);
440 cm_return_val_if_fail(msg != NULL, -1);
441
442 session->state = SESSION_SEND;
443 session->write_buf = g_strconcat((strlen(msg) > 0 ? msg : ""), "\r\n", NULL);
444 session->write_buf_p = session->write_buf;
445 session->write_buf_len = strlen(msg) + 2;
446
447 ret = session_write_msg_cb(session->sock, G_IO_OUT, session);
448
449 if (ret == TRUE)
450 session->io_tag = sock_add_watch(session->sock, G_IO_OUT,
451 session_write_msg_cb, session);
452 else if (session->state == SESSION_ERROR)
453 return -1;
454
455 return 0;
456 }
457
session_recv_msg(Session * session)458 gint session_recv_msg(Session *session)
459 {
460 cm_return_val_if_fail(session->read_msg_buf->len == 0, -1);
461
462 session->state = SESSION_RECV;
463
464 if (session->read_buf_len > 0)
465 g_idle_add(session_recv_msg_idle_cb, session);
466 else
467 session->io_tag = sock_add_watch(session->sock, G_IO_IN,
468 session_read_msg_cb, session);
469
470 return 0;
471 }
472
session_recv_msg_idle_cb(gpointer data)473 static gboolean session_recv_msg_idle_cb(gpointer data)
474 {
475 Session *session = SESSION(data);
476 gboolean ret;
477
478 ret = session_read_msg_cb(session->sock, G_IO_IN, session);
479
480 if (ret == TRUE)
481 session->io_tag = sock_add_watch(session->sock, G_IO_IN,
482 session_read_msg_cb, session);
483
484 return FALSE;
485 }
486
487 /*!
488 *\brief parent (child?): send data to other process
489 *
490 *\param session Contains session information
491 * data Data to send
492 * size Bytes to send
493 *
494 *\return 0 : success
495 * -1 : error
496 */
session_send_data(Session * session,const guchar * data,guint size)497 gint session_send_data(Session *session, const guchar *data, guint size)
498 {
499 gboolean ret;
500
501 cm_return_val_if_fail(session->write_data == NULL, -1);
502 cm_return_val_if_fail(data != NULL, -1);
503 cm_return_val_if_fail(size != 0, -1);
504
505 session->state = SESSION_SEND;
506
507 session->write_data = data;
508 session->write_data_p = session->write_data;
509 session->write_data_len = size;
510 g_date_time_unref(session->tv_prev);
511 session->tv_prev = g_date_time_new_now_local();
512
513 ret = session_write_data_cb(session->sock, G_IO_OUT, session);
514
515 if (ret == TRUE)
516 session->io_tag = sock_add_watch(session->sock, G_IO_OUT,
517 session_write_data_cb,
518 session);
519 else if (session->state == SESSION_ERROR)
520 return -1;
521
522 return 0;
523 }
524
session_recv_data(Session * session,guint size,const gchar * terminator)525 gint session_recv_data(Session *session, guint size, const gchar *terminator)
526 {
527 cm_return_val_if_fail(session->read_data_buf->len == 0, -1);
528
529 session->state = SESSION_RECV;
530
531 g_free(session->read_data_terminator);
532 session->read_data_terminator = g_strdup(terminator);
533 g_date_time_unref(session->tv_prev);
534 session->tv_prev = g_date_time_new_now_local();
535
536 if (session->read_buf_len > 0)
537 g_idle_add(session_recv_data_idle_cb, session);
538 else
539 session->io_tag = sock_add_watch(session->sock, G_IO_IN,
540 session_read_data_cb, session);
541
542 return 0;
543 }
544
session_recv_data_idle_cb(gpointer data)545 static gboolean session_recv_data_idle_cb(gpointer data)
546 {
547 Session *session = SESSION(data);
548 gboolean ret;
549
550 ret = session_read_data_cb(session->sock, G_IO_IN, session);
551
552 if (ret == TRUE)
553 session->io_tag = sock_add_watch(session->sock, G_IO_IN,
554 session_read_data_cb, session);
555
556 return FALSE;
557 }
558
session_read_msg_cb(SockInfo * source,GIOCondition condition,gpointer data)559 static gboolean session_read_msg_cb(SockInfo *source, GIOCondition condition,
560 gpointer data)
561 {
562 Session *session = SESSION(data);
563 gchar buf[SESSION_BUFFSIZE];
564 gint line_len;
565 gchar *newline;
566 gchar *msg;
567 gint ret;
568
569 cm_return_val_if_fail(condition == G_IO_IN, FALSE);
570
571 session_set_timeout(session, session->timeout_interval);
572
573 if (session->read_buf_len == 0) {
574 gint read_len = -1;
575
576 if (session->sock)
577 read_len = sock_read(session->sock, session->read_buf,
578 SESSION_BUFFSIZE - 1);
579
580 if (read_len == -1 && session->state == SESSION_DISCONNECTED) {
581 g_warning ("sock_read: session disconnected");
582 if (session->io_tag > 0) {
583 g_source_remove(session->io_tag);
584 session->io_tag = 0;
585 }
586 return FALSE;
587 }
588
589 if (read_len == 0) {
590 g_warning("sock_read: received EOF");
591 session->state = SESSION_EOF;
592 return FALSE;
593 }
594
595 if (read_len < 0) {
596 switch (errno) {
597 case EAGAIN:
598 return TRUE;
599 default:
600 g_warning("sock_read: %s", g_strerror(errno));
601 session->state = SESSION_ERROR;
602 return FALSE;
603 }
604 }
605
606 session->read_buf_len = read_len;
607 }
608
609 if ((newline = memchr(session->read_buf_p, '\n', session->read_buf_len))
610 != NULL)
611 line_len = newline - session->read_buf_p + 1;
612 else
613 line_len = session->read_buf_len;
614
615 if (line_len == 0)
616 return TRUE;
617
618 memcpy(buf, session->read_buf_p, line_len);
619 buf[line_len] = '\0';
620
621 g_string_append(session->read_msg_buf, buf);
622
623 session->read_buf_len -= line_len;
624 if (session->read_buf_len == 0)
625 session->read_buf_p = session->read_buf;
626 else
627 session->read_buf_p += line_len;
628
629 /* incomplete read */
630 if (buf[line_len - 1] != '\n')
631 return TRUE;
632
633 /* complete */
634 if (session->io_tag > 0) {
635 g_source_remove(session->io_tag);
636 session->io_tag = 0;
637 }
638
639 /* callback */
640 msg = g_strdup(session->read_msg_buf->str);
641 strretchomp(msg);
642 g_string_truncate(session->read_msg_buf, 0);
643
644 ret = session->recv_msg(session, msg);
645 session->recv_msg_notify(session, msg, session->recv_msg_notify_data);
646
647 g_free(msg);
648
649 if (ret < 0)
650 session->state = SESSION_ERROR;
651
652 return FALSE;
653 }
654
session_read_data_cb(SockInfo * source,GIOCondition condition,gpointer data)655 static gboolean session_read_data_cb(SockInfo *source, GIOCondition condition,
656 gpointer data)
657 {
658 Session *session = SESSION(data);
659 GByteArray *data_buf;
660 gint terminator_len;
661 gboolean complete = FALSE;
662 guint data_len;
663 gint ret;
664
665 cm_return_val_if_fail(condition == G_IO_IN, FALSE);
666
667 session_set_timeout(session, session->timeout_interval);
668
669 if (session->read_buf_len == 0) {
670 gint read_len;
671
672 read_len = sock_read(session->sock, session->read_buf,
673 SESSION_BUFFSIZE);
674
675 if (read_len == 0) {
676 g_warning("sock_read: received EOF");
677 session->state = SESSION_EOF;
678 return FALSE;
679 }
680
681 if (read_len < 0) {
682 switch (errno) {
683 case EAGAIN:
684 return TRUE;
685 default:
686 g_warning("sock_read: %s", g_strerror(errno));
687 session->state = SESSION_ERROR;
688 return FALSE;
689 }
690 }
691
692 session->read_buf_len = read_len;
693 }
694
695 data_buf = session->read_data_buf;
696 terminator_len = strlen(session->read_data_terminator);
697
698 if (session->read_buf_len == 0)
699 return TRUE;
700
701 g_byte_array_append(data_buf, session->read_buf_p,
702 session->read_buf_len);
703
704 session->read_buf_len = 0;
705 session->read_buf_p = session->read_buf;
706
707 /* check if data is terminated */
708 if (data_buf->len >= terminator_len) {
709 if (memcmp(data_buf->data, session->read_data_terminator,
710 terminator_len) == 0)
711 complete = TRUE;
712 else if (data_buf->len >= terminator_len + 2 &&
713 memcmp(data_buf->data + data_buf->len -
714 (terminator_len + 2), "\r\n", 2) == 0 &&
715 memcmp(data_buf->data + data_buf->len -
716 terminator_len, session->read_data_terminator,
717 terminator_len) == 0)
718 complete = TRUE;
719 }
720
721 /* incomplete read */
722 if (!complete) {
723 GDateTime *tv_cur = g_date_time_new_now_local();
724
725 GTimeSpan ts = g_date_time_difference(tv_cur, session->tv_prev);
726 if (1000 - ts < 0 || ts > UI_REFRESH_INTERVAL) {
727 session->recv_data_progressive_notify
728 (session, data_buf->len, 0,
729 session->recv_data_progressive_notify_data);
730 g_date_time_unref(session->tv_prev);
731 session->tv_prev = g_date_time_new_now_local();
732 }
733 g_date_time_unref(tv_cur);
734 return TRUE;
735 }
736
737 /* complete */
738 if (session->io_tag > 0) {
739 g_source_remove(session->io_tag);
740 session->io_tag = 0;
741 }
742
743 data_len = data_buf->len - terminator_len;
744
745 /* callback */
746 ret = session->recv_data_finished(session, (gchar *)data_buf->data,
747 data_len);
748
749 g_byte_array_set_size(data_buf, 0);
750
751 session->recv_data_notify(session, data_len,
752 session->recv_data_notify_data);
753
754 if (ret < 0)
755 session->state = SESSION_ERROR;
756
757 return FALSE;
758 }
759
session_write_buf(Session * session)760 static gint session_write_buf(Session *session)
761 {
762 gint write_len;
763 gint to_write_len;
764
765 cm_return_val_if_fail(session->write_buf != NULL, -1);
766 cm_return_val_if_fail(session->write_buf_p != NULL, -1);
767 cm_return_val_if_fail(session->write_buf_len > 0, -1);
768
769 to_write_len = session->write_buf_len -
770 (session->write_buf_p - session->write_buf);
771 to_write_len = MIN(to_write_len, SESSION_BUFFSIZE);
772
773 write_len = sock_write(session->sock, session->write_buf_p,
774 to_write_len);
775
776 if (write_len < 0) {
777 switch (errno) {
778 case EAGAIN:
779 write_len = 0;
780 break;
781 default:
782 g_warning("sock_write: %s", g_strerror(errno));
783 session->state = SESSION_ERROR;
784 return -1;
785 }
786 }
787
788 /* incomplete write */
789 if (session->write_buf_p - session->write_buf + write_len <
790 session->write_buf_len) {
791 session->write_buf_p += write_len;
792 return 1;
793 }
794
795 g_free(session->write_buf);
796 session->write_buf = NULL;
797 session->write_buf_p = NULL;
798 session->write_buf_len = 0;
799
800 return 0;
801 }
802
session_write_data(Session * session)803 static gint session_write_data(Session *session)
804 {
805 gint write_len;
806 gint to_write_len;
807
808 cm_return_val_if_fail(session->write_data != NULL, -1);
809 cm_return_val_if_fail(session->write_data_p != NULL, -1);
810 cm_return_val_if_fail(session->write_data_len > 0, -1);
811
812 to_write_len = session->write_data_len -
813 (session->write_data_p - session->write_data);
814 to_write_len = MIN(to_write_len, SESSION_BUFFSIZE);
815
816 write_len = sock_write(session->sock, session->write_data_p,
817 to_write_len);
818
819 if (write_len < 0) {
820 switch (errno) {
821 case EAGAIN:
822 write_len = 0;
823 break;
824 default:
825 g_warning("sock_write: %s", g_strerror(errno));
826 session->state = SESSION_ERROR;
827 return -1;
828 }
829 }
830
831 /* incomplete write */
832 if (session->write_data_p - session->write_data + write_len <
833 session->write_data_len) {
834 session->write_data_p += write_len;
835 return 1;
836 }
837
838 session->write_data = NULL;
839 session->write_data_p = NULL;
840 session->write_data_len = 0;
841
842 return 0;
843 }
844
session_write_msg_cb(SockInfo * source,GIOCondition condition,gpointer data)845 static gboolean session_write_msg_cb(SockInfo *source, GIOCondition condition,
846 gpointer data)
847 {
848 Session *session = SESSION(data);
849 gint ret;
850
851 cm_return_val_if_fail(condition == G_IO_OUT, FALSE);
852 cm_return_val_if_fail(session->write_buf != NULL, FALSE);
853 cm_return_val_if_fail(session->write_buf_p != NULL, FALSE);
854 cm_return_val_if_fail(session->write_buf_len > 0, FALSE);
855
856 ret = session_write_buf(session);
857
858 if (ret < 0) {
859 session->state = SESSION_ERROR;
860 return FALSE;
861 } else if (ret > 0)
862 return TRUE;
863
864 if (session->io_tag > 0) {
865 g_source_remove(session->io_tag);
866 session->io_tag = 0;
867 }
868
869 session_recv_msg(session);
870
871 return FALSE;
872 }
873
session_write_data_cb(SockInfo * source,GIOCondition condition,gpointer data)874 static gboolean session_write_data_cb(SockInfo *source,
875 GIOCondition condition, gpointer data)
876 {
877 Session *session = SESSION(data);
878 guint write_data_len;
879 gint ret;
880
881 cm_return_val_if_fail(condition == G_IO_OUT, FALSE);
882 cm_return_val_if_fail(session->write_data != NULL, FALSE);
883 cm_return_val_if_fail(session->write_data_p != NULL, FALSE);
884 cm_return_val_if_fail(session->write_data_len > 0, FALSE);
885
886 write_data_len = session->write_data_len;
887
888 ret = session_write_data(session);
889
890 if (ret < 0) {
891 session->state = SESSION_ERROR;
892 return FALSE;
893 } else if (ret > 0) {
894 GDateTime *tv_cur = g_date_time_new_now_local();
895
896 GTimeSpan ts = g_date_time_difference(tv_cur, session->tv_prev);
897 if (1000 - ts < 0 || ts > UI_REFRESH_INTERVAL) {
898 session_set_timeout(session, session->timeout_interval);
899 session->send_data_progressive_notify
900 (session,
901 session->write_data_p - session->write_data,
902 write_data_len,
903 session->send_data_progressive_notify_data);
904 g_date_time_unref(session->tv_prev);
905 session->tv_prev = g_date_time_new_now_local();
906 }
907 g_date_time_unref(tv_cur);
908 return TRUE;
909 }
910
911 if (session->io_tag > 0) {
912 g_source_remove(session->io_tag);
913 session->io_tag = 0;
914 }
915
916 /* callback */
917 ret = session->send_data_finished(session, write_data_len);
918 session->send_data_notify(session, write_data_len,
919 session->send_data_notify_data);
920
921 return FALSE;
922 }
923
session_register_ping(Session * session,gboolean (* ping_cb)(gpointer data))924 void session_register_ping(Session *session, gboolean (*ping_cb)(gpointer data))
925 {
926 if (!session)
927 return;
928 if (session->ping_tag > -1)
929 g_source_remove(session->ping_tag);
930
931 session->ping_tag = -1;
932
933 if (ping_cb != NULL)
934 session->ping_tag = g_timeout_add_seconds(60, ping_cb, session);
935 }
936