Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/pqueue/pqueue.c

 /* crypto/pqueue/pqueue.c */
 /* 
  * DTLS implementation written by Nagendra Modadugu
  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.  
  */
 /* ====================================================================
  * Copyright (c) 1999-2005 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 50 matching lines @@
 #include <openssl/bn.h>
 #include "pqueue.h"
 
 typedef struct _pqueue
         {
         pitem *items;
         int count;
         } pqueue_s;
 
 pitem *
-pitem_new(PQ_64BIT priority, void *data)
+pitem_new(unsigned char *prio64be, void *data)
         {
         pitem *item = (pitem *) OPENSSL_malloc(sizeof(pitem));
         if (item == NULL) return NULL;
 
-        pq_64bit_init(&(item->priority));
-        pq_64bit_assign(&item->priority, &priority);
+        memcpy(item->priority,prio64be,sizeof(item->priority));
 
         item->data = data;
         item->next = NULL;
 
         return item;
         }
 
 void
 pitem_free(pitem *item)
         {
         if (item == NULL) return;
 
-        pq_64bit_free(&(item->priority));
         OPENSSL_free(item);
         }
 
 pqueue_s *
 pqueue_new()
         {
         pqueue_s *pq = (pqueue_s *) OPENSSL_malloc(sizeof(pqueue_s));
         if (pq == NULL) return NULL;
 
         memset(pq, 0x00, sizeof(pqueue_s));
@@ skipping 16 matching lines @@
         if (pq->items == NULL)
                 {
                 pq->items = item;
                 return item;
                 }
 
         for(curr = NULL, next = pq->items; 
                 next != NULL;
                 curr = next, next = next->next)
                 {
-                if (pq_64bit_gt(&(next->priority), &(item->priority)))
+                /* we can compare 64-bit value in big-endian encoding
+                 * with memcmp:-) */
+                int cmp = memcmp(next->priority, item->priority,8);
+                if (cmp > 0)            /* next > item */
                         {
                         item->next = next;
 
                         if (curr == NULL) 
                                 pq->items = item;
                         else  
                                 curr->next = item;
 
                         return item;
                         }
-                /* duplicates not allowed */
-                if (pq_64bit_eq(&(item->priority), &(next->priority)))
+                
+                else if (cmp == 0)      /* duplicates not allowed */
                         return NULL;
                 }
 
         item->next = NULL;
         curr->next = item;
 
         return item;
         }
 
 pitem *
 pqueue_peek(pqueue_s *pq)
         {
         return pq->items;
         }
 
 pitem *
 pqueue_pop(pqueue_s *pq)
         {
         pitem *item = pq->items;
 
         if (pq->items != NULL)
                 pq->items = pq->items->next;
 
         return item;
         }
 
 pitem *
-pqueue_find(pqueue_s *pq, PQ_64BIT priority)
+pqueue_find(pqueue_s *pq, unsigned char *prio64be)
         {
-        pitem *next, *prev = NULL;
+        pitem *next;
         pitem *found = NULL;
 
         if ( pq->items == NULL)
                 return NULL;
 
-        for ( next = pq->items; next->next != NULL; 
-                  prev = next, next = next->next)
+        for ( next = pq->items; next->next != NULL; next = next->next)
                 {
-                if ( pq_64bit_eq(&(next->priority), &priority))
+                if ( memcmp(next->priority, prio64be,8) == 0)
                         {
                         found = next;
                         break;
                         }
                 }
         
         /* check the one last node */
-        if ( pq_64bit_eq(&(next->priority), &priority))
+        if ( memcmp(next->priority, prio64be,8) ==0)
                 found = next;
 
         if ( ! found)
                 return NULL;
 
 #if 0 /* find works in peek mode */
         if ( prev == NULL)
                 pq->items = next->next;
         else
                 prev->next = next->next;
 #endif
 
         return found;
         }
 
-#if PQ_64BIT_IS_INTEGER
 void
 pqueue_print(pqueue_s *pq)
         {
         pitem *item = pq->items;
 
         while(item != NULL)
                 {
-                printf("item\t" PQ_64BIT_PRINT "\n", item->priority);
+                printf("item\t%02x%02x%02x%02x%02x%02x%02x%02x\n",
+                        item->priority[0],item->priority[1],
+                        item->priority[2],item->priority[3],
+                        item->priority[4],item->priority[5],
+                        item->priority[6],item->priority[7]);
                 item = item->next;
                 }
         }
-#endif
 
 pitem *
 pqueue_iterator(pqueue_s *pq)
         {
         return pqueue_peek(pq);
         }
 
 pitem *
 pqueue_next(pitem **item)
         {
@@ skipping 16 matching lines @@
         pitem *item = pq->items;
         int count = 0;
         
         while(item != NULL)
         {
                 count++;
                 item = item->next;
         }
         return count;
 }