camel/camel-tcp-stream-raw.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  *  Authors: Jeffrey Stedfast <fejj@ximian.com>
   4  *
   5  *  Copyright 2001-2003 Ximian, Inc. (www.ximian.com)
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of version 2 of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <sys/time.h>
  33 #include <sys/types.h>
  34
  35 #include "camel-file-utils.h"
  36 #include "camel-operation.h"
  37 #include "camel-tcp-stream-raw.h"
  38
  39 #ifndef G_OS_WIN32
  40 #define SOCKET_ERROR_CODE() errno
  41 #define SOCKET_CLOSE(fd) close (fd)
  42 #define SOCKET_ERROR_IS_EINPROGRESS() (errno == EINPROGRESS)
  43 #define SOCKET_ERROR_IS_EINTR() (errno == EINTR)
  44 #else
  45 #define SOCKET_ERROR_CODE() WSAGetLastError ()
  46 #define SOCKET_CLOSE(fd) closesocket (fd)
  47 #define SOCKET_ERROR_IS_EINPROGRESS() (WSAGetLastError () == WSAEWOULDBLOCK)
  48 #define SOCKET_ERROR_IS_EINTR() 0 /* No WSAEINTR in WinSock2 */
  49 #endif
  50
  51 static CamelTcpStreamClass *parent_class = NULL;
  52
  53 /* Returns the class for a CamelTcpStreamRaw */
  54 #define CTSR_CLASS(so) CAMEL_TCP_STREAM_RAW_CLASS (CAMEL_OBJECT_GET_CLASS (so))
  55
  56 static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
  57 static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n);
  58 static int stream_flush  (CamelStream *stream);
  59 static int stream_close  (CamelStream *stream);
  60
  61 static int stream_connect (CamelTcpStream *stream, struct addrinfo *host);
  62 static int stream_getsockopt (CamelTcpStream *stream, CamelSockOptData *data);
  63 static int stream_setsockopt (CamelTcpStream *stream, const CamelSockOptData *data);
  64 static struct sockaddr *stream_get_local_address (CamelTcpStream *stream, socklen_t *len);
  65 static struct sockaddr *stream_get_remote_address (CamelTcpStream *stream, socklen_t *len);
  66
  67 static void
  68 camel_tcp_stream_raw_class_init (CamelTcpStreamRawClass *camel_tcp_stream_raw_class)
  69 {
  70         CamelTcpStreamClass *camel_tcp_stream_class =
  71                 CAMEL_TCP_STREAM_CLASS (camel_tcp_stream_raw_class);
  72         CamelStreamClass *camel_stream_class =
  73                 CAMEL_STREAM_CLASS (camel_tcp_stream_raw_class);
  74
  75         parent_class = CAMEL_TCP_STREAM_CLASS (camel_type_get_global_classfuncs (camel_tcp_stream_get_type ()));
  76
  77         /* virtual method overload */
  78         camel_stream_class->read = stream_read;
  79         camel_stream_class->write = stream_write;
  80         camel_stream_class->flush = stream_flush;
  81         camel_stream_class->close = stream_close;
  82
  83         camel_tcp_stream_class->connect = stream_connect;
  84         camel_tcp_stream_class->getsockopt = stream_getsockopt;
  85         camel_tcp_stream_class->setsockopt  = stream_setsockopt;
  86         camel_tcp_stream_class->get_local_address  = stream_get_local_address;
  87         camel_tcp_stream_class->get_remote_address = stream_get_remote_address;
  88 }
  89
  90 static void
  91 camel_tcp_stream_raw_init (gpointer object, gpointer klass)
  92 {
  93         CamelTcpStreamRaw *stream = CAMEL_TCP_STREAM_RAW (object);
  94
  95         stream->sockfd = -1;
  96 }
  97
  98 static void
  99 camel_tcp_stream_raw_finalize (CamelObject *object)
 100 {
 101         CamelTcpStreamRaw *stream = CAMEL_TCP_STREAM_RAW (object);
 102
 103         if (stream->sockfd != -1)
 104                 SOCKET_CLOSE (stream->sockfd);
 105 }
 106
 107
 108 CamelType
 109 camel_tcp_stream_raw_get_type (void)
 110 {
 111         static CamelType type = CAMEL_INVALID_TYPE;
 112
 113         if (type == CAMEL_INVALID_TYPE) {
 114                 type = camel_type_register (camel_tcp_stream_get_type (),
 115                                             "CamelTcpStreamRaw",
 116                                             sizeof (CamelTcpStreamRaw),
 117                                             sizeof (CamelTcpStreamRawClass),
 118                                             (CamelObjectClassInitFunc) camel_tcp_stream_raw_class_init,
 119                                             NULL,
 120                                             (CamelObjectInitFunc) camel_tcp_stream_raw_init,
 121                                             (CamelObjectFinalizeFunc) camel_tcp_stream_raw_finalize);
 122         }
 123
 124         return type;
 125 }
 126
 127 #ifdef SIMULATE_FLAKY_NETWORK
 128 static ssize_t
 129 flaky_tcp_write (int fd, const char *buffer, size_t buflen)
 130 {
 131         size_t len = buflen;
 132         ssize_t nwritten;
 133         int val;
 134
 135         if (buflen == 0)
 136                 return 0;
 137
 138         val = 1 + (int) (10.0 * rand () / (RAND_MAX + 1.0));
 139
 140         switch (val) {
 141         case 1:
 142                 printf ("flaky_tcp_write (%d, ..., %d): (-1) EINTR\n", fd, buflen);
 143                 errno = EINTR;
 144                 return -1;
 145         case 2:
 146                 printf ("flaky_tcp_write (%d, ..., %d): (-1) EAGAIN\n", fd, buflen);
 147                 errno = EAGAIN;
 148                 return -1;
 149         case 3:
 150                 printf ("flaky_tcp_write (%d, ..., %d): (-1) EWOULDBLOCK\n", fd, buflen);
 151                 errno = EWOULDBLOCK;
 152                 return -1;
 153         case 4:
 154         case 5:
 155         case 6:
 156                 len = 1 + (size_t) (buflen * rand () / (RAND_MAX + 1.0));
 157                 len = MIN (len, buflen);
 158                 /* fall through... */
 159         default:
 160                 printf ("flaky_tcp_write (%d, ..., %d): (%d) '%.*s'", fd, buflen, len, (int) len, buffer);
 161                 nwritten = write (fd, buffer, len);
 162                 if (nwritten < 0)
 163                         printf (" errno => %s\n", strerror (errno));
 164                 else if (nwritten < len)
 165                         printf (" only wrote %d bytes\n", nwritten);
 166                 else
 167                         printf ("\n");
 168
 169                 return nwritten;
 170         }
 171 }
 172
 173 #define write(fd, buffer, buflen) flaky_tcp_write (fd, buffer, buflen)
 174
 175 static ssize_t
 176 flaky_tcp_read (int fd, char *buffer, size_t buflen)
 177 {
 178         size_t len = buflen;
 179         ssize_t nread;
 180         int val;
 181
 182         if (buflen == 0)
 183                 return 0;
 184
 185         val = 1 + (int) (10.0 * rand () / (RAND_MAX + 1.0));
 186
 187         switch (val) {
 188         case 1:
 189                 printf ("flaky_tcp_read (%d, ..., %d): (-1) EINTR\n", fd, buflen);
 190                 errno = EINTR;
 191                 return -1;
 192         case 2:
 193                 printf ("flaky_tcp_read (%d, ..., %d): (-1) EAGAIN\n", fd, buflen);
 194                 errno = EAGAIN;
 195                 return -1;
 196         case 3:
 197                 printf ("flaky_tcp_read (%d, ..., %d): (-1) EWOULDBLOCK\n", fd, buflen);
 198                 errno = EWOULDBLOCK;
 199                 return -1;
 200         case 4:
 201         case 5:
 202         case 6:
 203         case 7:
 204         case 8:
 205         case 9:
 206         case 10:
 207                 len = 1 + (size_t) (10.0 * rand () / (RAND_MAX + 1.0));
 208                 len = MIN (len, buflen);
 209                 /* fall through... */
 210         default:
 211                 printf ("flaky_tcp_read (%d, ..., %d): (%d)", fd, buflen, len);
 212                 nread = read (fd, buffer, len);
 213                 if (nread < 0)
 214                         printf (" errno => %s\n", strerror (errno));
 215                 else if (nread < len)
 216                         printf (" only read %d bytes\n", nread);
 217                 else
 218                         printf ("\n");
 219
 220                 return nread;
 221         }
 222 }
 223
 224 #define read(fd, buffer, buflen) flaky_tcp_read (fd, buffer, buflen)
 225
 226 #endif /* SIMULATE_FLAKY_NETWORK */
 227
 228
 229
 230 /**
 231  * camel_tcp_stream_raw_new:
 232  *
 233  * Create a new #CamelTcpStreamRaw object.
 234  *
 235  * Returns a new #CamelTcpStream object
 236  **/
 237 CamelStream *
 238 camel_tcp_stream_raw_new ()
 239 {
 240         CamelTcpStreamRaw *stream;
 241
 242         stream = CAMEL_TCP_STREAM_RAW (camel_object_new (camel_tcp_stream_raw_get_type ()));
 243
 244         return CAMEL_STREAM (stream);
 245 }
 246
 247 static ssize_t
 248 stream_read (CamelStream *stream, char *buffer, size_t n)
 249 {
 250         CamelTcpStreamRaw *raw = CAMEL_TCP_STREAM_RAW (stream);
 251
 252         return camel_read_socket (raw->sockfd, buffer, n);
 253 }
 254
 255 static ssize_t
 256 stream_write (CamelStream *stream, const char *buffer, size_t n)
 257 {
 258         CamelTcpStreamRaw *raw = CAMEL_TCP_STREAM_RAW (stream);
 259
 260         return camel_write_socket (raw->sockfd, buffer, n);
 261 }
 262
 263 static int
 264 stream_flush (CamelStream *stream)
 265 {
 266         return 0;
 267 }
 268
 269 static int
 270 stream_close (CamelStream *stream)
 271 {
 272         if (SOCKET_CLOSE (((CamelTcpStreamRaw *)stream)->sockfd) == -1)
 273                 return -1;
 274
 275         ((CamelTcpStreamRaw *)stream)->sockfd = -1;
 276         return 0;
 277 }
 278
 279 /* this is a 'cancellable' connect, cancellable from camel_operation_cancel etc */
 280 /* returns -1 & errno == EINTR if the connection was cancelled */
 281 static int
 282 socket_connect(struct addrinfo *h)
 283 {
 284         struct timeval tv;
 285         socklen_t len;
 286         int cancel_fd;
 287         int errnosav;
 288         int ret, fd;
 289
 290         /* see if we're cancelled yet */
 291         if (camel_operation_cancel_check (NULL)) {
 292                 errno = EINTR;
 293                 return -1;
 294         }
 295
 296         if (h->ai_socktype != SOCK_STREAM) {
 297                 errno = EINVAL;
 298                 return -1;
 299         }
 300
 301         if ((fd = socket (h->ai_family, SOCK_STREAM, 0)) == -1)
 302                 return -1;
 303
 304         cancel_fd = camel_operation_cancel_fd (NULL);
 305         if (cancel_fd == -1) {
 306                 if (connect (fd, h->ai_addr, h->ai_addrlen) == -1) {
 307                         /* Yeah, errno is meaningless on Win32 after a
 308                          * Winsock call fails, but I doubt the callers
 309                          * check errno anyway.
 310                          */
 311                         errnosav = errno;
 312                         SOCKET_CLOSE (fd);
 313                         errno = errnosav;
 314                         return -1;
 315                 }
 316
 317                 return fd;
 318         } else {
 319 #ifndef G_OS_WIN32
 320                 int flags;
 321 #endif
 322                 int fdmax, status;
 323                 fd_set rdset, wrset;
 324
 325 #ifndef G_OS_WIN32
 326                 flags = fcntl (fd, F_GETFL);
 327                 fcntl (fd, F_SETFL, flags | O_NONBLOCK);
 328 #else
 329                 {
 330                         u_long yes = 1;
 331                         ioctlsocket (fd, FIONBIO, &yes);
 332                 }
 333 #endif
 334                 if (connect (fd, h->ai_addr, h->ai_addrlen) == 0) {
 335 #ifndef G_OS_WIN32
 336                         fcntl (fd, F_SETFL, flags);
 337 #else
 338                         {
 339                                 u_long no = 0;
 340                                 ioctlsocket (fd, FIONBIO, &no);
 341                         }
 342 #endif
 343                         return fd;
 344                 }
 345
 346                 if (!SOCKET_ERROR_IS_EINPROGRESS ()) {
 347                         errnosav = errno;
 348                         SOCKET_CLOSE (fd);
 349                         errno = errnosav;
 350                         return -1;
 351                 }
 352
 353                 do {
 354                         FD_ZERO (&rdset);
 355                         FD_ZERO (&wrset);
 356                         FD_SET (fd, &wrset);
 357                         FD_SET (cancel_fd, &rdset);
 358                         fdmax = MAX (fd, cancel_fd) + 1;
 359                         tv.tv_sec = 60 * 4;
 360                         tv.tv_usec = 0;
 361
 362                         status = select (fdmax, &rdset, &wrset, 0, &tv);
 363                 } while (status == -1 && SOCKET_ERROR_IS_EINTR ());
 364
 365                 if (status <= 0) {
 366                         SOCKET_CLOSE (fd);
 367                         errno = ETIMEDOUT;
 368                         return -1;
 369                 }
 370
 371                 if (cancel_fd != -1 && FD_ISSET (cancel_fd, &rdset)) {
 372                         SOCKET_CLOSE (fd);
 373                         errno = EINTR;
 374                         return -1;
 375                 } else {
 376                         len = sizeof (int);
 377
 378                         if (getsockopt (fd, SOL_SOCKET, SO_ERROR, (char *) &ret, &len) == -1) {
 379                                 errnosav = errno;
 380                                 SOCKET_CLOSE (fd);
 381                                 errno = errnosav;
 382                                 return -1;
 383                         }
 384
 385                         if (ret != 0) {
 386                                 SOCKET_CLOSE (fd);
 387                                 errno = ret;
 388                                 return -1;
 389                         }
 390                 }
 391 #ifndef G_OS_WIN32
 392                 fcntl (fd, F_SETFL, flags);
 393 #else
 394                 {
 395                         u_long no = 0;
 396                         ioctlsocket (fd, FIONBIO, &no);
 397                 }
 398 #endif
 399         }
 400
 401         return fd;
 402 }
 403
 404 static int
 405 stream_connect (CamelTcpStream *stream, struct addrinfo *host)
 406 {
 407         CamelTcpStreamRaw *raw = CAMEL_TCP_STREAM_RAW (stream);
 408
 409         g_return_val_if_fail (host != NULL, -1);
 410
 411         while (host) {
 412                 raw->sockfd = socket_connect(host);
 413                 if (raw->sockfd != -1)
 414                         return 0;
 415
 416                 host = host->ai_next;
 417         }
 418
 419         return -1;
 420 }
 421
 422 static int
 423 get_sockopt_level (const CamelSockOptData *data)
 424 {
 425         switch (data->option) {
 426         case CAMEL_SOCKOPT_MAXSEGMENT:
 427         case CAMEL_SOCKOPT_NODELAY:
 428                 return IPPROTO_TCP;
 429         default:
 430                 return SOL_SOCKET;
 431         }
 432 }
 433
 434 static int
 435 get_sockopt_optname (const CamelSockOptData *data)
 436 {
 437         switch (data->option) {
 438 #ifdef TCP_MAXSEG
 439         case CAMEL_SOCKOPT_MAXSEGMENT:
 440                 return TCP_MAXSEG;
 441 #endif
 442         case CAMEL_SOCKOPT_NODELAY:
 443                 return TCP_NODELAY;
 444         case CAMEL_SOCKOPT_BROADCAST:
 445                 return SO_BROADCAST;
 446         case CAMEL_SOCKOPT_KEEPALIVE:
 447                 return SO_KEEPALIVE;
 448         case CAMEL_SOCKOPT_LINGER:
 449                 return SO_LINGER;
 450         case CAMEL_SOCKOPT_RECVBUFFERSIZE:
 451                 return SO_RCVBUF;
 452         case CAMEL_SOCKOPT_SENDBUFFERSIZE:
 453                 return SO_SNDBUF;
 454         case CAMEL_SOCKOPT_REUSEADDR:
 455                 return SO_REUSEADDR;
 456         case CAMEL_SOCKOPT_IPTYPEOFSERVICE:
 457                 return SO_TYPE;
 458         default:
 459                 return -1;
 460         }
 461 }
 462
 463 static int
 464 stream_getsockopt (CamelTcpStream *stream, CamelSockOptData *data)
 465 {
 466         int optname, optlen;
 467
 468         if ((optname = get_sockopt_optname (data)) == -1)
 469                 return -1;
 470
 471         if (data->option == CAMEL_SOCKOPT_NONBLOCKING) {
 472 #ifndef G_OS_WIN32
 473                 int flags;
 474
 475                 flags = fcntl (((CamelTcpStreamRaw *)stream)->sockfd, F_GETFL);
 476                 if (flags == -1)
 477                         return -1;
 478
 479                 data->value.non_blocking = flags & O_NONBLOCK ? TRUE : FALSE;
 480 #else
 481                 data->value.non_blocking = ((CamelTcpStreamRaw *)stream)->is_nonblocking;
 482 #endif
 483                 return 0;
 484         }
 485
 486         return getsockopt (((CamelTcpStreamRaw *)stream)->sockfd,
 487                            get_sockopt_level (data),
 488                            optname,
 489                            (void *) &data->value,
 490                            &optlen);
 491 }
 492
 493 static int
 494 stream_setsockopt (CamelTcpStream *stream, const CamelSockOptData *data)
 495 {
 496         int optname;
 497
 498         if ((optname = get_sockopt_optname (data)) == -1)
 499                 return -1;
 500
 501         if (data->option == CAMEL_SOCKOPT_NONBLOCKING) {
 502 #ifndef G_OS_WIN32
 503                 int flags, set;
 504
 505                 flags = fcntl (((CamelTcpStreamRaw *)stream)->sockfd, F_GETFL);
 506                 if (flags == -1)
 507                         return -1;
 508
 509                 set = data->value.non_blocking ? O_NONBLOCK : 0;
 510                 flags = (flags & ~O_NONBLOCK) | set;
 511
 512                 if (fcntl (((CamelTcpStreamRaw *)stream)->sockfd, F_SETFL, flags) == -1)
 513                         return -1;
 514 #else
 515                 u_long fionbio = data->value.non_blocking ? 1 : 0;
 516                 if (ioctlsocket (((CamelTcpStreamRaw *)stream)->sockfd, FIONBIO, &fionbio) == SOCKET_ERROR)
 517                         return -1;
 518                 ((CamelTcpStreamRaw *)stream)->is_nonblocking = data->value.non_blocking ? 1 : 0;
 519 #endif
 520                 return 0;
 521         }
 522
 523         return setsockopt (((CamelTcpStreamRaw *)stream)->sockfd,
 524                            get_sockopt_level (data),
 525                            optname,
 526                            (void *) &data->value,
 527                            sizeof (data->value));
 528 }
 529
 530 static struct sockaddr *
 531 stream_get_local_address (CamelTcpStream *stream, socklen_t *len)
 532 {
 533 #ifdef ENABLE_IPv6
 534         struct sockaddr_in6 sin;
 535 #else
 536         struct sockaddr_in sin;
 537 #endif
 538         struct sockaddr *saddr = (struct sockaddr *)&sin;
 539
 540         *len = sizeof(sin);
 541         if (getsockname (CAMEL_TCP_STREAM_RAW (stream)->sockfd, saddr, len) == -1)
 542                 return NULL;
 543
 544         saddr = g_malloc(*len);
 545         memcpy(saddr, &sin, *len);
 546
 547         return saddr;
 548 }
 549
 550 static struct sockaddr *
 551 stream_get_remote_address (CamelTcpStream *stream, socklen_t *len)
 552 {
 553 #ifdef ENABLE_IPv6
 554         struct sockaddr_in6 sin;
 555 #else
 556         struct sockaddr_in sin;
 557 #endif
 558         struct sockaddr *saddr = (struct sockaddr *)&sin;
 559
 560         *len = sizeof(sin);
 561         if (getpeername (CAMEL_TCP_STREAM_RAW (stream)->sockfd, saddr, len) == -1)
 562                 return NULL;
 563
 564         saddr = g_malloc(*len);
 565         memcpy(saddr, &sin, *len);
 566
 567         return saddr;
 568 }