Update net/third_party/nss/ssl to NSS 3.14.

net/third_party/nss/ssl/dtlscon.c

+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
 /*
  * DTLS Protocol
- *
- * ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is the Netscape security libraries.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1994-2000
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Eric Rescorla <ekr@rtfm.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-/* $Id: $ */
+ */
+/* $Id: dtlscon.c,v 1.5 2012/09/28 01:46:45 wtc%google.com Exp $ */
 
 #include "ssl.h"
 #include "sslimpl.h"
 #include "sslproto.h"
 
 #ifndef PR_ARRAY_SIZE
 #define PR_ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
 #endif
 
 static SECStatus dtls_TransmitMessageFlight(sslSocket *ss);
@@ skipping 228 matching lines @@
          */
         if ((message_seq == ss->ssl3.hs.recvMessageSeq)
             && (fragment_offset == 0)
             && (fragment_length == message_length)) {
             /* Complete next message. Process immediately */
             ss->ssl3.hs.msg_type = (SSL3HandshakeType)type;
             ss->ssl3.hs.msg_len = message_length;
 
             /* At this point we are advancing our state machine, so
              * we can free our last flight of messages */
-            dtls_FreeHandshakeMessages(ss->ssl3.hs.lastMessageFlight);
+            dtls_FreeHandshakeMessages(&ss->ssl3.hs.lastMessageFlight);
             ss->ssl3.hs.recvdHighWater = -1;
             dtls_CancelTimer(ss);
 
             /* Reset the timer to the initial value if the retry counter
              * is 0, per Sec. 4.2.4.1 */
             if (ss->ssl3.hs.rtRetries == 0) {
                 ss->ssl3.hs.rtTimeoutMs = INITIAL_DTLS_TIMEOUT_MS;
             }
 
             rv = ssl3_HandleHandshakeMessage(ss, buf.buf, ss->ssl3.hs.msg_len);
@@ skipping 146 matching lines @@
                     ss->ssl3.hs.recvdHighWater = -1;
 
                     rv = ssl3_HandleHandshakeMessage(ss,
                                                      ss->ssl3.hs.msg_body.buf,
                                                      ss->ssl3.hs.msg_len);
                     if (rv == SECFailure)
                         break; /* Skip rest of record */
 
                     /* At this point we are advancing our state machine, so
                      * we can free our last flight of messages */
-                    dtls_FreeHandshakeMessages(ss->ssl3.hs.lastMessageFlight);
+                    dtls_FreeHandshakeMessages(&ss->ssl3.hs.lastMessageFlight);
                     dtls_CancelTimer(ss);
 
                     /* If there have been no retries this time, reset the
                      * timer value to the default per Section 4.2.4.1 */
                     if (ss->ssl3.hs.rtRetries == 0) {
                         ss->ssl3.hs.rtTimeoutMs = INITIAL_DTLS_TIMEOUT_MS;
                     }
                 }
             }
         }
@@ skipping 23 matching lines @@
 
     PORT_Assert(ss->opt.noLocks || ssl_HaveSSL3HandshakeLock(ss));
     PORT_Assert(ss->opt.noLocks || ssl_HaveXmitBufLock(ss));
 
     msg = dtls_AllocQueuedMessage(ss->ssl3.cwSpec->epoch, type, pIn, nIn);
 
     if (!msg) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         rv = SECFailure;
     } else {
-        PR_APPEND_LINK(&msg->link, ss->ssl3.hs.lastMessageFlight);
+        PR_APPEND_LINK(&msg->link, &ss->ssl3.hs.lastMessageFlight);
     }
 
     return rv;
 }
 
 /* Add DTLS handshake message to the pending queue
  * Empty the sendBuf buffer.
  * This function returns SECSuccess or SECFailure, never SECWouldBlock.
  * Always set sendBuf.len to 0, even when returning SECFailure.
  *
@@ skipping 105 matching lines @@
     ssl_GetXmitBufLock(ss);
     ssl_GetSpecReadLock(ss);
 
     /* DTLS does not buffer its handshake messages in
      * ss->pendingBuf, but rather in the lastMessageFlight
      * structure. This is just a sanity check that
      * some programming error hasn't inadvertantly
      * stuffed something in ss->pendingBuf
      */
     PORT_Assert(!ss->pendingBuf.len);
-    for (msg_p = PR_LIST_HEAD(ss->ssl3.hs.lastMessageFlight);
-         msg_p != ss->ssl3.hs.lastMessageFlight;
+    for (msg_p = PR_LIST_HEAD(&ss->ssl3.hs.lastMessageFlight);
+         msg_p != &ss->ssl3.hs.lastMessageFlight;
          msg_p = PR_NEXT_LINK(msg_p)) {
         DTLSQueuedMessage *msg = (DTLSQueuedMessage *)msg_p;
 
         /* The logic here is:
          *
          * 1. If this is a message that will not fit into the remaining
          *    space, then flush.
          * 2. If the message will now fit into the remaining space,
          *    encrypt, buffer, and loop.
          * 3. If the message will not fit, then fragment.
@@ skipping 518 matching lines @@
     desired = PR_MillisecondsToInterval(ss->ssl3.hs.rtTimeoutMs);
     if (elapsed > desired) {
         /* Timer expired */
         *timeout = PR_INTERVAL_NO_WAIT;
     } else {
         *timeout = desired - elapsed;
     }
 
     return SECSuccess;
 }