Version 0.1.12 from FTP
[asterisk/asterisk.git] / io.c
1 /*
2  * Asterisk
3  * 
4  * Mark Spencer <markster@marko.net>
5  *
6  * Copyright(C) Mark Spencer
7  * 
8  * Distributed under the terms of the GNU General Public License (GPL) Version 2
9  *
10  * I/O Managment (Derived from Cheops-NG)
11  *
12  */
13
14 #include <stdio.h>
15 #include <sys/poll.h>
16 #include <unistd.h>
17 #include <stdlib.h>
18 #include <termios.h>
19 #include <asterisk/io.h>
20 #include <asterisk/logger.h>
21
22 #ifdef DEBUG_IO
23 #define DEBUG DEBUG_M
24 #else
25 #define DEBUG(a) 
26 #endif
27
28 /* 
29  * Kept for each file descriptor
30  */
31 struct io_rec {
32         ast_io_cb callback;             /* What is to be called */
33         void *data;                             /* Data to be passed */
34         int *id;                                        /* ID number */
35 };
36
37 /* These two arrays are keyed with
38    the same index.  it's too bad that
39    pollfd doesn't have a callback field
40    or something like that.  They grow as
41    needed, by GROW_SHRINK_AMOUNT structures
42    at once */
43
44 #define GROW_SHRINK_SIZE 512
45
46 /* Global variables are now in a struct in order to be
47    made threadsafe */
48 struct io_context {
49         /* Poll structure */
50         struct pollfd *fds;
51         /* Associated I/O records */
52         struct io_rec *ior;
53         /* First available fd */
54         unsigned int fdcnt;
55         /* Maximum available fd */
56         unsigned int maxfdcnt;
57         /* Currently used io callback */
58         int current_ioc;
59 };
60
61
62 struct io_context *io_context_create(void)
63 {
64         /* Create an I/O context */
65         struct io_context *tmp;
66         tmp = malloc(sizeof(struct io_context));
67         if (tmp) {
68                 tmp->fds = NULL;
69                 tmp->ior =  NULL;
70                 tmp->fdcnt = 0;
71                 tmp->maxfdcnt = -1;
72                 tmp->current_ioc = -1;
73         }
74         return tmp;
75 }
76
77 void io_context_destroy(struct io_context *ioc)
78 {
79         /* Free associated memory with an I/O context */
80         if (ioc->fds)
81                 free(ioc->fds);
82         if (ioc->ior)
83                 free(ioc->ior);
84         free(ioc);
85 }
86
87 static int io_grow(struct io_context *ioc)
88 {
89         /* 
90          * Grow the size of our arrays.  Return 0 on success or
91          * -1 on failure
92          */
93         void *tmp;
94         DEBUG(ast_log(LOG_DEBUG, "io_grow()\n"));
95         ioc->maxfdcnt += GROW_SHRINK_SIZE;
96         tmp = realloc(ioc->ior, (ioc->maxfdcnt + 1) * sizeof(struct io_rec));
97         if (tmp) {
98                 ioc->ior = (struct io_rec *)tmp;
99                 tmp = realloc(ioc->fds, (ioc->maxfdcnt + 1) * sizeof(struct pollfd));
100                 if (tmp) {
101                         ioc->fds = tmp;
102                 } else {
103                         /*
104                          * Not enough memory for the pollfd.  Not really any need
105                          * to shrink back the iorec's as we'll probably want to
106                          * grow them again soon when more memory is available, and
107                          * then they'll already be the right size
108                          */
109                         ioc->maxfdcnt -= GROW_SHRINK_SIZE;
110                         return -1;
111                 }
112                 
113         } else {
114                 /*
115                  * Out of memory.  We return to the old size, and return a failure
116                  */
117                 ioc->maxfdcnt -= GROW_SHRINK_SIZE;
118                 return -1;
119         }
120         return 0;
121 }
122
123 int *ast_io_add(struct io_context *ioc, int fd, ast_io_cb callback, short events, void *data)
124 {
125         /*
126          * Add a new I/O entry for this file descriptor
127          * with the given event mask, to call callback with
128          * data as an argument.  Returns NULL on failure.
129          */
130         DEBUG(ast_log(LOG_DEBUG, "ast_io_add()\n"));
131         if (ioc->fdcnt < ioc->maxfdcnt) {
132                 /* 
133                  * We don't have enough space for this entry.  We need to
134                  * reallocate maxfdcnt poll fd's and io_rec's, or back out now.
135                  */
136                 if (io_grow(ioc))
137                         return NULL;
138         }
139
140         /*
141          * At this point, we've got sufficiently large arrays going
142          * and we can make an entry for it in the pollfd and io_r
143          * structures.
144          */
145         ioc->fds[ioc->fdcnt].fd = fd;
146         ioc->fds[ioc->fdcnt].events = events;
147         ioc->ior[ioc->fdcnt].callback = callback;
148         ioc->ior[ioc->fdcnt].data = data;
149         ioc->ior[ioc->fdcnt].id = (int *)malloc(sizeof(int));
150         /* Bonk if we couldn't allocate an int */
151         if (!ioc->ior[ioc->fdcnt].id)
152                 return NULL;
153         *ioc->ior[ioc->fdcnt].id = ioc->fdcnt;
154         return ioc->ior[ioc->fdcnt++].id;
155 }
156
157 int *ast_io_change(struct io_context *ioc, int *id, int fd, ast_io_cb callback, short events, void *data)
158 {
159         if (*id < ioc->fdcnt) {
160                 if (fd > -1)
161                         ioc->fds[*id].fd = fd;
162                 if (callback)
163                         ioc->ior[*id].callback = callback;
164                 if (events)
165                         ioc->fds[*id].events = events;
166                 if (data)
167                         ioc->ior[*id].data = data;
168                 return id;
169         } else return NULL;
170 }
171
172 static int io_shrink(struct io_context *ioc, int which)
173 {
174         /* 
175          * Bring the fields from the very last entry to cover over
176          * the entry we are removing, then decrease the size of the 
177          * arrays by one.
178          */
179         ioc->fdcnt--;
180
181         /* Free the int */
182         free(ioc->ior[which].id);
183         
184         /* If we're not deleting the last one, move the last one to
185            the current position */
186         if (which != ioc->fdcnt) {
187                 ioc->fds[which] = ioc->fds[ioc->fdcnt];
188                 ioc->ior[which] = ioc->ior[ioc->fdcnt];
189                 *ioc->ior[which].id = which;
190         }
191         /* FIXME: We should free some memory if we have lots of unused
192            io structs */
193         return 0;
194 }
195
196 int ast_io_remove(struct io_context *ioc, int *id)
197 {
198         if (ioc->current_ioc == *id) {
199                 ast_log(LOG_NOTICE, "Callback for %d tried to remove itself (%p)\n", *id, id);
200         } else
201         
202         if (*id < ioc->fdcnt) {
203                 return io_shrink(ioc, *id);
204         } else 
205                 ast_log(LOG_NOTICE, "Unable to remove unknown id %d\n", *id);
206
207         return -1;
208 }
209
210 int ast_io_wait(struct io_context *ioc, int howlong)
211 {
212         /*
213          * Make the poll call, and call
214          * the callbacks for anything that needs
215          * to be handled
216          */
217         int res;
218         int x;
219         DEBUG(ast_log(LOG_DEBUG, "ast_io_wait()\n"));
220         res = poll(ioc->fds, ioc->fdcnt, howlong);
221         if (res > 0) {
222                 /*
223                  * At least one event
224                  */
225                 for(x=0;x<ioc->fdcnt;x++) {
226                         if (ioc->fds[x].revents) {
227                                 /* There's an event waiting */
228                                 
229                                 ioc->current_ioc = *ioc->ior[x].id;
230                                 if (!ioc->ior[x].callback(ioc->ior[x].id, ioc->fds[x].fd, ioc->fds[x].revents, ioc->ior[x].data)) {
231                                         /* Time to delete them since they returned a 0 */
232                                         io_shrink(ioc, x);
233                                 }
234                                 ioc->current_ioc = -1;
235                         }
236                 }
237         }
238         return res;
239 }
240
241 void ast_io_dump(struct io_context *ioc)
242 {
243         /*
244          * Print some debugging information via
245          * the logger interface
246          */
247         int x;
248         ast_log(LOG_DEBUG, "Asterisk IO Dump: %d entries, %d max entries\n", ioc->fdcnt, ioc->maxfdcnt);
249         ast_log(LOG_DEBUG, "================================================\n");
250         ast_log(LOG_DEBUG, "| ID    FD     Callback    Data        Events  |\n");
251         ast_log(LOG_DEBUG, "+------+------+-----------+-----------+--------+\n");
252         for (x=0;x<ioc->fdcnt;x++) {
253                 ast_log(LOG_DEBUG, "| %.4d | %.4d | %p | %p | %.6x |\n", 
254                                 *ioc->ior[x].id,
255                                 ioc->fds[x].fd,
256                                 ioc->ior[x].callback,
257                                 ioc->ior[x].data,
258                                 ioc->fds[x].events);
259         }
260         ast_log(LOG_DEBUG, "================================================\n");
261 }
262
263 /* Unrelated I/O functions */
264
265 int ast_hide_password(int fd)
266 {
267         struct termios tios;
268         int res;
269         int old;
270         if (!isatty(fd))
271                 return -1;
272         res = tcgetattr(fd, &tios);
273         if (res < 0)
274                 return -1;
275         old = tios.c_lflag & (ECHO | ECHONL);
276         tios.c_lflag &= ~ECHO;
277         tios.c_lflag |= ECHONL;
278         res = tcsetattr(fd, TCSAFLUSH, &tios);
279         if (res < 0)
280                 return -1;
281         return old;
282 }
283
284 int ast_restore_tty(int fd, int oldstate)
285 {
286         int res;
287         struct termios tios;
288         if (oldstate < 0)
289                 return 0;
290         res = tcgetattr(fd, &tios);
291         if (res < 0)
292                 return -1;
293         tios.c_lflag &= ~(ECHO | ECHONL);
294         tios.c_lflag |= oldstate;
295         res = tcsetattr(fd, TCSAFLUSH, &tios);
296         if (res < 0)
297                 return -1;
298         return 0;
299 }
300