Sun Aug 6 15:12:20 2006

Asterisk developer's documentation

---

io.c File Reference

I/O Managment (Derived from Cheops-NG). More...

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <termios.h>
#include <string.h>
#include <sys/ioctl.h>
#include "asterisk.h"
#include "asterisk/io.h"
#include "asterisk/logger.h"

Include dependency graph for io.c:

Go to the source code of this file.

Defines
#define	DEBUG(a)
#define	GROW_SHRINK_SIZE   512
Functions
int	ast_get_termcols (int fd)
int	ast_hide_password (int fd)
int *	ast_io_add (struct io_context *ioc, int fd, ast_io_cb callback, short events, void *data)
int *	ast_io_change (struct io_context *ioc, int *id, int fd, ast_io_cb callback, short events, void *data)
void	ast_io_dump (struct io_context *ioc)
int	ast_io_remove (struct io_context *ioc, int *_id)
int	ast_io_wait (struct io_context *ioc, int howlong)
int	ast_restore_tty (int fd, int oldstate)
io_context *	io_context_create (void)
void	io_context_destroy (struct io_context *ioc)
static int	io_grow (struct io_context *ioc)
static int	io_shrink (struct io_context *ioc)

---

Detailed Description

I/O Managment (Derived from Cheops-NG).

Definition in file io.c.

---

Define Documentation

#define DEBUG (  a   )

Definition at line 42 of file io.c. Referenced by ast_io_add(), ast_io_wait(), ast_sched_add_variable(), ast_sched_del(), ast_sched_runq(), ast_sched_wait(), ast_sched_when(), and io_grow().

#define GROW_SHRINK_SIZE   512

Definition at line 61 of file io.c. Referenced by io_context_create(), and io_grow().

---

Function Documentation

int ast_get_termcols (  int  fd  )

Definition at line 358 of file io.c. Referenced by ast_cli_display_match_list(). { struct winsize win; int cols = 0; if (!isatty(fd)) return -1; if ( ioctl(fd, TIOCGWINSZ, &win) != -1 ) { if ( !cols && win.ws_col > 0 ) cols = (int) win.ws_col; } else { /* assume 80 characters if the ioctl fails for some reason */ cols = 80; } return cols; }

int ast_hide_password (  int  fd  )

Set fd into non-echoing mode (if fd is a tty) Definition at line 322 of file io.c. References ECHO. Referenced by pw_cb(). { struct termios tios; int res; int old; if (!isatty(fd)) return -1; res = tcgetattr(fd, &tios); if (res < 0) return -1; old = tios.c_lflag & (ECHO | ECHONL); tios.c_lflag &= ~ECHO; tios.c_lflag |= ECHONL; res = tcsetattr(fd, TCSAFLUSH, &tios); if (res < 0) return -1; return old; }

int* ast_io_add (  struct io_context *  ioc, int  fd, ast_io_cb  callback, short  events, void *  data )

Parameters: ioc  which context to use fd  which fd to monitor callback  callback function to run events  event mask of events to wait for data  data to pass to the callback Watch for any of revents activites on fd, calling callback with data as callback data. Returns a pointer to ID of the IO event, or NULL on failure. Definition at line 154 of file io.c. References ast_log(), DEBUG, io_grow(), LOG_DEBUG, and malloc. Referenced by ast_netsock_bindaddr(), ast_rtp_new_with_bindaddr(), do_monitor(), and network_thread(). { /* * Add a new I/O entry for this file descriptor * with the given event mask, to call callback with * data as an argument. Returns NULL on failure. */ int *ret; DEBUG(ast_log(LOG_DEBUG, "ast_io_add()\n")); if (ioc->fdcnt >= ioc->maxfdcnt) { /* * We don't have enough space for this entry. We need to * reallocate maxfdcnt poll fd's and io_rec's, or back out now. */ if (io_grow(ioc)) return NULL; } /* * At this point, we've got sufficiently large arrays going * and we can make an entry for it in the pollfd and io_r * structures. */ 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) return NULL; *(ioc->ior[ioc->fdcnt].id) = ioc->fdcnt; ret = ioc->ior[ioc->fdcnt].id; ioc->fdcnt++; return ret; }

int* ast_io_change (  struct io_context *  ioc, int *  id, int  fd, ast_io_cb  callback, short  events, void *  data )

Parameters: ioc  which context to use id  fd  the fd you wish it to contain now callback  new callback function events  event mask to wait for data  data to pass to the callback function Change an i/o handler, updating fd if > -1, callback if non-null, and revents if >-1, and data if non-null. Returns a pointero to the ID of the IO event, or NULL on failure. Definition at line 192 of file io.c. References io_rec::callback, io_rec::data, pollfd::events, pollfd::fd, io_context::fds, and io_context::ior. { if (*id < ioc->fdcnt) { if (fd > -1) ioc->fds[*id].fd = fd; if (callback) ioc->ior[*id].callback = callback; if (events) ioc->fds[*id].events = events; if (data) ioc->ior[*id].data = data; return id; } return NULL; }

void ast_io_dump (  struct io_context *  ioc  )

Dumps the IO array Definition at line 298 of file io.c. References ast_log(), io_rec::callback, io_rec::data, pollfd::events, pollfd::fd, io_context::fdcnt, io_context::fds, io_rec::id, io_context::ior, LOG_DEBUG, and io_context::maxfdcnt. { /* * Print some debugging information via * the logger interface */ int x; ast_log(LOG_DEBUG, "Asterisk IO Dump: %d entries, %d max entries\n", ioc->fdcnt, ioc->maxfdcnt); 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++) { ast_log(LOG_DEBUG, "| %.4d | %.4d | %p | %p | %.6x |\n", *ioc->ior[x].id, ioc->fds[x].fd, ioc->ior[x].callback, ioc->ior[x].data, ioc->fds[x].events); } ast_log(LOG_DEBUG, "================================================\n"); }

