Remove status_response callbacks where they are not needed.
[asterisk/asterisk.git] / main / astfd.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2009, Digium, Inc.
5  *
6  * Tilghman Lesher <tlesher@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Debugging routines for file descriptor leaks
22  *
23  * \author Tilghman Lesher <tlesher@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 #ifdef DEBUG_FD_LEAKS
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include <stdio.h>
33 #include <string.h>
34 #include <stddef.h>
35 #include <time.h>
36 #include <sys/time.h>
37 #include <sys/resource.h>
38
39 #include "asterisk/cli.h"
40 #include "asterisk/logger.h"
41 #include "asterisk/options.h"
42 #include "asterisk/lock.h"
43 #include "asterisk/strings.h"
44 #include "asterisk/unaligned.h"
45
46 static struct fdleaks {
47         char file[40];
48         int line;
49         char function[25];
50         char callname[10];
51         char callargs[60];
52         unsigned int isopen:1;
53 } fdleaks[1024] = { { "", }, };
54
55 #define COPY(dst, src)                                             \
56         do {                                                           \
57                 int dlen = sizeof(dst), slen = strlen(src);                \
58                 if (slen + 1 > dlen) {                                     \
59                         char *slash = strrchr(src, '/');                       \
60                         if (slash) {                                           \
61                                 ast_copy_string(dst, slash + 1, dlen);             \
62                         } else {                                               \
63                                 ast_copy_string(dst, src + slen - dlen + 1, dlen); \
64                         }                                                      \
65                 } else {                                                   \
66                         ast_copy_string(dst, src, dlen);                       \
67                 }                                                          \
68         } while (0)
69
70 #define STORE_COMMON(offset, name, ...)     \
71         COPY(fdleaks[offset].file, file);       \
72         fdleaks[offset].line = line;            \
73         COPY(fdleaks[offset].function, func);   \
74         strcpy(fdleaks[offset].callname, name); \
75         snprintf(fdleaks[offset].callargs, sizeof(fdleaks[offset].callargs), __VA_ARGS__); \
76         fdleaks[offset].isopen = 1;
77
78 #undef open
79 int __ast_fdleak_open(const char *file, int line, const char *func, const char *path, int flags, ...)
80 {
81         int res;
82         va_list ap;
83         int mode;
84
85         if (flags & O_CREAT) {
86                 va_start(ap, flags);
87                 mode = va_arg(ap, int);
88                 va_end(ap);
89                 res = open(path, flags, mode);
90                 if (res > -1 && res < (sizeof(fdleaks) / sizeof(fdleaks[0]))) {
91                         char sflags[80];
92                         snprintf(sflags, sizeof(sflags), "O_CREAT%s%s%s%s%s%s%s%s",
93                                 flags & O_APPEND ? "|O_APPEND" : "",
94                                 flags & O_EXCL ? "|O_EXCL" : "",
95                                 flags & O_NONBLOCK ? "|O_NONBLOCK" : "",
96                                 flags & O_TRUNC ? "|O_TRUNC" : "",
97                                 flags & O_RDWR ? "|O_RDWR" : "",
98                                 flags & O_RDONLY ? "|O_RDONLY" : "",
99                                 flags & O_WRONLY ? "|O_WRONLY" : "",
100                                 "");
101                         flags &= ~(O_CREAT | O_APPEND | O_EXCL | O_NONBLOCK | O_TRUNC | O_RDWR | O_RDONLY | O_WRONLY);
102                         if (flags) {
103                                 STORE_COMMON(res, "open", "\"%s\",%s|%d,%04o", path, sflags, flags, mode);
104                         } else {
105                                 STORE_COMMON(res, "open", "\"%s\",%s,%04o", path, sflags, mode);
106                         }
107                 }
108         } else {
109                 res = open(path, flags);
110                 if (res > -1 && res < (sizeof(fdleaks) / sizeof(fdleaks[0]))) {
111                         STORE_COMMON(res, "open", "\"%s\",%d", path, flags);
112                 }
113         }
114         return res;
115 }
116
117 #undef pipe
118 int __ast_fdleak_pipe(int *fds, const char *file, int line, const char *func)
119 {
120         int i, res = pipe(fds);
121         if (res) {
122                 return res;
123         }
124         for (i = 0; i < 2; i++) {
125                 STORE_COMMON(fds[i], "pipe", "{%d,%d}", fds[0], fds[1]);
126         }
127         return 0;
128 }
129
130 #undef socket
131 int __ast_fdleak_socket(int domain, int type, int protocol, const char *file, int line, const char *func)
132 {
133         char sdomain[20], stype[20], *sproto = NULL;
134         struct protoent *pe;
135         int res = socket(domain, type, protocol);
136         if (res < 0 || res > 1023) {
137                 return res;
138         }
139
140         if ((pe = getprotobynumber(protocol))) {
141                 sproto = pe->p_name;
142         }
143
144         if (domain == PF_UNIX) {
145                 ast_copy_string(sdomain, "PF_UNIX", sizeof(sdomain));
146         } else if (domain == PF_INET) {
147                 ast_copy_string(sdomain, "PF_INET", sizeof(sdomain));
148         } else {
149                 snprintf(sdomain, sizeof(sdomain), "%d", domain);
150         }
151
152         if (type == SOCK_DGRAM) {
153                 ast_copy_string(stype, "SOCK_DGRAM", sizeof(stype));
154                 if (protocol == 0) {
155                         sproto = "udp";
156                 }
157         } else if (type == SOCK_STREAM) {
158                 ast_copy_string(stype, "SOCK_STREAM", sizeof(stype));
159                 if (protocol == 0) {
160                         sproto = "tcp";
161                 }
162         } else {
163                 snprintf(stype, sizeof(stype), "%d", type);
164         }
165
166         if (sproto) {
167                 STORE_COMMON(res, "socket", "%s,%s,\"%s\"", sdomain, stype, sproto);
168         } else {
169                 STORE_COMMON(res, "socket", "%s,%s,\"%d\"", sdomain, stype, protocol);
170         }
171         return res;
172 }
173
174 #undef close
175 int __ast_fdleak_close(int fd)
176 {
177         int res = close(fd);
178         if (!res && fd > -1 && fd < 1024) {
179                 fdleaks[fd].isopen = 0;
180         }
181         return res;
182 }
183
184 #undef fopen
185 FILE *__ast_fdleak_fopen(const char *path, const char *mode, const char *file, int line, const char *func)
186 {
187         FILE *res = fopen(path, mode);
188         int fd;
189         if (!res) {
190                 return res;
191         }
192         fd = fileno(res);
193         STORE_COMMON(fd, "fopen", "\"%s\",\"%s\"", path, mode);
194         return res;
195 }
196
197 #undef fclose
198 int __ast_fdleak_fclose(FILE *ptr)
199 {
200         int fd, res;
201         if (!ptr) {
202                 return fclose(ptr);
203         }
204
205         fd = fileno(ptr);
206         if ((res = fclose(ptr)) || fd < 0 || fd > 1023) {
207                 return res;
208         }
209         fdleaks[fd].isopen = 0;
210         return res;
211 }
212
213 #undef dup2
214 int __ast_fdleak_dup2(int oldfd, int newfd, const char *file, int line, const char *func)
215 {
216         int res = dup2(oldfd, newfd);
217         if (res < 0 || res > 1023) {
218                 return res;
219         }
220         STORE_COMMON(res, "dup2", "%d,%d", oldfd, newfd);
221         return res;
222 }
223
224 #undef dup
225 int __ast_fdleak_dup(int oldfd, const char *file, int line, const char *func)
226 {
227         int res = dup(oldfd);
228         if (res < 0 || res > 1023) {
229                 return res;
230         }
231         STORE_COMMON(res, "dup2", "%d", oldfd);
232         return res;
233 }
234
235 static char *handle_show_fd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
236 {
237         int i;
238         char line[24];
239         struct rlimit rl;
240         switch (cmd) {
241         case CLI_INIT:
242                 e->command = "core show fd";
243                 e->usage =
244                         "Usage: core show fd\n"
245                         "       List all file descriptors currently in use and where\n"
246                         "       each was opened, and with what command.\n";
247                 return NULL;
248         case CLI_GENERATE:
249                 return NULL;
250         }
251         getrlimit(RLIMIT_FSIZE, &rl);
252         if (rl.rlim_cur == RLIM_INFINITY || rl.rlim_max == RLIM_INFINITY) {
253                 ast_copy_string(line, "unlimited", sizeof(line));
254         } else {
255                 snprintf(line, sizeof(line), "%d/%d", (int) rl.rlim_cur, (int) rl.rlim_max);
256         }
257         ast_cli(a->fd, "Current maxfiles: %s\n", line);
258         for (i = 0; i < 1024; i++) {
259                 if (fdleaks[i].isopen) {
260                         snprintf(line, sizeof(line), "%d", fdleaks[i].line);
261                         ast_cli(a->fd, "%5d %15s:%-7.7s (%-25s): %s(%s)\n", i, fdleaks[i].file, line, fdleaks[i].function, fdleaks[i].callname, fdleaks[i].callargs);
262                 }
263         }
264         return CLI_SUCCESS;
265 }
266
267 static struct ast_cli_entry cli_show_fd = AST_CLI_DEFINE(handle_show_fd, "Show open file descriptors");
268
269 int ast_fd_init(void)
270 {
271         return ast_cli_register(&cli_show_fd);
272 }
273
274 #else  /* !defined(DEBUG_FD_LEAKS) */
275 int ast_fd_init(void)
276 {
277         return 0;
278 }
279 #endif /* defined(DEBUG_FD_LEAKS) */
280