src/socket.c

   1 /*
   2  * Copyright (C) 2000-2012 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuTLS.
   5  *
   6  * GnuTLS is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuTLS 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
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21
  22 #if HAVE_SYS_SOCKET_H
  23 # include <sys/socket.h>
  24 #elif HAVE_WS2TCPIP_H
  25 # include <ws2tcpip.h>
  26 #endif
  27 #include <netdb.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <sys/select.h>
  31 #include <sys/types.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #ifndef _WIN32
  36 # include <signal.h>
  37 #endif
  38 #include <socket.h>
  39 #include "sockets.h"
  40
  41 #define MAX_BUF 4096
  42
  43 extern unsigned int verbose;
  44 /* Functions to manipulate sockets
  45  */
  46
  47 ssize_t
  48 socket_recv (const socket_st * socket, void *buffer, int buffer_size)
  49 {
  50   int ret;
  51
  52   if (socket->secure)
  53     {
  54       do
  55         {
  56           ret = gnutls_record_recv (socket->session, buffer, buffer_size);
  57           if (ret == GNUTLS_E_HEARTBEAT_PING_RECEIVED)
  58             gnutls_heartbeat_pong(socket->session, 0);
  59         }
  60       while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_HEARTBEAT_PING_RECEIVED);
  61
  62     }
  63   else
  64     do
  65       {
  66         ret = recv (socket->fd, buffer, buffer_size, 0);
  67       }
  68     while (ret == -1 && errno == EINTR);
  69
  70   return ret;
  71 }
  72
  73 ssize_t
  74 socket_send (const socket_st * socket, const void *buffer, int buffer_size)
  75 {
  76   int ret;
  77
  78   if (socket->secure)
  79     do
  80       {
  81         ret = gnutls_record_send (socket->session, buffer, buffer_size);
  82       }
  83     while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
  84   else
  85     do
  86       {
  87         ret = send (socket->fd, buffer, buffer_size, 0);
  88       }
  89     while (ret == -1 && errno == EINTR);
  90
  91   if (ret > 0 && ret != buffer_size && verbose)
  92     fprintf (stderr,
  93              "*** Only sent %d bytes instead of %d.\n", ret, buffer_size);
  94
  95   return ret;
  96 }
  97
  98 void
  99 socket_bye (socket_st * socket)
 100 {
 101   int ret;
 102   if (socket->secure)
 103     {
 104       do
 105         ret = gnutls_bye (socket->session, GNUTLS_SHUT_WR);
 106       while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN);
 107       if (ret < 0)
 108         fprintf (stderr, "*** gnutls_bye() error: %s\n",
 109                  gnutls_strerror (ret));
 110       gnutls_deinit (socket->session);
 111       socket->session = NULL;
 112     }
 113
 114   freeaddrinfo (socket->addr_info);
 115   socket->addr_info = socket->ptr = NULL;
 116
 117   free (socket->ip);
 118   free (socket->hostname);
 119   free (socket->service);
 120
 121   shutdown (socket->fd, SHUT_RDWR);     /* no more receptions */
 122   close (socket->fd);
 123
 124   socket->fd = -1;
 125   socket->secure = 0;
 126 }
 127
 128 void
 129 socket_connect (const socket_st * hd)
 130 {
 131   int err;
 132
 133   printf ("Connecting to '%s:%s'...\n", hd->ip, hd->service);
 134
 135   err = connect (hd->fd, hd->ptr->ai_addr, hd->ptr->ai_addrlen);
 136   if (err < 0)
 137     {
 138       fprintf (stderr, "Cannot connect to %s:%s: %s\n", hd->hostname,
 139                hd->service, strerror (errno));
 140       exit (1);
 141     }
 142 }
 143
 144 void
 145 socket_open (socket_st * hd, const char *hostname, const char *service, int udp)
 146 {
 147   struct addrinfo hints, *res, *ptr;
 148   int sd, err;
 149   char buffer[MAX_BUF + 1];
 150   char portname[16] = { 0 };
 151
 152   printf ("Resolving '%s'...\n", hostname);
 153   /* get server name */
 154   memset (&hints, 0, sizeof (hints));
 155   hints.ai_socktype = udp ? SOCK_DGRAM : SOCK_STREAM;
 156   if ((err = getaddrinfo (hostname, service, &hints, &res)))
 157     {
 158       fprintf (stderr, "Cannot resolve %s:%s: %s\n", hostname, service,
 159                gai_strerror (err));
 160       exit (1);
 161     }
 162
 163   sd = -1;
 164   for (ptr = res; ptr != NULL; ptr = ptr->ai_next)
 165     {
 166       sd = socket (ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
 167       if (sd == -1)
 168         continue;
 169
 170       if ((err = getnameinfo (ptr->ai_addr, ptr->ai_addrlen, buffer, MAX_BUF,
 171                               portname, sizeof (portname),
 172                               NI_NUMERICHOST | NI_NUMERICSERV)) != 0)
 173         {
 174           fprintf (stderr, "getnameinfo(): %s\n", gai_strerror (err));
 175           freeaddrinfo (res);
 176           exit (1);
 177         }
 178
 179       break;
 180     }
 181
 182   if (sd == -1)
 183     {
 184       fprintf (stderr, "socket(): %s\n", strerror (errno));
 185       exit (1);
 186     }
 187
 188   if (hints.ai_socktype == SOCK_DGRAM)
 189     {
 190 #if defined(IP_DONTFRAG)
 191       int yes = 1;
 192       if (setsockopt (sd, IPPROTO_IP, IP_DONTFRAG,
 193                       (const void *) &yes, sizeof (yes)) < 0)
 194         perror ("setsockopt(IP_DF) failed");
 195 #elif defined(IP_MTU_DISCOVER)
 196       int yes = IP_PMTUDISC_DO;
 197       if (setsockopt(sd, IPPROTO_IP, IP_MTU_DISCOVER,
 198                      (const void*) &yes, sizeof (yes)) < 0)
 199         perror ("setsockopt(IP_DF) failed");
 200 #endif
 201     }
 202
 203   hd->secure = 0;
 204   hd->fd = sd;
 205   hd->hostname = strdup (hostname);
 206   hd->ip = strdup (buffer);
 207   hd->service = strdup (portname);
 208   hd->ptr = ptr;
 209   hd->addr_info = res;
 210
 211   return;
 212 }
 213
 214 void
 215 sockets_init (void)
 216 {
 217 #ifdef _WIN32
 218     WORD wVersionRequested;
 219     WSADATA wsaData;
 220
 221     wVersionRequested = MAKEWORD (1, 1);
 222     if (WSAStartup (wVersionRequested, &wsaData) != 0)
 223       {
 224           perror ("WSA_STARTUP_ERROR");
 225       }
 226 #else
 227   signal (SIGPIPE, SIG_IGN);
 228 #endif
 229
 230 }