Changed strcpy() calls into strlcpy() calls, just to be extra safe.

[rsync/rsync.git] / lib / pool_alloc.c

diff --git a/lib/pool_alloc.c b/lib/pool_alloc.c
index 9f65b88..1ec381d 100644 (file)
--- a/lib/pool_alloc.c
+++ b/lib/pool_alloc.c
@@ -17,10 +17,10 @@ struct alloc_pool
        /* statistical data */
        unsigned long           e_created;      /* extents created      */
        unsigned long           e_freed;        /* extents detroyed     */
-       uint64                  n_allocated;    /* calls to alloc       */
-       uint64                  n_freed;        /* calls to free        */
-       uint64                  b_allocated;    /* cum. bytes allocated */
-       uint64                  b_freed;        /* cum. bytes freed     */
+       int64                   n_allocated;    /* calls to alloc       */
+       int64                   n_freed;        /* calls to free        */
+       int64                   b_allocated;    /* cum. bytes allocated */
+       int64                   b_freed;        /* cum. bytes freed     */
 };
 
 struct pool_extent
@@ -32,7 +32,16 @@ struct pool_extent
        struct pool_extent      *next;
 };
 
-#define MINALIGN       (sizeof (long))
+struct align_test {
+    void *foo;
+    int64 bar;
+};
+
+#define MINALIGN       offsetof(struct align_test, bar)
+
+/* Temporarily cast a void* var into a char* var when adding an offset (to
+ * keep some compilers from complaining about the pointer arithmetic). */
+#define PTR_ADD(b,o)   ( (void*) ((char*)(b) + (o)) )
 
 alloc_pool_t
 pool_create(size_t size, size_t quantum,
@@ -47,8 +56,7 @@ pool_create(size_t size, size_t quantum,
        pool->size = size       /* round extent size to min alignment reqs */
            ? (size + MINALIGN - 1) & ~(MINALIGN - 1)
            : POOL_DEF_EXTENT;
-       if (pool->flags & POOL_INTERN)
-       {
+       if (pool->flags & POOL_INTERN) {
                pool->size -= sizeof (struct pool_extent);
                flags |= POOL_APPEND;
        }
@@ -68,15 +76,13 @@ pool_destroy(alloc_pool_t p)
        if (!pool)
                return;
 
-       if (pool->live)
-       {
+       if (pool->live) {
                cur = pool->live;
                free(cur->start);
                if (!(pool->flags & POOL_APPEND))
                        free(cur);
        }
-       for (cur = pool->free; cur; cur = next)
-       {
+       for (cur = pool->free; cur; cur = next) {
                next = cur->next;
                free(cur->start);
                if (!(pool->flags & POOL_APPEND))
@@ -100,16 +106,14 @@ pool_alloc(alloc_pool_t p, size_t len, char *bomb)
        if (len > pool->size)
                goto bomb;
 
-       if (!pool->live || len > pool->live->free)
-       {
+       if (!pool->live || len > pool->live->free) {
                void    *start;
                size_t  free;
                size_t  bound;
                size_t  sqew;
                size_t  asize;
 
-               if (pool->live)
-               {
+               if (pool->live) {
                        pool->live->next = pool->free;
                        pool->free = pool->live;
                }
@@ -128,16 +132,11 @@ pool_alloc(alloc_pool_t p, size_t len, char *bomb)
                        memset(start, 0, pool->size);
 
                if (pool->flags & POOL_APPEND)
-               {
-                       pool->live = start + free;
-               }
+                       pool->live = PTR_ADD(start, free);
                else if (!(pool->live = (struct pool_extent *) malloc(sizeof (struct pool_extent))))
-               {
                        goto bomb;
-               }
                if (pool->flags & POOL_QALIGN && pool->quantum > 1
-                   && (sqew = (size_t)(start + free) % pool->quantum))
-               {
+                   && (sqew = (size_t)PTR_ADD(start, free) % pool->quantum)) {
                        bound  += sqew;
                        free -= sqew;
                }
@@ -154,7 +153,7 @@ pool_alloc(alloc_pool_t p, size_t len, char *bomb)
 
        pool->live->free -= len;
 
-       return pool->live->start + pool->live->free;
+       return PTR_ADD(pool->live->start, pool->live->free);
 
 bomb:
        if (pool->bomb)
@@ -177,8 +176,7 @@ pool_free(alloc_pool_t p, size_t len, void *addr)
        else if (pool->quantum > 1 && len % pool->quantum)
                len += pool->quantum - len % pool->quantum;
 
-       if (!addr && pool->live)
-       {
+       if (!addr && pool->live) {
                pool->live->next = pool->free;
                pool->free = pool->live;
                pool->live = NULL;
@@ -188,52 +186,43 @@ pool_free(alloc_pool_t p, size_t len, void *addr)
        pool->b_freed += len;
 
        cur = pool->live;
-       if (cur
-           && addr >= cur->start
-           && addr < cur->start + pool->size)
-       {
-               if (addr == cur->start + cur->free)
-               {
+       if (cur && addr >= cur->start
+           && addr < PTR_ADD(cur->start, pool->size)) {
+               if (addr == PTR_ADD(cur->start, cur->free)) {
                        if (pool->flags & POOL_CLEAR)
                                memset(addr, 0, len);
                        pool->b_freed += len;
-               } else {
+               } else
                        cur->bound += len;
-               }
-               if (cur->free + cur->bound >= pool->size)
-               {
+               if (cur->free + cur->bound >= pool->size) {
                        size_t sqew;
 
                        cur->free = pool->size;
                        cur->bound = 0;
                        if (pool->flags & POOL_QALIGN && pool->quantum > 1
-                           && (sqew = (size_t)(cur->start + cur->free) % pool->quantum))
-                       {
+                           && (sqew = (size_t)PTR_ADD(cur->start, cur->free) % pool->quantum)) {
                                cur->bound += sqew;
                                cur->free -= sqew;
                        }
                }
                return;
        }
-       for (prev = NULL, cur = pool->free; cur; prev = cur, cur = cur->next)
-       {
+       for (prev = NULL, cur = pool->free; cur; prev = cur, cur = cur->next) {
                if (addr >= cur->start
-                   && addr < cur->start + pool->size)
+                   && addr < PTR_ADD(cur->start, pool->size))
                        break;
        }
        if (!cur)
                return;
 
-       if (prev)
-       {
+       if (prev) {
                prev->next = cur->next;
                cur->next = pool->free;
                pool->free = cur;
        }
        cur->bound += len;
 
-       if (cur->free + cur->bound >= pool->size)
-       {
+       if (cur->free + cur->bound >= pool->size) {
                pool->free = cur->next;
 
                free(cur->start);
@@ -245,11 +234,11 @@ pool_free(alloc_pool_t p, size_t len, void *addr)
 }
 
 #define FDPRINT(label, value) \
-       snprintf(buf, BUFSIZ, label, value), \
-       write(fd, buf, strlen(buf));
+       snprintf(buf, sizeof buf, label, value), \
+       write(fd, buf, strlen(buf))
 
 #define FDEXTSTAT(ext) \
-       snprintf(buf, BUFSIZ, "  %12ld  %5ld\n", \
+       snprintf(buf, sizeof buf, "  %12ld  %5ld\n", \
                (long) ext->free, \
                (long) ext->bound), \
        write(fd, buf, strlen(buf))
@@ -282,14 +271,10 @@ pool_stats(alloc_pool_t p, int fd, int summarize)
        write(fd, "\n", 1);
 
        if (pool->live)
-       {
                FDEXTSTAT(pool->live);
-       }
-       strcpy(buf, "   FREE    BOUND\n");
+       strlcpy(buf, "   FREE    BOUND\n", sizeof buf);
        write(fd, buf, strlen(buf));
 
        for (cur = pool->free; cur; cur = cur->next)
-       {
                FDEXTSTAT(cur);
-       }
 }