1 /* 2 * Gather (Read) entire SSL3 records from socket into buffer. 3 * 4 * ***** BEGIN LICENSE BLOCK ***** 5 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 8 * 1.1 (the "License"); you may not use this file except in compliance with 9 * the License. You may obtain a copy of the License at 10 * http://www.mozilla.org/MPL/ 11 * 12 * Software distributed under the License is distributed on an "AS IS" basis, 13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 14 * for the specific language governing rights and limitations under the 15 * License. 16 * 17 * The Original Code is the Netscape security libraries. 18 * 19 * The Initial Developer of the Original Code is 20 * Netscape Communications Corporation. 21 * Portions created by the Initial Developer are Copyright (C) 1994-2000 22 * the Initial Developer. All Rights Reserved. 23 * 24 * Contributor(s): 25 * 26 * Alternatively, the contents of this file may be used under the terms of 27 * either the GNU General Public License Version 2 or later (the "GPL"), or 28 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), 29 * in which case the provisions of the GPL or the LGPL are applicable instead 30 * of those above. If you wish to allow use of your version of this file only 31 * under the terms of either the GPL or the LGPL, and not to allow others to 32 * use your version of this file under the terms of the MPL, indicate your 33 * decision by deleting the provisions above and replace them with the notice 34 * and other provisions required by the GPL or the LGPL. If you do not delete 35 * the provisions above, a recipient may use your version of this file under 36 * the terms of any one of the MPL, the GPL or the LGPL. 37 * 38 * ***** END LICENSE BLOCK ***** */ 39 /* $Id: ssl3gthr.c,v 1.9 2008/11/20 07:37:25 nelson%bolyard.com Exp $ */ 40 41 #include "cert.h" 42 #include "ssl.h" 43 #include "sslimpl.h" 44 #include "ssl3prot.h" 45 46 /* 47 * Attempt to read in an entire SSL3 record. 48 * Blocks here for blocking sockets, otherwise returns -1 with 49 * PR_WOULD_BLOCK_ERROR when socket would block. 50 * 51 * returns 1 if received a complete SSL3 record. 52 * returns 0 if recv returns EOF 53 * returns -1 if recv returns <0 54 * (The error value may have already been set to PR_WOULD_BLOCK_ERROR) 55 * 56 * Caller must hold the recv buf lock. 57 * 58 * The Gather state machine has 3 states: GS_INIT, GS_HEADER, GS_DATA. 59 * GS_HEADER: waiting for the 5-byte SSL3 record header to come in. 60 * GS_DATA: waiting for the body of the SSL3 record to come in. 61 * 62 * This loop returns when either (a) an error or EOF occurs, 63 * (b) PR_WOULD_BLOCK_ERROR, 64 * (c) data (entire SSL3 record) has been received. 65 */ 66 static int 67 ssl3_GatherData(sslSocket *ss, sslGather *gs, int flags) 68 { 69 unsigned char *bp; 70 unsigned char *lbp; 71 int nb; 72 int err; 73 int rv = 1; 74 75 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 76 if (gs->state == GS_INIT) { 77 gs->state = GS_HEADER; 78 gs->remainder = 5; 79 gs->offset = 0; 80 gs->writeOffset = 0; 81 gs->readOffset = 0; 82 gs->inbuf.len = 0; 83 } 84 85 lbp = gs->inbuf.buf; 86 for(;;) { 87 SSL_TRC(30, ("%d: SSL3[%d]: gather state %d (need %d more)", 88 SSL_GETPID(), ss->fd, gs->state, gs->remainder)); 89 bp = ((gs->state != GS_HEADER) ? lbp : gs->hdr) + gs->offset; 90 nb = ssl_DefRecv(ss, bp, gs->remainder, flags); 91 92 if (nb > 0) { 93 PRINT_BUF(60, (ss, "raw gather data:", bp, nb)); 94 } else if (nb == 0) { 95 /* EOF */ 96 SSL_TRC(30, ("%d: SSL3[%d]: EOF", SSL_GETPID(), ss->fd)); 97 rv = 0; 98 break; 99 } else /* if (nb < 0) */ { 100 SSL_DBG(("%d: SSL3[%d]: recv error %d", SSL_GETPID(), ss->fd, 101 PR_GetError())); 102 rv = SECFailure; 103 break; 104 } 105 106 PORT_Assert( nb <= gs->remainder ); 107 if (nb > gs->remainder) { 108 /* ssl_DefRecv is misbehaving! this error is fatal to SSL. */ 109 gs->state = GS_INIT; /* so we don't crash next time */ 110 rv = SECFailure; 111 break; 112 } 113 114 gs->offset += nb; 115 gs->remainder -= nb; 116 if (gs->state == GS_DATA) 117 gs->inbuf.len += nb; 118 119 /* if there's more to go, read some more. */ 120 if (gs->remainder > 0) { 121 continue; 122 } 123 124 /* have received entire record header, or entire record. */ 125 switch (gs->state) { 126 case GS_HEADER: 127 /* 128 ** Have received SSL3 record header in gs->hdr. 129 ** Now extract the length of the following encrypted data, 130 ** and then read in the rest of the SSL3 record into gs->inbuf. 131 */ 132 gs->remainder = (gs->hdr[3] << 8) | gs->hdr[4]; 133 134 /* This is the max fragment length for an encrypted fragment 135 ** plus the size of the record header. 136 */ 137 if(gs->remainder > (MAX_FRAGMENT_LENGTH + 2048 + 5)) { 138 SSL3_SendAlert(ss, alert_fatal, unexpected_message); 139 gs->state = GS_INIT; 140 PORT_SetError(SSL_ERROR_RX_RECORD_TOO_LONG); 141 return SECFailure; 142 } 143 144 gs->state = GS_DATA; 145 gs->offset = 0; 146 gs->inbuf.len = 0; 147 148 if (gs->remainder > gs->inbuf.space) { 149 err = sslBuffer_Grow(&gs->inbuf, gs->remainder); 150 if (err) { /* realloc has set error code to no mem. */ 151 return err; 152 } 153 lbp = gs->inbuf.buf; 154 } 155 break; /* End this case. Continue around the loop. */ 156 157 158 case GS_DATA: 159 /* 160 ** SSL3 record has been completely received. 161 */ 162 gs->state = GS_INIT; 163 return 1; 164 } 165 } 166 167 return rv; 168 } 169 170 /* Gather in a record and when complete, Handle that record. 171 * Repeat this until the handshake is complete, 172 * or until application data is available. 173 * 174 * Returns 1 when the handshake is completed without error, or 175 * application data is available. 176 * Returns 0 if ssl3_GatherData hits EOF. 177 * Returns -1 on read error, or PR_WOULD_BLOCK_ERROR, or handleRecord error. 178 * Returns -2 on SECWouldBlock return from ssl3_HandleRecord. 179 * 180 * Called from ssl_GatherRecord1stHandshake in sslcon.c, 181 * and from SSL_ForceHandshake in sslsecur.c 182 * and from ssl3_GatherAppDataRecord below (<- DoRecv in sslsecur.c). 183 * 184 * Caller must hold the recv buf lock. 185 */ 186 int 187 ssl3_GatherCompleteHandshake(sslSocket *ss, int flags) 188 { 189 SSL3Ciphertext cText; 190 int rv; 191 192 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 193 do { 194 /* bring in the next sslv3 record. */ 195 rv = ssl3_GatherData(ss, &ss->gs, flags); 196 if (rv <= 0) { 197 return rv; 198 } 199 200 /* decipher it, and handle it if it's a handshake. 201 * If it's application data, ss->gs.buf will not be empty upon return. 202 */ 203 cText.type = (SSL3ContentType)ss->gs.hdr[0]; 204 cText.version = (ss->gs.hdr[1] << 8) | ss->gs.hdr[2]; 205 cText.buf = &ss->gs.inbuf; 206 rv = ssl3_HandleRecord(ss, &cText, &ss->gs.buf); 207 if (rv < 0) { 208 return ss->recvdCloseNotify ? 0 : rv; 209 } 210 } while (ss->ssl3.hs.ws != idle_handshake && ss->gs.buf.len == 0); 211 212 ss->gs.readOffset = 0; 213 ss->gs.writeOffset = ss->gs.buf.len; 214 return 1; 215 } 216 217 /* Repeatedly gather in a record and when complete, Handle that record. 218 * Repeat this until some application data is received. 219 * 220 * Returns 1 when application data is available. 221 * Returns 0 if ssl3_GatherData hits EOF. 222 * Returns -1 on read error, or PR_WOULD_BLOCK_ERROR, or handleRecord error. 223 * Returns -2 on SECWouldBlock return from ssl3_HandleRecord. 224 * 225 * Called from DoRecv in sslsecur.c 226 * Caller must hold the recv buf lock. 227 */ 228 int 229 ssl3_GatherAppDataRecord(sslSocket *ss, int flags) 230 { 231 int rv; 232 233 PORT_Assert( ss->opt.noLocks || ssl_HaveRecvBufLock(ss) ); 234 do { 235 rv = ssl3_GatherCompleteHandshake(ss, flags); 236 } while (rv > 0 && ss->gs.buf.len == 0); 237 238 return rv; 239 } 240
