Update to NSPR 4.9.5 Beta 2, part 2: actual changes.

mozilla/nsprpub/pr/src/io/prlayer.c

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 
 /*
 ** File:        prlayer.c
 ** Description: Routines for handling pushable protocol modules on sockets.
 */
 
@@ skipping 505 matching lines @@
     }
 
     if (stack == insert)
     {
                 /* going on top of the stack */
                 /* old-style stack */   
                 PRFileDesc copy = *stack;
                 *stack = *fd;
                 *fd = copy;
                 fd->higher = stack;
+                if (fd->lower)
+                {
+                        PR_ASSERT(fd->lower->higher == stack);
+                        fd->lower->higher = fd;
+                }
                 stack->lower = fd;
                 stack->higher = NULL;
         } else {
         /*
                  * going somewhere in the middle of the stack for both old and new
                  * style stacks, or going on top of stack for new style stack
                  */
         fd->lower = insert;
         fd->higher = insert->higher;
 
@@ skipping 18 matching lines @@
     }
 
     if (extract == stack) {
         /* popping top layer of the stack */
                 /* old style stack */
         PRFileDesc copy = *stack;
         extract = stack->lower;
         *stack = *extract;
         *extract = copy;
         stack->higher = NULL;
+        if (stack->lower) {
+            PR_ASSERT(stack->lower->higher == extract);
+            stack->lower->higher = stack;
+        }
         } else if ((PR_IO_LAYER_HEAD == stack->identity) &&
                                         (extract == stack->lower) && (extract->lower == NULL)) {
                         /*
                          * new style stack
                          * popping the only layer in the stack; delete the stack too
                          */
                         stack->lower = NULL;
                         _PR_DestroyIOLayer(stack);
         } else {
                 /* for both kinds of stacks */
@@ skipping 31 matching lines @@
         {
             PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
             return PR_INVALID_IO_LAYER;
         }
         strcpy(name, layer_name);
     }
 
     /* this initial code runs unsafe */
 retry:
     PR_ASSERT(NULL == names);
+    /*
+     * In the initial round, both identity_cache.ident and
+     * identity_cache.length are 0, so (identity_cache.ident + 1) is greater
+     * than length.  In later rounds, identity_cache.ident is always less
+     * than length, so (identity_cache.ident + 1) can be equal to but cannot
+     * be greater than length.
+     */
     length = identity_cache.length;
-    if (length < (identity_cache.ident + 1))
+    if ((identity_cache.ident + 1) >= length)
     {
         length += ID_CACHE_INCREMENT;
         names = (char**)PR_CALLOC(length * sizeof(char*));
         if (NULL == names)
         {
             if (NULL != name) PR_DELETE(name);
             PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
             return PR_INVALID_IO_LAYER;
         }
     }
 
     /* now we get serious about thread safety */
     PR_Lock(identity_cache.ml);
-    PR_ASSERT(identity_cache.ident <= identity_cache.length);
+    PR_ASSERT(identity_cache.length == 0 ||
+              identity_cache.ident < identity_cache.length);
     identity = identity_cache.ident + 1;
-    if (identity > identity_cache.length)  /* there's no room */
+    if (identity >= identity_cache.length)  /* there's no room */
     {
         /* we have to do something - hopefully it's already done */
-        if ((NULL != names) && (length >= identity))
+        if ((NULL != names) && (identity < length))
         {
             /* what we did is still okay */
             memcpy(
                 names, identity_cache.name,
                 identity_cache.length * sizeof(char*));
             old = identity_cache.name;
             identity_cache.name = names;
             identity_cache.length = length;
             names = NULL;
         }
         else
         {
-            PR_ASSERT(identity_cache.ident <= identity_cache.length);
             PR_Unlock(identity_cache.ml);
             if (NULL != names) PR_DELETE(names);
             goto retry;
         }
     }
     if (NULL != name) /* there's a name to be stored */
     {
         identity_cache.name[identity] = name;
     }
     identity_cache.ident = identity;
-    PR_ASSERT(identity_cache.ident <= identity_cache.length);
+    PR_ASSERT(identity_cache.ident < identity_cache.length);
     PR_Unlock(identity_cache.ml);
 
     if (NULL != old) PR_DELETE(old);
     if (NULL != names) PR_DELETE(names);
 
     return identity;
 }  /* PR_GetUniqueIdentity */
 
 PR_IMPLEMENT(const char*) PR_GetNameForIdentity(PRDescIdentity ident)
 {
@@ skipping 57 matching lines @@
         PRDescIdentity ident;
 
         for (ident = 0; ident <= identity_cache.ident; ident++)
             PR_DELETE(identity_cache.name[ident]);
 
         PR_DELETE(identity_cache.name);
     }
 }  /* _PR_CleanupLayerCache */
 
 /* prlayer.c */