get rid of another annoying stray space in the gcc commands
[asterisk/asterisk.git] / io.c
diff --git a/io.c b/io.c
old mode 100755 (executable)
new mode 100644 (file)
index d1d8edb..220b29d
--- a/io.c
+++ b/io.c
@@ -1,24 +1,42 @@
 /*
- * Asterisk
- * 
- * Mark Spencer <markster@marko.net>
+ * Asterisk -- An open source telephony toolkit.
  *
- * Copyright(C) Mark Spencer
- * 
- * Distributed under the terms of the GNU General Public License (GPL) Version 2
+ * Copyright (C) 1999 - 2005, Digium, Inc.
  *
- * I/O Managment (Derived from Cheops-NG)
+ * Mark Spencer <markster@digium.com>
  *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief I/O Managment (Derived from Cheops-NG)
+ *
+ * \author Mark Spencer <markster@digium.com>
  */
 
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <termios.h>
-#include <string.h> /* for memset */
+#include <string.h>
 #include <sys/ioctl.h>
-#include <asterisk/io.h>
-#include <asterisk/logger.h>
+
+#include "asterisk/io.h"
+#include "asterisk/logger.h"
+#include "asterisk/utils.h"
 
 #ifdef DEBUG_IO
 #define DEBUG DEBUG_M
@@ -61,30 +79,24 @@ struct io_context {
        int needshrink;
 };
 