int ast_io_remove (  struct io_context *  ioc, int *  id )

Parameters: ioc  which io_context to remove it from id  which ID to remove Remove an I/O id from consideration Returns 0 on success or -1 on failure. Definition at line 235 of file io.c. References ast_log(), free, io_shrink(), LOG_NOTICE, and LOG_WARNING. Referenced by ast_io_wait(), ast_netsock_destroy(), ast_rtp_destroy(), and reload_config(). { int x; if (!_id) { ast_log(LOG_WARNING, "Asked to remove NULL?\n"); return -1; } 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); ioc->ior[x].id = NULL; ioc->fds[x].events = 0; ioc->fds[x].revents = 0; ioc->needshrink = 1; if (!ioc->current_ioc) io_shrink(ioc); return 0; } } ast_log(LOG_NOTICE, "Unable to remove unknown id %p\n", _id); return -1; }

int ast_io_wait (  struct io_context *  ioc, int  howlong )

Parameters: ioc  which context to act upon howlong  how many milliseconds to wait Wait for I/O to happen, returning after howlong milliseconds, and after processing any necessary I/O. Returns the number of I/O events which took place. Definition at line 260 of file io.c. References ast_io_remove(), ast_log(), io_rec::callback, io_context::current_ioc, io_rec::data, DEBUG, pollfd::fd, io_context::fdcnt, io_context::fds, io_rec::id, io_shrink(), io_context::ior, LOG_DEBUG, io_context::needshrink, poll(), and pollfd::revents. Referenced by do_monitor(), network_thread(), and reload_config(). { /* * Make the poll call, and call * the callbacks for anything that needs * to be handled */ int res; int x; int origcnt; DEBUG(ast_log(LOG_DEBUG, "ast_io_wait()\n")); res = poll(ioc->fds, ioc->fdcnt, howlong); if (res > 0) { /* * At least one event */ origcnt = ioc->fdcnt; 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) { /* There's an event waiting */ ioc->current_ioc = *ioc->ior[x].id; if (ioc->ior[x].callback) { if (!ioc->ior[x].callback(ioc->ior[x].id, ioc->fds[x].fd, ioc->fds[x].revents, ioc->ior[x].data)) { /* Time to delete them since they returned a 0 */ ast_io_remove(ioc, ioc->ior[x].id); } } ioc->current_ioc = -1; } } if (ioc->needshrink) io_shrink(ioc); } return res; }

int ast_restore_tty (  int  fd, int  oldstatus )

Restores TTY mode Definition at line 341 of file io.c. References ECHO. Referenced by pw_cb(). { int res; struct termios tios; if (oldstate < 0) return 0; res = tcgetattr(fd, &tios); if (res < 0) return -1; tios.c_lflag &= ~(ECHO | ECHONL); tios.c_lflag |= oldstate; res = tcsetattr(fd, TCSAFLUSH, &tios); if (res < 0) return -1; return 0; }

struct io_context* io_context_create (  void   )

Create a context for I/O operations Basically mallocs an IO structure and sets up some default values. Returns an allocated io_context structure Definition at line 80 of file io.c. References io_context::current_ioc, io_context::fdcnt, io_context::fds, free, GROW_SHRINK_SIZE, io_context::ior, malloc, io_context::maxfdcnt, and io_context::needshrink. Referenced by load_module(). { /* Create an I/O context */ struct io_context *tmp; tmp = malloc(sizeof(struct io_context)); if (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) { 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) { free(tmp->fds); free(tmp); tmp = NULL; } else { memset(tmp->ior, 0, (GROW_SHRINK_SIZE / 2) * sizeof(struct io_rec)); } } } return tmp; }

void io_context_destroy (  struct io_context *  ioc  )

Destroys a context Definition at line 109 of file io.c. References io_context::fds, free, and io_context::ior. Referenced by unload_module(). { /* Free associated memory with an I/O context */ if (ioc->fds) free(ioc->fds); if (ioc->ior) free(ioc->ior); free(ioc); }

static int io_grow (  struct io_context *  ioc  )  [static]

Definition at line 119 of file io.c. References ast_log(), DEBUG, io_context::fds, GROW_SHRINK_SIZE, io_context::ior, LOG_DEBUG, io_context::maxfdcnt, and realloc. Referenced by ast_io_add(). { /* * Grow the size of our arrays. Return 0 on success or * -1 on failure */ 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) { 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 */ ioc->maxfdcnt -= GROW_SHRINK_SIZE; return -1; } } else { /* * Out of memory. We return to the old size, and return a failure */ ioc->maxfdcnt -= GROW_SHRINK_SIZE; return -1; } return 0; }

static int io_shrink (  struct io_context *  ioc  )  [static]

Definition at line 208 of file io.c. Referenced by ast_io_remove(), and ast_io_wait(). { int getfrom; int putto = 0; /* * Bring the fields from the very last entry to cover over * the entry we are removing, then decrease the size of the * arrays by one. */ for (getfrom = 0; getfrom < ioc->fdcnt; getfrom++) { if (ioc->ior[getfrom].id) { /* In use, save it */ if (getfrom != putto) { ioc->fds[putto] = ioc->fds[getfrom]; ioc->ior[putto] = ioc->ior[getfrom]; *(ioc->ior[putto].id) = putto; } putto++; } } ioc->fdcnt = putto; ioc->needshrink = 0; /* FIXME: We should free some memory if we have lots of unused io structs */ return 0; }

---