io.c File Reference

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

Go to the source code of this file.

Defines
#define	DEBUG(a)
#define	GROW_SHRINK_SIZE   512
Functions
io_context *	io_context_create (void)
	Creates a context.
void	io_context_destroy (struct io_context *ioc)
	Destroys a context.
int *	ast_io_add (struct io_context *ioc, int fd, ast_io_cb callback, short events, void *data)
	Adds an IO context.
int *	ast_io_change (struct io_context *ioc, int *id, int fd, ast_io_cb callback, short events, void *data)
	Changes an IO handler.
int	ast_io_remove (struct io_context *ioc, int *_id)
	Removes an IO context.
int	ast_io_wait (struct io_context *ioc, int howlong)
	Waits for IO.
void	ast_io_dump (struct io_context *ioc)
	Dumps the IO array.
int	ast_hide_password (int fd)
	Set fd into non-echoing mode (if fd is a tty).
int	ast_restore_tty (int fd, int oldstate)
	Restores TTY mode.
int	ast_get_termcols (int fd)

---

Define Documentation

#define DEBUG (  a   )

Definition at line 26 of file io.c. Referenced by ast_io_add(), ast_io_wait(), ast_sched_add(), ast_sched_del(), ast_sched_runq(), and ast_sched_wait().

#define GROW_SHRINK_SIZE   512

Definition at line 45 of file io.c. Referenced by io_context_create().

---

Function Documentation

int ast_get_termcols (  int  fd  )

Definition at line 341 of file io.c. { 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 305 of file io.c. { 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 )

Adds an IO context. 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 139 of file io.c. References ast_log(), DEBUG, LOG_DEBUG, and malloc. Referenced by ast_rtp_new_with_bindaddr(). { /* * 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->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 )

Changes an IO handler. 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 176 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; } else return NULL; }

void ast_io_dump (  struct io_context *  ioc  )

Dumps the IO array. Definition at line 281 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 )

Removes an IO context. 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 218 of file io.c. References ast_log(), free, LOG_NOTICE, and LOG_WARNING. Referenced by ast_io_wait(), and ast_rtp_destroy(). { 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 )

Waits for IO. 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 243 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_context::ior, LOG_DEBUG, io_context::needshrink, poll(), and pollfd::revents. { /* * 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  oldstate )

Restores TTY mode. Definition at line 324 of file io.c. { 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   )

Creates a context. 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 65 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. { /* 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 93 of file io.c. References io_context::fds, free, and io_context::ior. { /* Free associated memory with an I/O context */ if (ioc->fds) free(ioc->fds); if (ioc->ior) free(ioc->ior); free(ioc); }

---