lib/gnutls_session.c

   1 /*
   2  * Copyright (C) 2000-2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GnuTLS.
   7  *
   8  * The GnuTLS is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22 #include "gnutls_int.h"
  23 #include "gnutls_errors.h"
  24 #include "debug.h"
  25 #include <gnutls_session_pack.h>
  26 #include <gnutls_datum.h>
  27
  28 /**
  29  * gnutls_session_get_data:
  30  * @session: is a #gnutls_session_t structure.
  31  * @session_data: is a pointer to space to hold the session.
  32  * @session_data_size: is the session_data's size, or it will be set by the function.
  33  *
  34  * Returns all session parameters needed to be stored to support resumption.
  35  * The client should call this, and store the returned session data. A session
  36  * may be resumed later by calling gnutls_session_set_data().
  37  * This function must be called after a successful handshake.
  38  *
  39  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
  40  *   an error code is returned.
  41  **/
  42 int
  43 gnutls_session_get_data (gnutls_session_t session,
  44                          void *session_data, size_t * session_data_size)
  45 {
  46
  47   gnutls_datum_t psession;
  48   int ret;
  49
  50   if (session->internals.resumable == RESUME_FALSE)
  51     return GNUTLS_E_INVALID_SESSION;
  52
  53   psession.data = session_data;
  54
  55   ret = _gnutls_session_pack (session, &psession);
  56   if (ret < 0)
  57     {
  58       gnutls_assert ();
  59       return ret;
  60     }
  61
  62   if (psession.size > *session_data_size)
  63     {
  64       *session_data_size = psession.size;
  65       ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
  66       goto error;
  67     }
  68   *session_data_size = psession.size;
  69
  70   if (session_data != NULL)
  71     memcpy (session_data, psession.data, psession.size);
  72
  73   ret = 0;
  74
  75 error:
  76   _gnutls_free_datum (&psession);
  77   return ret;
  78 }
  79
  80 /**
  81  * gnutls_session_get_data2:
  82  * @session: is a #gnutls_session_t structure.
  83  * @data: is a pointer to a datum that will hold the session.
  84  *
  85  * Returns all session parameters needed to be stored to support resumption.
  86  * The client should call this, and store the returned session data. A session
  87  * may be resumed later by calling gnutls_session_set_data().
  88  * This function must be called after a successful handshake.
  89  * The returned @data are allocated and must be released using gnutls_free().
  90  *
  91  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
  92  *   an error code is returned.
  93  **/
  94 int
  95 gnutls_session_get_data2 (gnutls_session_t session, gnutls_datum_t * data)
  96 {
  97
  98   int ret;
  99
 100   if (data == NULL)
 101     {
 102       return GNUTLS_E_INVALID_REQUEST;
 103     }
 104
 105   if (session->internals.resumable == RESUME_FALSE)
 106     return GNUTLS_E_INVALID_SESSION;
 107
 108   ret = _gnutls_session_pack (session, data);
 109   if (ret < 0)
 110     {
 111       gnutls_assert ();
 112       return ret;
 113     }
 114
 115   return 0;
 116 }
 117
 118
 119 /**
 120  * gnutls_session_get_id:
 121  * @session: is a #gnutls_session_t structure.
 122  * @session_id: is a pointer to space to hold the session id.
 123  * @session_id_size: initially should contain the maximum @session_id size and will be updated.
 124  *
 125  * Returns the current session ID. This can be used if you want to
 126  * check if the next session you tried to resume was actually
 127  * resumed.  That is because resumed sessions share the same session ID
 128  * with the original session.
 129  *
 130  * The session ID is selected by the server, that identify the
 131  * current session.  In TLS 1.0 and SSL 3.0 session id is always less
 132  * than 32 bytes.
 133  *
 134  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 135  *   an error code is returned.
 136  **/
 137 int
 138 gnutls_session_get_id (gnutls_session_t session,
 139                        void *session_id, size_t * session_id_size)
 140 {
 141   size_t given_session_id_size = *session_id_size;
 142
 143   *session_id_size = session->security_parameters.session_id_size;
 144
 145   /* just return the session size */
 146   if (session_id == NULL)
 147     {
 148       return 0;
 149     }
 150
 151   if (given_session_id_size < session->security_parameters.session_id_size)
 152     {
 153       return GNUTLS_E_SHORT_MEMORY_BUFFER;
 154     }
 155
 156   memcpy (session_id, &session->security_parameters.session_id,
 157           *session_id_size);
 158
 159   return 0;
 160 }
 161
 162 /**
 163  * gnutls_session_get_id2:
 164  * @session: is a #gnutls_session_t structure.
 165  * @session_id: will point to the session ID.
 166  *
 167  * Returns the current session ID. The returned data should be
 168  * treated as constant.
 169  *
 170  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 171  *   an error code is returned.
 172  *
 173  * Since: 3.1.4
 174  **/
 175 int
 176 gnutls_session_get_id2 (gnutls_session_t session,
 177                         gnutls_datum_t *session_id)
 178 {
 179   session_id->size = session->security_parameters.session_id_size;
 180   session_id->data = session->security_parameters.session_id;
 181
 182   return 0;
 183 }
 184
 185 /**
 186  * gnutls_session_set_data:
 187  * @session: is a #gnutls_session_t structure.
 188  * @session_data: is a pointer to space to hold the session.
 189  * @session_data_size: is the session's size
 190  *
 191  * Sets all session parameters, in order to resume a previously
 192  * established session.  The session data given must be the one
 193  * returned by gnutls_session_get_data().  This function should be
 194  * called before gnutls_handshake().
 195  *
 196  * Keep in mind that session resuming is advisory. The server may
 197  * choose not to resume the session, thus a full handshake will be
 198  * performed.
 199  *
 200  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 201  *   an error code is returned.
 202  **/
 203 int
 204 gnutls_session_set_data (gnutls_session_t session,
 205                          const void *session_data, size_t session_data_size)
 206 {
 207   int ret;
 208   gnutls_datum_t psession;
 209
 210   psession.data = (uint8_t *) session_data;
 211   psession.size = session_data_size;
 212
 213   if (session_data == NULL || session_data_size == 0)
 214     {
 215       gnutls_assert ();
 216       return GNUTLS_E_INVALID_REQUEST;
 217     }
 218   ret = _gnutls_session_unpack (session, &psession);
 219   if (ret < 0)
 220     {
 221       gnutls_assert ();
 222       return ret;
 223     }
 224
 225   return 0;
 226 }