1999-10-08 04:46:33 +00:00
|
|
|
/*
|
2005-09-14 20:46:50 +00:00
|
|
|
* Asterisk -- An open source telephony toolkit.
|
1999-10-08 04:46:33 +00:00
|
|
|
*
|
2005-09-14 20:46:50 +00:00
|
|
|
* Copyright (C) 1999 - 2005, Digium, Inc.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2005-10-24 20:12:06 +00:00
|
|
|
/*! \file
|
1999-10-08 04:46:33 +00:00
|
|
|
*
|
2005-10-24 20:12:06 +00:00
|
|
|
* \brief I/O Managment (Derived from Cheops-NG)
|
1999-10-08 04:46:33 +00:00
|
|
|
*
|
2005-12-30 21:18:06 +00:00
|
|
|
* \author Mark Spencer <markster@digium.com>
|
1999-10-08 04:46:33 +00:00
|
|
|
*/
|
|
|
|
|
2012-06-15 16:20:16 +00:00
|
|
|
/*** MODULEINFO
|
|
|
|
<support_level>core</support_level>
|
|
|
|
***/
|
|
|
|
|
2006-06-07 18:54:56 +00:00
|
|
|
#include "asterisk.h"
|
|
|
|
|
git migration: Refactor the ASTERISK_FILE_VERSION macro
Git does not support the ability to replace a token with a version
string during check-in. While it does have support for replacing a
token on clone, this is somewhat sub-optimal: the token is replaced
with the object hash, which is not particularly easy for human
consumption. What's more, in practice, the source file version was often
not terribly useful. Generally, when triaging bugs, the overall version
of Asterisk is far more useful than an individual SVN version of a file. As a
result, this patch removes Asterisk's support for showing source file
versions.
Specifically, it does the following:
* Rename ASTERISK_FILE_VERSION macro to ASTERISK_REGISTER_FILE, and
remove passing the version in with the macro. Other facilities
than 'core show file version' make use of the file names, such as
setting a debug level only on a specific file. As such, the act of
registering source files with the Asterisk core still has use. The
macro rename now reflects the new macro purpose.
* main/asterisk:
- Refactor the file_version structure to reflect that it no longer
tracks a version field.
- Remove the "core show file version" CLI command. Without the file
version, it is no longer useful.
- Remove the ast_file_version_find function. The file version is no
longer tracked.
- Rename ast_register_file_version/ast_unregister_file_version to
ast_register_file/ast_unregister_file, respectively.
* main/manager: Remove value from the Version key of the ModuleCheck
Action. The actual key itself has not been removed, as doing so would
absolutely constitute a backwards incompatible change. However, since
the file version is no longer tracked, there is no need to attempt to
include it in the Version key.
* UPGRADE: Add notes for:
- Modification to the ModuleCheck AMI Action
- Removal of the "core show file version" CLI command
Change-Id: I6cf0ff280e1668bf4957dc21f32a5ff43444a40e
2015-04-12 02:38:22 +00:00
|
|
|
ASTERISK_REGISTER_FILE()
|
2006-06-07 18:54:56 +00:00
|
|
|
|
2001-12-25 21:12:07 +00:00
|
|
|
#include <termios.h>
|
2002-11-27 05:04:07 +00:00
|
|
|
#include <sys/ioctl.h>
|
2005-04-22 13:11:34 +00:00
|
|
|
|
2005-04-21 06:02:45 +00:00
|
|
|
#include "asterisk/io.h"
|
2006-02-27 01:37:56 +00:00
|
|
|
#include "asterisk/utils.h"
|
1999-10-08 04:46:33 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG_IO
|
|
|
|
#define DEBUG DEBUG_M
|
|
|
|
#else
|
2012-03-22 19:51:16 +00:00
|
|
|
#define DEBUG(a)
|
1999-10-08 04:46:33 +00:00
|
|
|
#endif
|
|
|
|
|
2007-02-05 21:55:01 +00:00
|
|
|
/*! \brief
|
1999-10-08 04:46:33 +00:00
|
|
|
* Kept for each file descriptor
|
|
|
|
*/
|
|
|
|
struct io_rec {
|
2007-02-05 21:55:01 +00:00
|
|
|
ast_io_cb callback; /*!< What is to be called */
|
2012-03-22 19:51:16 +00:00
|
|
|
void *data; /*!< Data to be passed */
|
|
|
|
int *id; /*!< ID number */
|
1999-10-08 04:46:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* These two arrays are keyed with
|
|
|
|
the same index. it's too bad that
|
|
|
|
pollfd doesn't have a callback field
|
|
|
|
or something like that. They grow as
|
2007-12-27 20:11:20 +00:00
|
|
|
needed, by GROW_SHRINK_SIZE structures
|
1999-10-08 04:46:33 +00:00
|
|
|
at once */
|
|
|
|
|
|
|
|
#define GROW_SHRINK_SIZE 512
|
|
|
|
|
2007-02-15 17:13:29 +00:00
|
|
|
/*! \brief Global IO variables are now in a struct in order to be
|
1999-10-08 04:46:33 +00:00
|
|
|
made threadsafe */
|
|
|
|
struct io_context {
|
2007-02-05 21:55:01 +00:00
|
|
|
struct pollfd *fds; /*!< Poll structure */
|
|
|
|
struct io_rec *ior; /*!< Associated I/O records */
|
|
|
|
unsigned int fdcnt; /*!< First available fd */
|
|
|
|
unsigned int maxfdcnt; /*!< Maximum available fd */
|
|
|
|
int current_ioc; /*!< Currently used io callback */
|
|
|
|
int needshrink; /*!< Whether something has been deleted */
|
1999-10-08 04:46:33 +00:00
|
|
|
};
|
|
|
|
|
2007-02-15 17:13:29 +00:00
|
|
|
/*! \brief Create an I/O context */
|
1999-12-16 13:44:30 +00:00
|
|
|
struct io_context *io_context_create(void)
|
1999-10-08 04:46:33 +00:00
|
|
|
{
|
2007-02-15 02:11:34 +00:00
|
|
|
struct io_context *tmp = NULL;
|
|
|
|
|
|
|
|
if (!(tmp = ast_malloc(sizeof(*tmp))))
|
|
|
|
return NULL;
|
2012-03-22 19:51:16 +00:00
|
|
|
|
2007-02-15 02:11:34 +00:00
|
|
|
tmp->needshrink = 0;
|
|
|
|
tmp->fdcnt = 0;
|
|
|
|
tmp->maxfdcnt = GROW_SHRINK_SIZE/2;
|
|
|
|
tmp->current_ioc = -1;
|
2012-03-22 19:51:16 +00:00
|
|
|
|
2007-02-15 02:11:34 +00:00
|
|
|
if (!(tmp->fds = ast_calloc(1, (GROW_SHRINK_SIZE / 2) * sizeof(*tmp->fds)))) {
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(tmp);
|
2007-02-15 02:11:34 +00:00
|
|
|
tmp = NULL;
|
|
|
|
} else {
|
|
|
|
if (!(tmp->ior = ast_calloc(1, (GROW_SHRINK_SIZE / 2) * sizeof(*tmp->ior)))) {
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(tmp->fds);
|
|
|
|
ast_free(tmp);
|
2002-07-30 23:39:51 +00:00
|
|
|
tmp = NULL;
|
|
|
|
}
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
2007-02-15 02:11:34 +00:00
|
|
|
|
1999-10-08 04:46:33 +00:00
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void io_context_destroy(struct io_context *ioc)
|
|
|
|
{
|
|
|
|
/* Free associated memory with an I/O context */
|
|
|
|
if (ioc->fds)
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(ioc->fds);
|
1999-10-08 04:46:33 +00:00
|
|
|
if (ioc->ior)
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(ioc->ior);
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(ioc);
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
|
|
|
|
2007-02-05 21:55:01 +00:00
|
|
|
/*! \brief
|
2012-03-22 19:51:16 +00:00
|
|
|
* Grow the size of our arrays.
|
2007-02-05 21:55:01 +00:00
|
|
|
* \return 0 on success or -1 on failure
|
|
|
|
*/
|
1999-10-08 04:46:33 +00:00
|
|
|
static int io_grow(struct io_context *ioc)
|
|
|
|
{
|
|
|
|
void *tmp;
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2007-06-24 18:51:41 +00:00
|
|
|
DEBUG(ast_debug(1, "io_grow()\n"));
|
2007-02-15 02:11:34 +00:00
|
|
|
|
1999-10-08 04:46:33 +00:00
|
|
|
ioc->maxfdcnt += GROW_SHRINK_SIZE;
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2006-02-27 01:37:56 +00:00
|
|
|
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)))) {
|
1999-10-08 04:46:33 +00:00
|
|
|
ioc->fds = tmp;
|
|
|
|
} else {
|
|
|
|
/*
|
2006-02-27 01:37:56 +00:00
|
|
|
* 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
|
1999-10-08 04:46:33 +00:00
|
|
|
*/
|
|
|
|
ioc->maxfdcnt -= GROW_SHRINK_SIZE;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
2012-03-22 19:51:16 +00:00
|
|
|
* Memory allocation failure. We return to the old size, and
|
2006-02-27 01:37:56 +00:00
|
|
|
* return a failure
|
1999-10-08 04:46:33 +00:00
|
|
|
*/
|
|
|
|
ioc->maxfdcnt -= GROW_SHRINK_SIZE;
|
|
|
|
return -1;
|
|
|
|
}
|
2007-02-15 02:11:34 +00:00
|
|
|
|
1999-10-08 04:46:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-02-05 21:55:01 +00:00
|
|
|
/*! \brief
|
|
|
|
* Add a new I/O entry for this file descriptor
|
|
|
|
* with the given event mask, to call callback with
|
2012-03-22 19:51:16 +00:00
|
|
|
* data as an argument.
|
2007-02-05 21:55:01 +00:00
|
|
|
* \return Returns NULL on failure.
|
|
|
|
*/
|
1999-10-08 04:46:33 +00:00
|
|
|
int *ast_io_add(struct io_context *ioc, int fd, ast_io_cb callback, short events, void *data)
|
|
|
|
{
|
2002-07-30 23:39:51 +00:00
|
|
|
int *ret;
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2007-06-24 18:51:41 +00:00
|
|
|
DEBUG(ast_debug(1, "ast_io_add()\n"));
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2002-07-30 23:39:51 +00:00
|
|
|
if (ioc->fdcnt >= ioc->maxfdcnt) {
|
2012-03-22 19:51:16 +00:00
|
|
|
/*
|
1999-10-08 04:46:33 +00:00
|
|
|
* 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;
|
2005-08-31 22:12:23 +00:00
|
|
|
ioc->fds[ioc->fdcnt].revents = 0;
|
1999-10-08 04:46:33 +00:00
|
|
|
ioc->ior[ioc->fdcnt].callback = callback;
|
|
|
|
ioc->ior[ioc->fdcnt].data = data;
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2006-02-27 01:37:56 +00:00
|
|
|
if (!(ioc->ior[ioc->fdcnt].id = ast_malloc(sizeof(*ioc->ior[ioc->fdcnt].id)))) {
|
|
|
|
/* Bonk if we couldn't allocate an int */
|
1999-10-08 04:46:33 +00:00
|
|
|
return NULL;
|
2006-02-27 01:37:56 +00:00
|
|
|
}
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2002-07-30 23:39:51 +00:00
|
|
|
*(ioc->ior[ioc->fdcnt].id) = ioc->fdcnt;
|
|
|
|
ret = ioc->ior[ioc->fdcnt].id;
|
|
|
|
ioc->fdcnt++;
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2002-07-30 23:39:51 +00:00
|
|
|
return ret;
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int *ast_io_change(struct io_context *ioc, int *id, int fd, ast_io_cb callback, short events, void *data)
|
|
|
|
{
|
2007-02-15 02:11:34 +00:00
|
|
|
/* If this id exceeds our file descriptor count it doesn't exist here */
|
|
|
|
if (*id > ioc->fdcnt)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
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;
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
|
|
|
|
2002-07-30 23:39:51 +00:00
|
|
|
static int io_shrink(struct io_context *ioc)
|
1999-10-08 04:46:33 +00:00
|
|
|
{
|
2007-02-15 02:11:34 +00:00
|
|
|
int getfrom, putto = 0;
|
|
|
|
|
2012-03-22 19:51:16 +00:00
|
|
|
/*
|
1999-10-08 04:46:33 +00:00
|
|
|
* Bring the fields from the very last entry to cover over
|
2012-03-22 19:51:16 +00:00
|
|
|
* the entry we are removing, then decrease the size of the
|
1999-10-08 04:46:33 +00:00
|
|
|
* arrays by one.
|
|
|
|
*/
|
2005-07-19 13:44:42 +00:00
|
|
|
for (getfrom = 0; getfrom < ioc->fdcnt; getfrom++) {
|
2002-07-30 23:39:51 +00:00
|
|
|
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++;
|
|
|
|
}
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
2002-07-30 23:39:51 +00:00
|
|
|
ioc->fdcnt = putto;
|
|
|
|
ioc->needshrink = 0;
|
1999-10-08 04:46:33 +00:00
|
|
|
/* FIXME: We should free some memory if we have lots of unused
|
|
|
|
io structs */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-07-30 23:39:51 +00:00
|
|
|
int ast_io_remove(struct io_context *ioc, int *_id)
|
1999-10-08 04:46:33 +00:00
|
|
|
{
|
2002-07-30 23:39:51 +00:00
|
|
|
int x;
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2002-11-27 05:04:07 +00:00
|
|
|
if (!_id) {
|
2002-07-30 23:39:51 +00:00
|
|
|
ast_log(LOG_WARNING, "Asked to remove NULL?\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2005-07-19 13:44:42 +00:00
|
|
|
for (x = 0; x < ioc->fdcnt; x++) {
|
2002-07-30 23:39:51 +00:00
|
|
|
if (ioc->ior[x].id == _id) {
|
|
|
|
/* Free the int immediately and set to NULL so we know it's unused now */
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(ioc->ior[x].id);
|
2002-07-30 23:39:51 +00:00
|
|
|
ioc->ior[x].id = NULL;
|
|
|
|
ioc->fds[x].events = 0;
|
|
|
|
ioc->fds[x].revents = 0;
|
|
|
|
ioc->needshrink = 1;
|
2006-10-02 17:26:34 +00:00
|
|
|
if (ioc->current_ioc == -1)
|
2002-07-30 23:39:51 +00:00
|
|
|
io_shrink(ioc);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2012-03-22 19:51:16 +00:00
|
|
|
|
2002-07-30 23:39:51 +00:00
|
|
|
ast_log(LOG_NOTICE, "Unable to remove unknown id %p\n", _id);
|
2007-02-15 02:11:34 +00:00
|
|
|
|
1999-10-08 04:46:33 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-02-05 21:55:01 +00:00
|
|
|
/*! \brief
|
|
|
|
* Make the poll call, and call
|
|
|
|
* the callbacks for anything that needs
|
|
|
|
* to be handled
|
|
|
|
*/
|
1999-10-08 04:46:33 +00:00
|
|
|
int ast_io_wait(struct io_context *ioc, int howlong)
|
|
|
|
{
|
2007-02-15 02:11:34 +00:00
|
|
|
int res, x, origcnt;
|
|
|
|
|
2007-06-24 18:51:41 +00:00
|
|
|
DEBUG(ast_debug(1, "ast_io_wait()\n"));
|
2007-02-15 02:11:34 +00:00
|
|
|
|
Merged revisions 182810 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r182810 | russell | 2009-03-17 21:09:13 -0500 (Tue, 17 Mar 2009) | 44 lines
Fix cases where the internal poll() was not being used when it needed to be.
We have seen a number of problems caused by poll() not working properly on
Mac OSX. If you search around, you'll find a number of references to using
select() instead of poll() to work around these issues. In Asterisk, we've
had poll.c which implements poll() using select() internally. However, we
were still getting reports of problems.
vadim investigated a bit and realized that at least on his system, even
though we were compiling in poll.o, the system poll() was still being used.
So, the primary purpose of this patch is to ensure that we're using the
internal poll() when we want it to be used.
The changes are:
1) Remove logic for when internal poll should be used from the Makefile.
Instead, put it in the configure script. The logic in the configure
script is the same as it was in the Makefile. Ideally, we would have
a functionality test for the problem, but that's not actually possible,
since we would have to be able to run an application on the _target_
system to test poll() behavior.
2) Always include poll.o in the build, but it will be empty if AST_POLL_COMPAT
is not defined.
3) Change uses of poll() throughout the source tree to ast_poll(). I feel
that it is good practice to give the API call a new name when we are
changing its behavior and not using the system version directly in all cases.
So, normally, ast_poll() is just redefined to poll(). On systems where
AST_POLL_COMPAT is defined, ast_poll() is redefined to ast_internal_poll().
4) Change poll() in main/poll.c to be ast_internal_poll().
It's worth noting that any code that still uses poll() directly will work fine
(if they worked fine before). So, for example, out of tree modules that are
using poll() will not stop working or anything. However, for modules to work
properly on Mac OSX, ast_poll() needs to be used.
(closes issue #13404)
Reported by: agalbraith
Tested by: russell, vadim
http://reviewboard.digium.com/r/198/
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@182847 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-03-18 02:28:55 +00:00
|
|
|
if ((res = ast_poll(ioc->fds, ioc->fdcnt, howlong)) <= 0) {
|
2007-02-15 02:11:34 +00:00
|
|
|
return res;
|
Merged revisions 182810 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r182810 | russell | 2009-03-17 21:09:13 -0500 (Tue, 17 Mar 2009) | 44 lines
Fix cases where the internal poll() was not being used when it needed to be.
We have seen a number of problems caused by poll() not working properly on
Mac OSX. If you search around, you'll find a number of references to using
select() instead of poll() to work around these issues. In Asterisk, we've
had poll.c which implements poll() using select() internally. However, we
were still getting reports of problems.
vadim investigated a bit and realized that at least on his system, even
though we were compiling in poll.o, the system poll() was still being used.
So, the primary purpose of this patch is to ensure that we're using the
internal poll() when we want it to be used.
The changes are:
1) Remove logic for when internal poll should be used from the Makefile.
Instead, put it in the configure script. The logic in the configure
script is the same as it was in the Makefile. Ideally, we would have
a functionality test for the problem, but that's not actually possible,
since we would have to be able to run an application on the _target_
system to test poll() behavior.
2) Always include poll.o in the build, but it will be empty if AST_POLL_COMPAT
is not defined.
3) Change uses of poll() throughout the source tree to ast_poll(). I feel
that it is good practice to give the API call a new name when we are
changing its behavior and not using the system version directly in all cases.
So, normally, ast_poll() is just redefined to poll(). On systems where
AST_POLL_COMPAT is defined, ast_poll() is redefined to ast_internal_poll().
4) Change poll() in main/poll.c to be ast_internal_poll().
It's worth noting that any code that still uses poll() directly will work fine
(if they worked fine before). So, for example, out of tree modules that are
using poll() will not stop working or anything. However, for modules to work
properly on Mac OSX, ast_poll() needs to be used.
(closes issue #13404)
Reported by: agalbraith
Tested by: russell, vadim
http://reviewboard.digium.com/r/198/
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@182847 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-03-18 02:28:55 +00:00
|
|
|
}
|
2007-02-15 02:11:34 +00:00
|
|
|
|
|
|
|
/* At least one event tripped */
|
|
|
|
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);
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
|
|
|
}
|
2007-02-15 02:11:34 +00:00
|
|
|
ioc->current_ioc = -1;
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
|
|
|
}
|
2007-02-15 02:11:34 +00:00
|
|
|
|
|
|
|
if (ioc->needshrink)
|
|
|
|
io_shrink(ioc);
|
|
|
|
|
1999-10-08 04:46:33 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ast_io_dump(struct io_context *ioc)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Print some debugging information via
|
|
|
|
* the logger interface
|
|
|
|
*/
|
|
|
|
int x;
|
2007-02-15 02:11:34 +00:00
|
|
|
|
2014-05-09 22:49:26 +00:00
|
|
|
ast_debug(1, "Asterisk IO Dump: %u entries, %u max entries\n", ioc->fdcnt, ioc->maxfdcnt);
|
2007-06-24 18:51:41 +00:00
|
|
|
ast_debug(1, "================================================\n");
|
|
|
|
ast_debug(1, "| ID FD Callback Data Events |\n");
|
|
|
|
ast_debug(1, "+------+------+-----------+-----------+--------+\n");
|
2005-07-19 13:44:42 +00:00
|
|
|
for (x = 0; x < ioc->fdcnt; x++) {
|
2012-03-22 19:51:16 +00:00
|
|
|
ast_debug(1, "| %.4d | %.4d | %p | %p | %.6x |\n",
|
1999-10-08 04:46:33 +00:00
|
|
|
*ioc->ior[x].id,
|
|
|
|
ioc->fds[x].fd,
|
|
|
|
ioc->ior[x].callback,
|
|
|
|
ioc->ior[x].data,
|
2014-05-09 22:49:26 +00:00
|
|
|
(unsigned)ioc->fds[x].events);
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
2007-06-24 18:51:41 +00:00
|
|
|
ast_debug(1, "================================================\n");
|
1999-10-08 04:46:33 +00:00
|
|
|
}
|
2001-12-25 21:12:07 +00:00
|
|
|
|
|
|
|
/* Unrelated I/O functions */
|
|
|
|
|
|
|
|
int ast_hide_password(int fd)
|
|
|
|
{
|
|
|
|
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_restore_tty(int fd, int oldstate)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2002-11-27 05:04:07 +00:00
|
|
|
int ast_get_termcols(int fd)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|