-
 struct io_context *io_context_create(void)
 {
        /* Create an I/O context */
        struct io_context *tmp;
-       tmp = malloc(sizeof(struct io_context));
-       if (tmp) {
+       if ((tmp = ast_malloc(sizeof(*tmp)))) {
                tmp->needshrink = 0;
                tmp->fdcnt = 0;
                tmp->maxfdcnt = GROW_SHRINK_SIZE/2;
                tmp->current_ioc = -1;
-               tmp->fds = malloc((GROW_SHRINK_SIZE/2) * sizeof(struct pollfd));
-               if (!tmp->fds) {
+               if (!(tmp->fds = ast_calloc(1, (GROW_SHRINK_SIZE / 2) * sizeof(*tmp->fds)))) {
                        free(tmp);
                        tmp = NULL;
                } else {
-                       memset(tmp->fds, 0, (GROW_SHRINK_SIZE/2) * sizeof(struct pollfd));
-                       tmp->ior =  malloc((GROW_SHRINK_SIZE/2) * sizeof(struct io_rec));
-                       if (!tmp->ior) {
+                       if (!(tmp->ior = ast_calloc(1, (GROW_SHRINK_SIZE / 2) * sizeof(*tmp->ior)))) {
                                free(tmp->fds);
                                free(tmp);
                                tmp = NULL;
-                       } else
-                               memset(tmp->ior, 0, (GROW_SHRINK_SIZE/2) * sizeof(struct io_rec));
+                       }
                }
        }
        return tmp;
@@ -109,26 +121,24 @@ static int io_grow(struct io_context *ioc)
        void *tmp;
        DEBUG(ast_log(LOG_DEBUG, "io_grow()\n"));
        ioc->maxfdcnt += GROW_SHRINK_SIZE;
-       tmp = realloc(ioc->ior, (ioc->maxfdcnt + 1) * sizeof(struct io_rec));
-       if (tmp) {
-               ioc->ior = (struct io_rec *)tmp;
-               tmp = realloc(ioc->fds, (ioc->maxfdcnt + 1) * sizeof(struct pollfd));
-               if (tmp) {
+       if ((tmp = ast_realloc(ioc->ior, (ioc->maxfdcnt + 1) * sizeof(*ioc->ior)))) {
+               ioc->ior = tmp;
+               if ((tmp = ast_realloc(ioc->fds, (ioc->maxfdcnt + 1) * sizeof(*ioc->fds)))) {
                        ioc->fds = tmp;
                } else {
                        /*
-                        * Not enough memory for the pollfd.  Not really any need
-                        * to shrink back the iorec's as we'll probably want to
-                        * grow them again soon when more memory is available, and
-                        * then they'll already be the right size
+                        * Failed to allocate enough memory for the pollfd.  Not
+                        * really any need to shrink back the iorec's as we'll
+                        * probably want to grow them again soon when more memory
+                        * is available, and then they'll already be the right size
                         */
                        ioc->maxfdcnt -= GROW_SHRINK_SIZE;
                        return -1;
                }
-               
        } else {
                /*
-                * Out of memory.  We return to the old size, and return a failure
+                * Memory allocation failure.  We return to the old size, and 
+                * return a failure
                 */
                ioc->maxfdcnt -= GROW_SHRINK_SIZE;
                return -1;
@@ -161,12 +171,13 @@ int *ast_io_add(struct io_context *ioc, int fd, ast_io_cb callback, short events
         */
        ioc->fds[ioc->fdcnt].fd = fd;
        ioc->fds[ioc->fdcnt].events = events;
+       ioc->fds[ioc->fdcnt].revents = 0;
        ioc->ior[ioc->fdcnt].callback = callback;
        ioc->ior[ioc->fdcnt].data = data;
-       ioc->ior[ioc->fdcnt].id = (int *)malloc(sizeof(int));
-       /* Bonk if we couldn't allocate an int */
-       if (!ioc->ior[ioc->fdcnt].id)
+       if (!(ioc->ior[ioc->fdcnt].id = ast_malloc(sizeof(*ioc->ior[ioc->fdcnt].id)))) {
+               /* Bonk if we couldn't allocate an int */
                return NULL;
+       }
        *(ioc->ior[ioc->fdcnt].id) = ioc->fdcnt;
        ret = ioc->ior[ioc->fdcnt].id;
        ioc->fdcnt++;
@@ -185,7 +196,8 @@ int *ast_io_change(struct io_context *ioc, int *id, int fd, ast_io_cb callback,
                if (data)
                        ioc->ior[*id].data = data;
                return id;
-       } else return NULL;
+       }
+       return NULL;
 }
 
 static int io_shrink(struct io_context *ioc)
@@ -197,7 +209,7 @@ static int io_shrink(struct io_context *ioc)
         * the entry we are removing, then decrease the size of the 
         * arrays by one.
         */
-       for (getfrom=0;getfrom<ioc->fdcnt;getfrom++) {
+       for (getfrom = 0; getfrom < ioc->fdcnt; getfrom++) {
                if (ioc->ior[getfrom].id) {
                        /* In use, save it */
                        if (getfrom != putto) {
@@ -222,7 +234,7 @@ int ast_io_remove(struct io_context *ioc, int *_id)
                ast_log(LOG_WARNING, "Asked to remove NULL?\n");
                return -1;
        }
-       for (x=0;x<ioc->fdcnt;x++) {
+       for (x = 0; x < ioc->fdcnt; x++) {
                if (ioc->ior[x].id == _id) {
                        /* Free the int immediately and set to NULL so we know it's unused now */
                        free(ioc->ior[x].id);
@@ -257,7 +269,7 @@ int ast_io_wait(struct io_context *ioc, int howlong)
                 * At least one event
                 */
                origcnt = ioc->fdcnt;
-               for(x=0;x<origcnt;x++) {
+               for(x = 0; x < origcnt; x++) {
                        /* Yes, it is possible for an entry to be deleted and still have an
                           event waiting if it occurs after the original calling id */
                        if (ioc->fds[x].revents && ioc->ior[x].id) {
@@ -289,7 +301,7 @@ void ast_io_dump(struct io_context *ioc)
        ast_log(LOG_DEBUG, "================================================\n");
        ast_log(LOG_DEBUG, "| ID    FD     Callback    Data        Events  |\n");
        ast_log(LOG_DEBUG, "+------+------+-----------+-----------+--------+\n");
-       for (x=0;x<ioc->fdcnt;x++) {
+       for (x = 0; x < ioc->fdcnt; x++) {
                ast_log(LOG_DEBUG, "| %.4d | %.4d | %p | %p | %.6x |\n", 
                                *ioc->ior[x].id,
                                ioc->fds[x].fd,