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"
|
|
|
|
|
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"
|
2016-06-27 19:26:54 +00:00
|
|
|
#ifdef HAVE_SYSTEMD
|
|
|
|
#include <systemd/sd-daemon.h>
|
|
|
|
#endif
|
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;
|
|
|
|
}
|
|
|
|
|
2016-06-27 19:26:54 +00:00
|
|
|
int ast_sd_notify(const char *state) {
|
|
|
|
#ifdef HAVE_SYSTEMD
|
|
|
|
return sd_notify(0, state);
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|