Merged revisions 150298,150301 via svnmerge from
[asterisk/asterisk.git] / main / manager.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@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 The Asterisk Management Interface - AMI
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \extref OpenSSL http://www.openssl.org - for AMI/SSL 
26  *
27  * At the moment this file contains a number of functions, namely:
28  *
29  * - data structures storing AMI state
30  * - AMI-related API functions, used by internal asterisk components
31  * - handlers for AMI-related CLI functions
32  * - handlers for AMI functions (available through the AMI socket)
33  * - the code for the main AMI listener thread and individual session threads
34  * - the http handlers invoked for AMI-over-HTTP by the threads in main/http.c
35  *
36  * \ref amiconf
37  */
38
39 /*! \addtogroup Group_AMI AMI functions
40 */
41 /*! @{
42  Doxygen group */
43
44 #include "asterisk.h"
45
46 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
47
48 #include "asterisk/_private.h"
49 #include "asterisk/paths.h"     /* use various ast_config_AST_* */
50 #include <ctype.h>
51 #include <sys/time.h>
52 #include <signal.h>
53 #include <sys/mman.h>
54
55 #include "asterisk/channel.h"
56 #include "asterisk/file.h"
57 #include "asterisk/manager.h"
58 #include "asterisk/module.h"
59 #include "asterisk/config.h"
60 #include "asterisk/callerid.h"
61 #include "asterisk/lock.h"
62 #include "asterisk/cli.h"
63 #include "asterisk/app.h"
64 #include "asterisk/pbx.h"
65 #include "asterisk/md5.h"
66 #include "asterisk/acl.h"
67 #include "asterisk/utils.h"
68 #include "asterisk/tcptls.h"
69 #include "asterisk/http.h"
70 #include "asterisk/ast_version.h"
71 #include "asterisk/threadstorage.h"
72 #include "asterisk/linkedlists.h"
73 #include "asterisk/version.h"
74 #include "asterisk/term.h"
75 #include "asterisk/astobj2.h"
76 #include "asterisk/features.h"
77
78 enum error_type {
79         UNKNOWN_ACTION = 1,
80         UNKNOWN_CATEGORY,
81         UNSPECIFIED_CATEGORY,
82         UNSPECIFIED_ARGUMENT,
83         FAILURE_ALLOCATION,
84         FAILURE_DELCAT,
85         FAILURE_EMPTYCAT,
86         FAILURE_UPDATE,
87         FAILURE_DELETE,
88         FAILURE_APPEND
89 };
90
91
92 /*!
93  * Linked list of events.
94  * Global events are appended to the list by append_event().
95  * The usecount is the number of stored pointers to the element,
96  * excluding the list pointers. So an element that is only in
97  * the list has a usecount of 0, not 1.
98  *
99  * Clients have a pointer to the last event processed, and for each
100  * of these clients we track the usecount of the elements.
101  * If we have a pointer to an entry in the list, it is safe to navigate
102  * it forward because elements will not be deleted, but only appended.
103  * The worst that can happen is seeing the pointer still NULL.
104  *
105  * When the usecount of an element drops to 0, and the element is the
106  * first in the list, we can remove it. Removal is done within the
107  * main thread, which is woken up for the purpose.
108  *
109  * For simplicity of implementation, we make sure the list is never empty.
110  */
111 struct eventqent {
112         int usecount;           /*!< # of clients who still need the event */
113         int category;
114         unsigned int seq;       /*!< sequence number */
115         AST_LIST_ENTRY(eventqent) eq_next;
116         char eventdata[1];      /*!< really variable size, allocated by append_event() */
117 };
118
119 static AST_LIST_HEAD_STATIC(all_events, eventqent);
120
121 static int displayconnects = 1;
122 static int allowmultiplelogin = 1;
123 static int timestampevents;
124 static int httptimeout = 60;
125 static int manager_enabled = 0;
126 static int webmanager_enabled = 0;
127
128 static int block_sockets;
129 static int num_sessions;
130
131 static int manager_debug;       /*!< enable some debugging code in the manager */
132
133 /*! \brief
134  * Descriptor for a manager session, either on the AMI socket or over HTTP.
135  *
136  * \note
137  * AMI session have managerid == 0; the entry is created upon a connect,
138  * and destroyed with the socket.
139  * HTTP sessions have managerid != 0, the value is used as a search key
140  * to lookup sessions (using the mansession_id cookie).
141  */
142 #define MAX_BLACKLIST_CMD_LEN 2
143 static struct {
144         char *words[AST_MAX_CMD_LEN];
145 } command_blacklist[] = {
146         {{ "module", "load", NULL }},
147         {{ "module", "unload", NULL }},
148 };
149
150 struct mansession {
151         pthread_t ms_t;         /*!< Execution thread, basically useless */
152         ast_mutex_t __lock;     /*!< Thread lock -- don't use in action callbacks, it's already taken care of  */
153                                 /* XXX need to document which fields it is protecting */
154         struct sockaddr_in sin; /*!< address we are connecting from */
155         FILE *f;                /*!< fdopen() on the underlying fd */
156         int fd;                 /*!< descriptor used for output. Either the socket (AMI) or a temporary file (HTTP) */
157         int inuse;              /*!< number of HTTP sessions using this entry */
158         int needdestroy;        /*!< Whether an HTTP session should be destroyed */
159         pthread_t waiting_thread;       /*!< Sleeping thread using this descriptor */
160         uint32_t managerid;     /*!< Unique manager identifier, 0 for AMI sessions */
161         time_t sessionstart;    /*!< Session start time */
162         time_t sessiontimeout;  /*!< Session timeout if HTTP */
163         char username[80];      /*!< Logged in username */
164         char challenge[10];     /*!< Authentication challenge */
165         int authenticated;      /*!< Authentication status */
166         int readperm;           /*!< Authorization for reading */
167         int writeperm;          /*!< Authorization for writing */
168         char inbuf[1025];       /*!< Buffer */
169                                 /* we use the extra byte to add a '\0' and simplify parsing */
170         int inlen;              /*!< number of buffered bytes */
171         int send_events;        /*!<  XXX what ? */
172         struct eventqent *last_ev;      /*!< last event processed. */
173         int writetimeout;       /*!< Timeout for ast_carefulwrite() */
174         int pending_event;         /*!< Pending events indicator in case when waiting_thread is NULL */
175         AST_LIST_HEAD_NOLOCK(mansession_datastores, ast_datastore) datastores; /*!< Data stores on the session */
176         AST_LIST_ENTRY(mansession) list;
177 };
178
179 #define NEW_EVENT(m)    (AST_LIST_NEXT(m->last_ev, eq_next))
180
181 static AST_LIST_HEAD_STATIC(sessions, mansession);
182
183 /*! \brief user descriptor, as read from the config file.
184  *
185  * \note It is still missing some fields -- e.g. we can have multiple permit and deny
186  * lines which are not supported here, and readperm/writeperm/writetimeout
187  * are not stored.
188  */
189 struct ast_manager_user {
190         char username[80];
191         char *secret;
192         struct ast_ha *ha;              /*!< ACL setting */
193         int readperm;                   /*! Authorization for reading */
194         int writeperm;                  /*! Authorization for writing */
195         int writetimeout;               /*! Per user Timeout for ast_carefulwrite() */
196         int displayconnects;    /*!< XXX unused */
197         int keep;       /*!< mark entries created on a reload */
198         AST_RWLIST_ENTRY(ast_manager_user) list;
199 };
200
201 /*! \brief list of users found in the config file */
202 static AST_RWLIST_HEAD_STATIC(users, ast_manager_user);
203
204 /*! \brief list of actions registered */
205 static AST_RWLIST_HEAD_STATIC(actions, manager_action);
206
207 /*! \brief list of hooks registered */
208 static AST_RWLIST_HEAD_STATIC(manager_hooks, manager_custom_hook);
209
210 /*! \brief Add a custom hook to be called when an event is fired */
211 void ast_manager_register_hook(struct manager_custom_hook *hook)
212 {
213         AST_RWLIST_WRLOCK(&manager_hooks);
214         AST_RWLIST_INSERT_TAIL(&manager_hooks, hook, list);
215         AST_RWLIST_UNLOCK(&manager_hooks);
216         return;
217 }
218
219 /*! \brief Delete a custom hook to be called when an event is fired */
220 void ast_manager_unregister_hook(struct manager_custom_hook *hook)
221 {
222         AST_RWLIST_WRLOCK(&manager_hooks);
223         AST_RWLIST_REMOVE(&manager_hooks, hook, list);
224         AST_RWLIST_UNLOCK(&manager_hooks);
225         return;
226 }
227
228 /*! \brief
229  * Event list management functions.
230  * We assume that the event list always has at least one element,
231  * and the delete code will not remove the last entry even if the
232  * 
233  */
234 #if 0
235 static time_t __deb(time_t start, const char *msg)
236 {
237         time_t now = time(NULL);
238         ast_verbose("%4d th %p %s\n", (int)(now % 3600), pthread_self(), msg);
239         if (start != 0 && now - start > 5)
240                 ast_verbose("+++ WOW, %s took %d seconds\n", msg, (int)(now - start));
241         return now;
242 }
243
244 static void LOCK_EVENTS(void)
245 {
246         time_t start = __deb(0, "about to lock events");
247         AST_LIST_LOCK(&all_events);
248         __deb(start, "done lock events");
249 }
250
251 static void UNLOCK_EVENTS(void)
252 {
253         __deb(0, "about to unlock events");
254         AST_LIST_UNLOCK(&all_events);
255 }
256
257 static void LOCK_SESS(void)
258 {
259         time_t start = __deb(0, "about to lock sessions");
260         AST_LIST_LOCK(&sessions);
261         __deb(start, "done lock sessions");
262 }
263
264 static void UNLOCK_SESS(void)
265 {
266         __deb(0, "about to unlock sessions");
267         AST_LIST_UNLOCK(&sessions);
268 }
269 #endif
270
271 int check_manager_enabled()
272 {
273         return manager_enabled;
274 }
275
276 int check_webmanager_enabled()
277 {
278         return (webmanager_enabled && manager_enabled);
279 }
280
281 /*!
282  * Grab a reference to the last event, update usecount as needed.
283  * Can handle a NULL pointer.
284  */
285 static struct eventqent *grab_last(void)
286 {
287         struct eventqent *ret;
288
289         AST_LIST_LOCK(&all_events);
290         ret = AST_LIST_LAST(&all_events);
291         /* the list is never empty now, but may become so when
292          * we optimize it in the future, so be prepared.
293          */
294         if (ret)
295                 ast_atomic_fetchadd_int(&ret->usecount, 1);
296         AST_LIST_UNLOCK(&all_events);
297         return ret;
298 }
299
300 /*!
301  * Purge unused events. Remove elements from the head
302  * as long as their usecount is 0 and there is a next element.
303  */
304 static void purge_events(void)
305 {
306         struct eventqent *ev;
307
308         AST_LIST_LOCK(&all_events);
309         while ( (ev = AST_LIST_FIRST(&all_events)) &&
310             ev->usecount == 0 && AST_LIST_NEXT(ev, eq_next)) {
311                 AST_LIST_REMOVE_HEAD(&all_events, eq_next);
312                 ast_free(ev);
313         }
314         AST_LIST_UNLOCK(&all_events);
315 }
316
317 /*!
318  * helper functions to convert back and forth between
319  * string and numeric representation of set of flags
320  */
321 static struct permalias {
322         int num;
323         char *label;
324 } perms[] = {
325         { EVENT_FLAG_SYSTEM, "system" },
326         { EVENT_FLAG_CALL, "call" },
327         { EVENT_FLAG_LOG, "log" },
328         { EVENT_FLAG_VERBOSE, "verbose" },
329         { EVENT_FLAG_COMMAND, "command" },
330         { EVENT_FLAG_AGENT, "agent" },
331         { EVENT_FLAG_USER, "user" },
332         { EVENT_FLAG_CONFIG, "config" },
333         { EVENT_FLAG_DTMF, "dtmf" },
334         { EVENT_FLAG_REPORTING, "reporting" },
335         { EVENT_FLAG_CDR, "cdr" },
336         { EVENT_FLAG_DIALPLAN, "dialplan" },
337         { EVENT_FLAG_ORIGINATE, "originate" },
338         { -1, "all" },
339         { 0, "none" },
340 };
341
342 /*! \brief Convert authority code to a list of options */
343 static char *authority_to_str(int authority, struct ast_str **res)
344 {
345         int i;
346         char *sep = "";
347
348         (*res)->used = 0;
349         for (i = 0; i < ARRAY_LEN(perms) - 1; i++) {
350                 if (authority & perms[i].num) {
351                         ast_str_append(res, 0, "%s%s", sep, perms[i].label);
352                         sep = ",";
353                 }
354         }
355
356         if ((*res)->used == 0)  /* replace empty string with something sensible */
357                 ast_str_append(res, 0, "<none>");
358
359         return (*res)->str;
360 }
361
362 /*! Tells you if smallstr exists inside bigstr
363    which is delim by delim and uses no buf or stringsep
364    ast_instring("this|that|more","this",'|') == 1;
365
366    feel free to move this to app.c -anthm */
367 static int ast_instring(const char *bigstr, const char *smallstr, const char delim)
368 {
369         const char *val = bigstr, *next;
370
371         do {
372                 if ((next = strchr(val, delim))) {
373                         if (!strncmp(val, smallstr, (next - val)))
374                                 return 1;
375                         else
376                                 continue;
377                 } else
378                         return !strcmp(smallstr, val);
379         } while (*(val = (next + 1)));
380
381         return 0;
382 }
383
384 static int get_perm(const char *instr)
385 {
386         int x = 0, ret = 0;
387
388         if (!instr)
389                 return 0;
390
391         for (x = 0; x < ARRAY_LEN(perms); x++) {
392                 if (ast_instring(instr, perms[x].label, ','))
393                         ret |= perms[x].num;
394         }
395
396         return ret;
397 }
398
399 /*!
400  * A number returns itself, false returns 0, true returns all flags,
401  * other strings return the flags that are set.
402  */
403 static int strings_to_mask(const char *string)
404 {
405         const char *p;
406
407         if (ast_strlen_zero(string))
408                 return -1;
409
410         for (p = string; *p; p++)
411                 if (*p < '0' || *p > '9')
412                         break;
413         if (!p) /* all digits */
414                 return atoi(string);
415         if (ast_false(string))
416                 return 0;
417         if (ast_true(string)) { /* all permissions */
418                 int x, ret = 0;
419                 for (x = 0; x < ARRAY_LEN(perms); x++)
420                         ret |= perms[x].num;
421                 return ret;
422         }
423         return get_perm(string);
424 }
425
426 static int check_manager_session_inuse(const char *name)
427 {
428         struct mansession *session = NULL;
429
430         AST_LIST_LOCK(&sessions);
431         AST_LIST_TRAVERSE(&sessions, session, list) {
432                 if (!strcasecmp(session->username, name)) 
433                         break;
434         }
435         AST_LIST_UNLOCK(&sessions);
436
437         return session ? 1 : 0;
438 }
439
440
441 /*!
442  * lookup an entry in the list of registered users.
443  * must be called with the list lock held.
444  */
445 static struct ast_manager_user *get_manager_by_name_locked(const char *name)
446 {
447         struct ast_manager_user *user = NULL;
448
449         AST_RWLIST_TRAVERSE(&users, user, list)
450                 if (!strcasecmp(user->username, name))
451                         break;
452         return user;
453 }
454
455 /*! \brief Get displayconnects config option.
456  *  \param s manager session to get parameter from.
457  *  \return displayconnects config option value.
458  */
459 static int manager_displayconnects (struct mansession *s)
460 {
461         struct ast_manager_user *user = NULL;
462         int ret = 0;
463
464         AST_RWLIST_RDLOCK(&users);
465         if ((user = get_manager_by_name_locked (s->username)))
466                 ret = user->displayconnects;
467         AST_RWLIST_UNLOCK(&users);
468         
469         return ret;
470 }
471
472 static char *handle_showmancmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
473 {
474         struct manager_action *cur;
475         struct ast_str *authority;
476         int num, l, which;
477         char *ret = NULL;
478         switch (cmd) {
479         case CLI_INIT:
480                 e->command = "manager show command";
481                 e->usage = 
482                         "Usage: manager show command <actionname>\n"
483                         "       Shows the detailed description for a specific Asterisk manager interface command.\n";
484                 return NULL;
485         case CLI_GENERATE:
486                 l = strlen(a->word);
487                 which = 0;
488                 AST_RWLIST_RDLOCK(&actions);
489                 AST_RWLIST_TRAVERSE(&actions, cur, list) {
490                         if (!strncasecmp(a->word, cur->action, l) && ++which > a->n) {
491                                 ret = ast_strdup(cur->action);
492                                 break;  /* make sure we exit even if ast_strdup() returns NULL */
493                         }
494                 }
495                 AST_RWLIST_UNLOCK(&actions);
496                 return ret;
497         }
498         authority = ast_str_alloca(80);
499         if (a->argc != 4)
500                 return CLI_SHOWUSAGE;
501
502         AST_RWLIST_RDLOCK(&actions);
503         AST_RWLIST_TRAVERSE(&actions, cur, list) {
504                 for (num = 3; num < a->argc; num++) {
505                         if (!strcasecmp(cur->action, a->argv[num])) {
506                                 ast_cli(a->fd, "Action: %s\nSynopsis: %s\nPrivilege: %s\n%s\n",
507                                         cur->action, cur->synopsis,
508                                         authority_to_str(cur->authority, &authority),
509                                         S_OR(cur->description, ""));
510                         }
511                 }
512         }
513         AST_RWLIST_UNLOCK(&actions);
514
515         return CLI_SUCCESS;
516 }
517
518 static char *handle_mandebug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
519 {
520         switch (cmd) {
521         case CLI_INIT:
522                 e->command = "manager set debug [on|off]";
523                 e->usage = "Usage: manager set debug [on|off]\n Show, enable, disable debugging of the manager code.\n";
524                 return NULL;
525         case CLI_GENERATE:
526                 return NULL;    
527         }
528         if (a->argc == 3)
529                 ast_cli(a->fd, "manager debug is %s\n", manager_debug? "on" : "off");
530         else if (a->argc == 4) {
531                 if (!strcasecmp(a->argv[3], "on"))
532                         manager_debug = 1;
533                 else if (!strcasecmp(a->argv[3], "off"))
534                         manager_debug = 0;
535                 else
536                         return CLI_SHOWUSAGE;
537         }
538         return CLI_SUCCESS;
539 }
540
541 static char *handle_showmanager(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
542 {
543         struct ast_manager_user *user = NULL;
544         int l, which;
545         char *ret = NULL;
546         struct ast_str *rauthority = ast_str_alloca(80);
547         struct ast_str *wauthority = ast_str_alloca(80);
548
549         switch (cmd) {
550         case CLI_INIT:
551                 e->command = "manager show user";
552                 e->usage = 
553                         " Usage: manager show user <user>\n"
554                         "        Display all information related to the manager user specified.\n";
555                 return NULL;
556         case CLI_GENERATE:
557                 l = strlen(a->word);
558                 which = 0;
559                 if (a->pos != 3)
560                         return NULL;
561                 AST_RWLIST_RDLOCK(&users);
562                 AST_RWLIST_TRAVERSE(&users, user, list) {
563                         if ( !strncasecmp(a->word, user->username, l) && ++which > a->n ) {
564                                 ret = ast_strdup(user->username);
565                                 break;
566                         }
567                 }
568                 AST_RWLIST_UNLOCK(&users);
569                 return ret;
570         }
571
572         if (a->argc != 4)
573                 return CLI_SHOWUSAGE;
574
575         AST_RWLIST_RDLOCK(&users);
576
577         if (!(user = get_manager_by_name_locked(a->argv[3]))) {
578                 ast_cli(a->fd, "There is no manager called %s\n", a->argv[3]);
579                 AST_RWLIST_UNLOCK(&users);
580                 return CLI_SUCCESS;
581         }
582
583         ast_cli(a->fd, "\n");
584         ast_cli(a->fd,
585                 "       username: %s\n"
586                 "         secret: %s\n"
587                 "            acl: %s\n"
588                 "      read perm: %s\n"
589                 "     write perm: %s\n"
590                 "displayconnects: %s\n",
591                 (user->username ? user->username : "(N/A)"),
592                 (user->secret ? "<Set>" : "(N/A)"),
593                 (user->ha ? "yes" : "no"),
594                 authority_to_str(user->readperm, &rauthority),
595                 authority_to_str(user->writeperm, &wauthority),
596                 (user->displayconnects ? "yes" : "no"));
597
598         AST_RWLIST_UNLOCK(&users);
599
600         return CLI_SUCCESS;
601 }
602
603
604 static char *handle_showmanagers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
605 {
606         struct ast_manager_user *user = NULL;
607         int count_amu = 0;
608         switch (cmd) {
609         case CLI_INIT:
610                 e->command = "manager show users";
611                 e->usage = 
612                         "Usage: manager show users\n"
613                         "       Prints a listing of all managers that are currently configured on that\n"
614                         " system.\n";
615                 return NULL;
616         case CLI_GENERATE:
617                 return NULL;
618         }
619         if (a->argc != 3)
620                 return CLI_SHOWUSAGE;
621
622         AST_RWLIST_RDLOCK(&users);
623
624         /* If there are no users, print out something along those lines */
625         if (AST_RWLIST_EMPTY(&users)) {
626                 ast_cli(a->fd, "There are no manager users.\n");
627                 AST_RWLIST_UNLOCK(&users);
628                 return CLI_SUCCESS;
629         }
630
631         ast_cli(a->fd, "\nusername\n--------\n");
632
633         AST_RWLIST_TRAVERSE(&users, user, list) {
634                 ast_cli(a->fd, "%s\n", user->username);
635                 count_amu++;
636         }
637
638         AST_RWLIST_UNLOCK(&users);
639
640         ast_cli(a->fd, "-------------------\n");
641         ast_cli(a->fd, "%d manager users configured.\n", count_amu);
642
643         return CLI_SUCCESS;
644 }
645
646
647 /*! \brief  CLI command  manager list commands */
648 static char *handle_showmancmds(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
649 {
650         struct manager_action *cur;
651         struct ast_str *authority;
652 #define HSMC_FORMAT "  %-15.15s  %-15.15s  %-55.55s\n"
653         switch (cmd) {
654         case CLI_INIT:
655                 e->command = "manager show commands";
656                 e->usage = 
657                         "Usage: manager show commands\n"
658                         "       Prints a listing of all the available Asterisk manager interface commands.\n";
659                 return NULL;
660         case CLI_GENERATE:
661                 return NULL;    
662         }       
663         authority = ast_str_alloca(80);
664         ast_cli(a->fd, HSMC_FORMAT, "Action", "Privilege", "Synopsis");
665         ast_cli(a->fd, HSMC_FORMAT, "------", "---------", "--------");
666
667         AST_RWLIST_RDLOCK(&actions);
668         AST_RWLIST_TRAVERSE(&actions, cur, list)
669                 ast_cli(a->fd, HSMC_FORMAT, cur->action, authority_to_str(cur->authority, &authority), cur->synopsis);
670         AST_RWLIST_UNLOCK(&actions);
671
672         return CLI_SUCCESS;
673 }
674
675 /*! \brief CLI command manager list connected */
676 static char *handle_showmanconn(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
677 {
678         struct mansession *s;
679         time_t now = time(NULL);
680 #define HSMCONN_FORMAT1 "  %-15.15s  %-15.15s  %-10.10s  %-10.10s  %-8.8s  %-8.8s  %-5.5s  %-5.5s\n"
681 #define HSMCONN_FORMAT2 "  %-15.15s  %-15.15s  %-10d  %-10d  %-8d  %-8d  %-5.5d  %-5.5d\n"
682         int count = 0;
683         switch (cmd) {
684         case CLI_INIT:
685                 e->command = "manager show connected";
686                 e->usage = 
687                         "Usage: manager show connected\n"
688                         "       Prints a listing of the users that are currently connected to the\n"
689                         "Asterisk manager interface.\n";
690                 return NULL;
691         case CLI_GENERATE:
692                 return NULL;    
693         }
694
695         ast_cli(a->fd, HSMCONN_FORMAT1, "Username", "IP Address", "Start", "Elapsed", "FileDes", "HttpCnt", "Read", "Write");
696
697         AST_LIST_LOCK(&sessions);
698         AST_LIST_TRAVERSE(&sessions, s, list) {
699                 ast_cli(a->fd, HSMCONN_FORMAT2, s->username, ast_inet_ntoa(s->sin.sin_addr), (int)(s->sessionstart), (int)(now - s->sessionstart), s->fd, s->inuse, s->readperm, s->writeperm);
700                 count++;
701         }
702         AST_LIST_UNLOCK(&sessions);
703
704         ast_cli(a->fd, "%d users connected.\n", count);
705
706         return CLI_SUCCESS;
707 }
708
709 /*! \brief CLI command manager list eventq */
710 /* Should change to "manager show connected" */
711 static char *handle_showmaneventq(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
712 {
713         struct eventqent *s;
714         switch (cmd) {
715         case CLI_INIT:
716                 e->command = "manager show eventq";
717                 e->usage = 
718                         "Usage: manager show eventq\n"
719                         "       Prints a listing of all events pending in the Asterisk manger\n"
720                         "event queue.\n";
721                 return NULL;
722         case CLI_GENERATE:
723                 return NULL;
724         }
725         AST_LIST_LOCK(&all_events);
726         AST_LIST_TRAVERSE(&all_events, s, eq_next) {
727                 ast_cli(a->fd, "Usecount: %d\n", s->usecount);
728                 ast_cli(a->fd, "Category: %d\n", s->category);
729                 ast_cli(a->fd, "Event:\n%s", s->eventdata);
730         }
731         AST_LIST_UNLOCK(&all_events);
732
733         return CLI_SUCCESS;
734 }
735
736 /*! \brief CLI command manager reload */
737 static char *handle_manager_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
738 {
739         switch (cmd) {
740         case CLI_INIT:
741                 e->command = "manager reload";
742                 e->usage =
743                         "Usage: manager reload\n"
744                         "       Reloads the manager configuration.\n";
745                 return NULL;
746         case CLI_GENERATE:
747                 return NULL;
748         }
749         if (a->argc > 2)
750                 return CLI_SHOWUSAGE;
751         reload_manager();
752         return CLI_SUCCESS;
753 }
754
755
756 static struct ast_cli_entry cli_manager[] = {
757         AST_CLI_DEFINE(handle_showmancmd, "Show a manager interface command"),
758         AST_CLI_DEFINE(handle_showmancmds, "List manager interface commands"),
759         AST_CLI_DEFINE(handle_showmanconn, "List connected manager interface users"),
760         AST_CLI_DEFINE(handle_showmaneventq, "List manager interface queued events"),
761         AST_CLI_DEFINE(handle_showmanagers, "List configured manager users"),
762         AST_CLI_DEFINE(handle_showmanager, "Display information on a specific manager user"),
763         AST_CLI_DEFINE(handle_mandebug, "Show, enable, disable debugging of the manager code"),
764         AST_CLI_DEFINE(handle_manager_reload, "Reload manager configurations"),
765 };
766
767 /*
768  * Decrement the usecount for the event; if it goes to zero,
769  * (why check for e->next ?) wakeup the
770  * main thread, which is in charge of freeing the record.
771  * Returns the next record.
772  */
773 static struct eventqent *unref_event(struct eventqent *e)
774 {
775         ast_atomic_fetchadd_int(&e->usecount, -1);
776         return AST_LIST_NEXT(e, eq_next);
777 }
778
779 static void ref_event(struct eventqent *e)
780 {
781         ast_atomic_fetchadd_int(&e->usecount, 1);
782 }
783
784 /*
785  * destroy a session, leaving the usecount
786  */
787 static void free_session(struct mansession *s)
788 {
789         struct eventqent *eqe = s->last_ev;
790         struct ast_datastore *datastore;
791
792         /* Get rid of each of the data stores on the session */
793         while ((datastore = AST_LIST_REMOVE_HEAD(&s->datastores, entry))) {
794                 /* Free the data store */
795                 ast_datastore_free(datastore);
796         }
797
798         if (s->f != NULL)
799                 fclose(s->f);
800         ast_mutex_destroy(&s->__lock);
801         ast_free(s);
802         unref_event(eqe);
803 }
804
805 static void destroy_session(struct mansession *s)
806 {
807         AST_LIST_LOCK(&sessions);
808         AST_LIST_REMOVE(&sessions, s, list);
809         ast_atomic_fetchadd_int(&num_sessions, -1);
810         free_session(s);
811         AST_LIST_UNLOCK(&sessions);
812 }
813
814 /*
815  * Generic function to return either the first or the last matching header
816  * from a list of variables, possibly skipping empty strings.
817  * At the moment there is only one use of this function in this file,
818  * so we make it static.
819  */
820 #define GET_HEADER_FIRST_MATCH  0
821 #define GET_HEADER_LAST_MATCH   1
822 #define GET_HEADER_SKIP_EMPTY   2
823 static const char *__astman_get_header(const struct message *m, char *var, int mode)
824 {
825         int x, l = strlen(var);
826         const char *result = "";
827
828         for (x = 0; x < m->hdrcount; x++) {
829                 const char *h = m->headers[x];
830                 if (!strncasecmp(var, h, l) && h[l] == ':' && h[l+1] == ' ') {
831                         const char *value = h + l + 2;
832                         /* found a potential candidate */
833                         if (mode & GET_HEADER_SKIP_EMPTY && ast_strlen_zero(value))
834                                 continue;       /* not interesting */
835                         if (mode & GET_HEADER_LAST_MATCH)
836                                 result = value; /* record the last match so far */
837                         else
838                                 return value;
839                 }
840         }
841
842         return "";
843 }
844
845 /*
846  * Return the first matching variable from an array.
847  * This is the legacy function and is implemented in therms of
848  * __astman_get_header().
849  */
850 const char *astman_get_header(const struct message *m, char *var)
851 {
852         return __astman_get_header(m, var, GET_HEADER_FIRST_MATCH);
853 }
854
855
856 struct ast_variable *astman_get_variables(const struct message *m)
857 {
858         int varlen, x, y;
859         struct ast_variable *head = NULL, *cur;
860
861         AST_DECLARE_APP_ARGS(args,
862                 AST_APP_ARG(vars)[32];
863         );
864
865         varlen = strlen("Variable: ");
866
867         for (x = 0; x < m->hdrcount; x++) {
868                 char *parse, *var, *val;
869
870                 if (strncasecmp("Variable: ", m->headers[x], varlen))
871                         continue;
872                 parse = ast_strdupa(m->headers[x] + varlen);
873
874                 AST_STANDARD_APP_ARGS(args, parse);
875                 if (!args.argc)
876                         continue;
877                 for (y = 0; y < args.argc; y++) {
878                         if (!args.vars[y])
879                                 continue;
880                         var = val = ast_strdupa(args.vars[y]);
881                         strsep(&val, "=");
882                         if (!val || ast_strlen_zero(var))
883                                 continue;
884                         cur = ast_variable_new(var, val, "");
885                         cur->next = head;
886                         head = cur;
887                 }
888         }
889
890         return head;
891 }
892
893 /*!
894  * helper function to send a string to the socket.
895  * Return -1 on error (e.g. buffer full).
896  */
897 static int send_string(struct mansession *s, char *string)
898 {
899         int len = strlen(string);       /* residual length */
900         char *src = string;
901         struct timeval start = ast_tvnow();
902         int n = 0;
903
904         for (;;) {
905                 int elapsed;
906                 struct pollfd fd;
907                 n = fwrite(src, 1, len, s->f);  /* try to write the string, non blocking */
908                 if (n == len /* ok */ || n < 0 /* error */)
909                         break;
910                 len -= n;       /* skip already written data */
911                 src += n;
912                 fd.fd = s->fd;
913                 fd.events = POLLOUT;
914                 n = -1;         /* error marker */
915                 elapsed = ast_tvdiff_ms(ast_tvnow(), start);
916                 if (elapsed > s->writetimeout)
917                         break;
918                 if (poll(&fd, 1, s->writetimeout - elapsed) < 1)
919                         break;
920         }
921         fflush(s->f);
922         return n < 0 ? -1 : 0;
923 }
924
925 /*!
926  * \brief thread local buffer for astman_append
927  *
928  * \note This can not be defined within the astman_append() function
929  *       because it declares a couple of functions that get used to
930  *       initialize the thread local storage key.
931  */
932 AST_THREADSTORAGE(astman_append_buf);
933 /*! \brief initial allocated size for the astman_append_buf */
934 #define ASTMAN_APPEND_BUF_INITSIZE   256
935
936 /*!
937  * utility functions for creating AMI replies
938  */
939 void astman_append(struct mansession *s, const char *fmt, ...)
940 {
941         va_list ap;
942         struct ast_str *buf;
943
944         if (!(buf = ast_str_thread_get(&astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE)))
945                 return;
946
947         va_start(ap, fmt);
948         ast_str_set_va(&buf, 0, fmt, ap);
949         va_end(ap);
950
951         if (s->f != NULL)
952                 send_string(s, buf->str);
953         else
954                 ast_verbose("fd == -1 in astman_append, should not happen\n");
955 }
956
957 /*! \note NOTE: XXX this comment is unclear and possibly wrong.
958    Callers of astman_send_error(), astman_send_response() or astman_send_ack() must EITHER
959    hold the session lock _or_ be running in an action callback (in which case s->busy will
960    be non-zero). In either of these cases, there is no need to lock-protect the session's
961    fd, since no other output will be sent (events will be queued), and no input will
962    be read until either the current action finishes or get_input() obtains the session
963    lock.
964  */
965
966 /*! \brief send a response with an optional message,
967  * and terminate it with an empty line.
968  * m is used only to grab the 'ActionID' field.
969  *
970  * Use the explicit constant MSG_MOREDATA to remove the empty line.
971  * XXX MSG_MOREDATA should go to a header file.
972  */
973 #define MSG_MOREDATA    ((char *)astman_send_response)
974 static void astman_send_response_full(struct mansession *s, const struct message *m, char *resp, char *msg, char *listflag)
975 {
976         const char *id = astman_get_header(m, "ActionID");
977
978         astman_append(s, "Response: %s\r\n", resp);
979         if (!ast_strlen_zero(id))
980                 astman_append(s, "ActionID: %s\r\n", id);
981         if (listflag)
982                 astman_append(s, "Eventlist: %s\r\n", listflag);        /* Start, complete, cancelled */
983         if (msg == MSG_MOREDATA)
984                 return;
985         else if (msg)
986                 astman_append(s, "Message: %s\r\n\r\n", msg);
987         else
988                 astman_append(s, "\r\n");
989 }
990
991 void astman_send_response(struct mansession *s, const struct message *m, char *resp, char *msg)
992 {
993         astman_send_response_full(s, m, resp, msg, NULL);
994 }
995
996 void astman_send_error(struct mansession *s, const struct message *m, char *error)
997 {
998         astman_send_response_full(s, m, "Error", error, NULL);
999 }
1000
1001 void astman_send_ack(struct mansession *s, const struct message *m, char *msg)
1002 {
1003         astman_send_response_full(s, m, "Success", msg, NULL);
1004 }
1005
1006 static void astman_start_ack(struct mansession *s, const struct message *m)
1007 {
1008         astman_send_response_full(s, m, "Success", MSG_MOREDATA, NULL);
1009 }
1010
1011 void astman_send_listack(struct mansession *s, const struct message *m, char *msg, char *listflag)
1012 {
1013         astman_send_response_full(s, m, "Success", msg, listflag);
1014 }
1015
1016
1017 /*! \brief
1018    Rather than braindead on,off this now can also accept a specific int mask value
1019    or a ',' delim list of mask strings (the same as manager.conf) -anthm
1020 */
1021 static int set_eventmask(struct mansession *s, const char *eventmask)
1022 {
1023         int maskint = strings_to_mask(eventmask);
1024
1025         ast_mutex_lock(&s->__lock);
1026         if (maskint >= 0)
1027                 s->send_events = maskint;
1028         ast_mutex_unlock(&s->__lock);
1029
1030         return maskint;
1031 }
1032
1033 /*
1034  * Here we start with action_ handlers for AMI actions,
1035  * and the internal functions used by them.
1036  * Generally, the handlers are called action_foo()
1037  */
1038
1039 /* helper function for action_login() */
1040 static int authenticate(struct mansession *s, const struct message *m)
1041 {
1042         const char *username = astman_get_header(m, "Username");
1043         const char *password = astman_get_header(m, "Secret");
1044         int error = -1;
1045         struct ast_manager_user *user = NULL;
1046
1047         if (ast_strlen_zero(username))  /* missing username */
1048                 return -1;
1049
1050         /* locate user in locked state */
1051         AST_RWLIST_WRLOCK(&users);
1052
1053         if (!(user = get_manager_by_name_locked(username))) {
1054                 ast_log(LOG_NOTICE, "%s tried to authenticate with nonexistent user '%s'\n", ast_inet_ntoa(s->sin.sin_addr), username);
1055         } else if (user->ha && !ast_apply_ha(user->ha, &(s->sin))) {
1056                 ast_log(LOG_NOTICE, "%s failed to pass IP ACL as '%s'\n", ast_inet_ntoa(s->sin.sin_addr), username);
1057         } else if (!strcasecmp(astman_get_header(m, "AuthType"), "MD5")) {
1058                 const char *key = astman_get_header(m, "Key");
1059                 if (!ast_strlen_zero(key) && !ast_strlen_zero(s->challenge) && user->secret) {
1060                         int x;
1061                         int len = 0;
1062                         char md5key[256] = "";
1063                         struct MD5Context md5;
1064                         unsigned char digest[16];
1065
1066                         MD5Init(&md5);
1067                         MD5Update(&md5, (unsigned char *) s->challenge, strlen(s->challenge));
1068                         MD5Update(&md5, (unsigned char *) user->secret, strlen(user->secret));
1069                         MD5Final(digest, &md5);
1070                         for (x = 0; x < 16; x++)
1071                                 len += sprintf(md5key + len, "%2.2x", digest[x]);
1072                         if (!strcmp(md5key, key))
1073                                 error = 0;
1074                 } else {
1075                         ast_debug(1, "MD5 authentication is not possible.  challenge: '%s'\n", 
1076                                 S_OR(s->challenge, ""));
1077                 }
1078         } else if (password && user->secret && !strcmp(password, user->secret))
1079                 error = 0;
1080
1081         if (error) {
1082                 ast_log(LOG_NOTICE, "%s failed to authenticate as '%s'\n", ast_inet_ntoa(s->sin.sin_addr), username);
1083                 AST_RWLIST_UNLOCK(&users);
1084                 return -1;
1085         }
1086
1087         /* auth complete */
1088         
1089         ast_copy_string(s->username, username, sizeof(s->username));
1090         s->readperm = user->readperm;
1091         s->writeperm = user->writeperm;
1092         s->writetimeout = user->writetimeout;
1093         s->sessionstart = time(NULL);
1094         set_eventmask(s, astman_get_header(m, "Events"));
1095         
1096         AST_RWLIST_UNLOCK(&users);
1097         return 0;
1098 }
1099
1100 /*! \brief Manager PING */
1101 static char mandescr_ping[] =
1102 "Description: A 'Ping' action will ellicit a 'Pong' response.  Used to keep the\n"
1103 "  manager connection open.\n"
1104 "Variables: NONE\n";
1105
1106 static int action_ping(struct mansession *s, const struct message *m)
1107 {
1108         astman_append(s, "Response: Success\r\n"
1109                          "Ping: Pong\r\n");
1110         return 0;
1111 }
1112
1113 static char mandescr_getconfig[] =
1114 "Description: A 'GetConfig' action will dump the contents of a configuration\n"
1115 "file by category and contents or optionally by specified category only.\n"
1116 "Variables: (Names marked with * are required)\n"
1117 "   *Filename: Configuration filename (e.g. foo.conf)\n"
1118 "   Category: Category in configuration file\n";
1119
1120 static int action_getconfig(struct mansession *s, const struct message *m)
1121 {
1122         struct ast_config *cfg;
1123         const char *fn = astman_get_header(m, "Filename");
1124         const char *category = astman_get_header(m, "Category");
1125         int catcount = 0;
1126         int lineno = 0;
1127         char *cur_category = NULL;
1128         struct ast_variable *v;
1129         struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
1130
1131         if (ast_strlen_zero(fn)) {
1132                 astman_send_error(s, m, "Filename not specified");
1133                 return 0;
1134         }
1135         cfg = ast_config_load2(fn, "manager", config_flags);
1136         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
1137                 astman_send_error(s, m, "Config file not found");
1138                 return 0;
1139         }
1140
1141         astman_start_ack(s, m);
1142         while ((cur_category = ast_category_browse(cfg, cur_category))) {
1143                 if (ast_strlen_zero(category) || (!ast_strlen_zero(category) && !strcmp(category, cur_category))) {
1144                         lineno = 0;
1145                         astman_append(s, "Category-%06d: %s\r\n", catcount, cur_category);
1146                         for (v = ast_variable_browse(cfg, cur_category); v; v = v->next)
1147                                 astman_append(s, "Line-%06d-%06d: %s=%s\r\n", catcount, lineno++, v->name, v->value);
1148                         catcount++;
1149                 }
1150         }
1151         if (!ast_strlen_zero(category) && catcount == 0) /* TODO: actually, a config with no categories doesn't even get loaded */
1152                 astman_append(s, "No categories found");
1153         ast_config_destroy(cfg);
1154         astman_append(s, "\r\n");
1155
1156         return 0;
1157 }
1158
1159 static char mandescr_listcategories[] =
1160 "Description: A 'ListCategories' action will dump the categories in\n"
1161 "a given file.\n"
1162 "Variables:\n"
1163 "   Filename: Configuration filename (e.g. foo.conf)\n";
1164
1165 static int action_listcategories(struct mansession *s, const struct message *m)
1166 {
1167         struct ast_config *cfg;
1168         const char *fn = astman_get_header(m, "Filename");
1169         char *category = NULL;
1170         struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
1171         int catcount = 0;
1172
1173         if (ast_strlen_zero(fn)) {
1174                 astman_send_error(s, m, "Filename not specified");
1175                 return 0;
1176         }
1177         if (!(cfg = ast_config_load2(fn, "manager", config_flags))) {
1178                 astman_send_error(s, m, "Config file not found or file has invalid syntax");
1179                 return 0;
1180         }
1181         astman_start_ack(s, m);
1182         while ((category = ast_category_browse(cfg, category))) {
1183                 astman_append(s, "Category-%06d: %s\r\n", catcount, category);
1184                 catcount++;
1185         }
1186         if (catcount == 0) /* TODO: actually, a config with no categories doesn't even get loaded */
1187                 astman_append(s, "Error: no categories found");
1188         ast_config_destroy(cfg);
1189         astman_append(s, "\r\n");
1190
1191         return 0;
1192 }
1193
1194
1195         
1196
1197 /*! The amount of space in out must be at least ( 2 * strlen(in) + 1 ) */
1198 static void json_escape(char *out, const char *in)
1199 {
1200         for (; *in; in++) {
1201                 if (*in == '\\' || *in == '\"')
1202                         *out++ = '\\';
1203                 *out++ = *in;
1204         }
1205         *out = '\0';
1206 }
1207
1208 static char mandescr_getconfigjson[] =
1209 "Description: A 'GetConfigJSON' action will dump the contents of a configuration\n"
1210 "file by category and contents in JSON format.  This only makes sense to be used\n"
1211 "using rawman over the HTTP interface.\n"
1212 "Variables:\n"
1213 "   Filename: Configuration filename (e.g. foo.conf)\n";
1214
1215 static int action_getconfigjson(struct mansession *s, const struct message *m)
1216 {
1217         struct ast_config *cfg;
1218         const char *fn = astman_get_header(m, "Filename");
1219         char *category = NULL;
1220         struct ast_variable *v;
1221         int comma1 = 0;
1222         char *buf = NULL;
1223         unsigned int buf_len = 0;
1224         struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
1225
1226         if (ast_strlen_zero(fn)) {
1227                 astman_send_error(s, m, "Filename not specified");
1228                 return 0;
1229         }
1230
1231         if (!(cfg = ast_config_load2(fn, "manager", config_flags))) {
1232                 astman_send_error(s, m, "Config file not found");
1233                 return 0;
1234         }
1235
1236         buf_len = 512;
1237         buf = alloca(buf_len);
1238
1239         astman_start_ack(s, m);
1240         astman_append(s, "JSON: {");
1241         while ((category = ast_category_browse(cfg, category))) {
1242                 int comma2 = 0;
1243                 if (buf_len < 2 * strlen(category) + 1) {
1244                         buf_len *= 2;
1245                         buf = alloca(buf_len);
1246                 }
1247                 json_escape(buf, category);
1248                 astman_append(s, "%s\"%s\":[", comma1 ? "," : "", buf);
1249                 if (!comma1)
1250                         comma1 = 1;
1251                 for (v = ast_variable_browse(cfg, category); v; v = v->next) {
1252                         if (comma2)
1253                                 astman_append(s, ",");
1254                         if (buf_len < 2 * strlen(v->name) + 1) {
1255                                 buf_len *= 2;
1256                                 buf = alloca(buf_len);
1257                         }
1258                         json_escape(buf, v->name);
1259                         astman_append(s, "\"%s", buf);
1260                         if (buf_len < 2 * strlen(v->value) + 1) {
1261                                 buf_len *= 2;
1262                                 buf = alloca(buf_len);
1263                         }
1264                         json_escape(buf, v->value);
1265                         astman_append(s, "%s\"", buf);
1266                         if (!comma2)
1267                                 comma2 = 1;
1268                 }
1269                 astman_append(s, "]");
1270         }
1271         astman_append(s, "}\r\n\r\n");
1272
1273         ast_config_destroy(cfg);
1274
1275         return 0;
1276 }
1277
1278 /* helper function for action_updateconfig */
1279 static enum error_type handle_updates(struct mansession *s, const struct message *m, struct ast_config *cfg, const char *dfn)
1280 {
1281         int x;
1282         char hdr[40];
1283         const char *action, *cat, *var, *value, *match, *line;
1284         struct ast_category *category;
1285         struct ast_variable *v;
1286         struct ast_str *str1 = ast_str_create(16), *str2 = ast_str_create(16);
1287         enum error_type result = 0;
1288
1289         for (x = 0; x < 100000; x++) {
1290                 unsigned int object = 0;
1291
1292                 snprintf(hdr, sizeof(hdr), "Action-%06d", x);
1293                 action = astman_get_header(m, hdr);
1294                 if (ast_strlen_zero(action))
1295                         break;
1296                 snprintf(hdr, sizeof(hdr), "Cat-%06d", x);
1297                 cat = astman_get_header(m, hdr);
1298                 snprintf(hdr, sizeof(hdr), "Var-%06d", x);
1299                 var = astman_get_header(m, hdr);
1300                 snprintf(hdr, sizeof(hdr), "Value-%06d", x);
1301                 value = astman_get_header(m, hdr);
1302
1303                 if (!ast_strlen_zero(value) && *value == '>') {
1304                         object = 1;
1305                         value++;
1306                 }
1307                 snprintf(hdr, sizeof(hdr), "Match-%06d", x);
1308                 match = astman_get_header(m, hdr);
1309                 snprintf(hdr, sizeof(hdr), "Line-%06d", x);
1310                 line = astman_get_header(m, hdr);
1311                 if (!strcasecmp(action, "newcat")) {
1312                         if (ast_strlen_zero(cat)) {
1313                                 result = UNSPECIFIED_CATEGORY;
1314                                 break;
1315                         }
1316                         if (!(category = ast_category_new(cat, dfn, -1))) {
1317                                 result = FAILURE_ALLOCATION;
1318                                 break;
1319                         }
1320                         if (ast_strlen_zero(match)) {
1321                                 ast_category_append(cfg, category);
1322                         } else
1323                                 ast_category_insert(cfg, category, match);
1324                 } else if (!strcasecmp(action, "renamecat")) {
1325                         if (ast_strlen_zero(cat) || ast_strlen_zero(value)) {
1326                                 result = UNSPECIFIED_ARGUMENT;
1327                                 break;
1328                         }
1329                         if (!(category = ast_category_get(cfg, cat))) {
1330                                 result = UNKNOWN_CATEGORY;
1331                                 break;
1332                         }
1333                         ast_category_rename(category, value);
1334                 } else if (!strcasecmp(action, "delcat")) {
1335                         if (ast_strlen_zero(cat)) {
1336                                 result = UNSPECIFIED_CATEGORY;
1337                                 break;
1338                         }
1339                         if (ast_category_delete(cfg, cat)) {
1340                                 result = FAILURE_DELCAT;
1341                                 break;
1342                         }
1343                 } else if (!strcasecmp(action, "emptycat")) {
1344                         if (ast_strlen_zero(cat)) {
1345                                 result = UNSPECIFIED_CATEGORY;
1346                                 break;
1347                         }
1348                         if (ast_category_empty(cfg, cat)) {
1349                                 result = FAILURE_EMPTYCAT;
1350                                 break;
1351                         }
1352                 } else if (!strcasecmp(action, "update")) {
1353                         if (ast_strlen_zero(cat) || ast_strlen_zero(var)) {
1354                                 result = UNSPECIFIED_ARGUMENT;
1355                                 break;
1356                         }
1357                         if (!(category = ast_category_get(cfg,cat))) {
1358                                 result = UNKNOWN_CATEGORY;
1359                                 break;
1360                         }
1361                         if (ast_variable_update(category, var, value, match, object)) {
1362                                 result = FAILURE_UPDATE;
1363                                 break;
1364                         }
1365                 } else if (!strcasecmp(action, "delete")) {
1366                         if (ast_strlen_zero(cat) || (ast_strlen_zero(var) && ast_strlen_zero(line))) {
1367                                 result = UNSPECIFIED_ARGUMENT;
1368                                 break;
1369                         }
1370                         if (!(category = ast_category_get(cfg, cat))) {
1371                                 result = UNKNOWN_CATEGORY;
1372                                 break;
1373                         }
1374                         if (ast_variable_delete(category, var, match, line)) {
1375                                 result = FAILURE_DELETE;
1376                                 break;
1377                         }
1378                 } else if (!strcasecmp(action, "append")) {
1379                         if (ast_strlen_zero(cat) || ast_strlen_zero(var)) {
1380                                 result = UNSPECIFIED_ARGUMENT;
1381                                 break;
1382                         }
1383                         if (!(category = ast_category_get(cfg, cat))) {
1384                                 result = UNKNOWN_CATEGORY;      
1385                                 break;
1386                         }
1387                         if (!(v = ast_variable_new(var, value, dfn))) {
1388                                 result = FAILURE_ALLOCATION;
1389                                 break;
1390                         }
1391                         if (object || (match && !strcasecmp(match, "object")))
1392                                 v->object = 1;
1393                         ast_variable_append(category, v);
1394                 } else if (!strcasecmp(action, "insert")) {
1395                         if (ast_strlen_zero(cat) || ast_strlen_zero(var) || ast_strlen_zero(line)) {
1396                                 result = UNSPECIFIED_ARGUMENT;
1397                                 break;
1398                         }
1399                         if (!(category = ast_category_get(cfg, cat))) {
1400                                 result = UNKNOWN_CATEGORY;
1401                                 break;
1402                         }
1403                         if (!(v = ast_variable_new(var, value, dfn))) {
1404                                 result = FAILURE_ALLOCATION;
1405                                 break;
1406                         }
1407                         ast_variable_insert(category, v, line);
1408                 }
1409                 else {
1410                         ast_log(LOG_WARNING, "Action-%06d: %s not handled\n", x, action);
1411                         result = UNKNOWN_ACTION;
1412                         break;
1413                 }
1414         }
1415         ast_free(str1);
1416         ast_free(str2);
1417         return result;
1418 }
1419
1420 static char mandescr_updateconfig[] =
1421 "Description: A 'UpdateConfig' action will modify, create, or delete\n"
1422 "configuration elements in Asterisk configuration files.\n"
1423 "Variables (X's represent 6 digit number beginning with 000000):\n"
1424 "   SrcFilename:   Configuration filename to read(e.g. foo.conf)\n"
1425 "   DstFilename:   Configuration filename to write(e.g. foo.conf)\n"
1426 "   Reload:        Whether or not a reload should take place (or name of specific module)\n"
1427 "   Action-XXXXXX: Action to Take (NewCat,RenameCat,DelCat,EmptyCat,Update,Delete,Append,Insert)\n"
1428 "   Cat-XXXXXX:    Category to operate on\n"
1429 "   Var-XXXXXX:    Variable to work on\n"
1430 "   Value-XXXXXX:  Value to work on\n"
1431 "   Match-XXXXXX:  Extra match required to match line\n"
1432 "   Line-XXXXXX:   Line in category to operate on (used with delete and insert actions)\n";
1433
1434 static int action_updateconfig(struct mansession *s, const struct message *m)
1435 {
1436         struct ast_config *cfg;
1437         const char *sfn = astman_get_header(m, "SrcFilename");
1438         const char *dfn = astman_get_header(m, "DstFilename");
1439         int res;
1440         const char *rld = astman_get_header(m, "Reload");
1441         struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
1442         enum error_type result;
1443
1444         if (ast_strlen_zero(sfn) || ast_strlen_zero(dfn)) {
1445                 astman_send_error(s, m, "Filename not specified");
1446                 return 0;
1447         }
1448         if (!(cfg = ast_config_load2(sfn, "manager", config_flags))) {
1449                 astman_send_error(s, m, "Config file not found");
1450                 return 0;
1451         }
1452         result = handle_updates(s, m, cfg, dfn);
1453         if (!result) {
1454                 ast_include_rename(cfg, sfn, dfn); /* change the include references from dfn to sfn, so things match up */
1455                 res = config_text_file_save(dfn, cfg, "Manager");
1456                 ast_config_destroy(cfg);
1457                 if (res) {
1458                         astman_send_error(s, m, "Save of config failed");
1459                         return 0;
1460                 }
1461                 astman_send_ack(s, m, NULL);
1462                 if (!ast_strlen_zero(rld)) {
1463                         if (ast_true(rld))
1464                                 rld = NULL;
1465                         ast_module_reload(rld);
1466                 }
1467         } else {
1468                 ast_config_destroy(cfg);
1469                 switch(result) {
1470                 case UNKNOWN_ACTION:
1471                         astman_send_error(s, m, "Unknown action command");
1472                         break;
1473                 case UNKNOWN_CATEGORY:
1474                         astman_send_error(s, m, "Given category does not exist");
1475                         break;
1476                 case UNSPECIFIED_CATEGORY:
1477                         astman_send_error(s, m, "Category not specified");
1478                         break;
1479                 case UNSPECIFIED_ARGUMENT:
1480                         astman_send_error(s, m, "Problem with category, value, or line (if required)");
1481                         break;
1482                 case FAILURE_ALLOCATION:
1483                         astman_send_error(s, m, "Memory allocation failure, this should not happen");
1484                         break;
1485                 case FAILURE_DELCAT:
1486                         astman_send_error(s, m, "Delete category did not complete successfully");
1487                         break;
1488                 case FAILURE_EMPTYCAT:
1489                         astman_send_error(s, m, "Empty category did not complete successfully");
1490                         break;
1491                 case FAILURE_UPDATE:
1492                         astman_send_error(s, m, "Update did not complete successfully");
1493                         break;
1494                 case FAILURE_DELETE:
1495                         astman_send_error(s, m, "Delete did not complete successfully");
1496                         break;
1497                 case FAILURE_APPEND:
1498                         astman_send_error(s, m, "Append did not complete successfully");
1499                         break;
1500                 }
1501         }
1502         return 0;
1503 }
1504
1505 static char mandescr_createconfig[] =
1506 "Description: A 'CreateConfig' action will create an empty file in the\n"
1507 "configuration directory. This action is intended to be used before an\n"
1508 "UpdateConfig action.\n"
1509 "Variables\n"
1510 "   Filename:   The configuration filename to create (e.g. foo.conf)\n";
1511
1512 static int action_createconfig(struct mansession *s, const struct message *m)
1513 {
1514         int fd;
1515         const char *fn = astman_get_header(m, "Filename");
1516         struct ast_str *filepath = ast_str_alloca(PATH_MAX);
1517         ast_str_set(&filepath, 0, "%s/", ast_config_AST_CONFIG_DIR);
1518         ast_str_append(&filepath, 0, "%s", fn);
1519
1520         if ((fd = open(filepath->str, O_CREAT | O_EXCL, AST_FILE_MODE)) != -1) {
1521                 close(fd);
1522                 astman_send_ack(s, m, "New configuration file created successfully");
1523         } else 
1524                 astman_send_error(s, m, strerror(errno));
1525
1526         return 0;
1527 }
1528
1529 /*! \brief Manager WAITEVENT */
1530 static char mandescr_waitevent[] =
1531 "Description: A 'WaitEvent' action will ellicit a 'Success' response.  Whenever\n"
1532 "a manager event is queued.  Once WaitEvent has been called on an HTTP manager\n"
1533 "session, events will be generated and queued.\n"
1534 "Variables: \n"
1535 "   Timeout: Maximum time (in seconds) to wait for events, -1 means forever.\n";
1536
1537 static int action_waitevent(struct mansession *s, const struct message *m)
1538 {
1539         const char *timeouts = astman_get_header(m, "Timeout");
1540         int timeout = -1;
1541         int x;
1542         int needexit = 0;
1543         const char *id = astman_get_header(m, "ActionID");
1544         char idText[256];
1545
1546         if (!ast_strlen_zero(id))
1547                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
1548         else
1549                 idText[0] = '\0';
1550
1551         if (!ast_strlen_zero(timeouts)) {
1552                 sscanf(timeouts, "%i", &timeout);
1553                 if (timeout < -1)
1554                         timeout = -1;
1555                 /* XXX maybe put an upper bound, or prevent the use of 0 ? */
1556         }
1557
1558         ast_mutex_lock(&s->__lock);
1559         if (s->waiting_thread != AST_PTHREADT_NULL)
1560                 pthread_kill(s->waiting_thread, SIGURG);
1561
1562         if (s->managerid) { /* AMI-over-HTTP session */
1563                 /*
1564                  * Make sure the timeout is within the expire time of the session,
1565                  * as the client will likely abort the request if it does not see
1566                  * data coming after some amount of time.
1567                  */
1568                 time_t now = time(NULL);
1569                 int max = s->sessiontimeout - now - 10;
1570
1571                 if (max < 0)    /* We are already late. Strange but possible. */
1572                         max = 0;
1573                 if (timeout < 0 || timeout > max)
1574                         timeout = max;
1575                 if (!s->send_events)    /* make sure we record events */
1576                         s->send_events = -1;
1577         }
1578         ast_mutex_unlock(&s->__lock);
1579
1580         /* XXX should this go inside the lock ? */
1581         s->waiting_thread = pthread_self();     /* let new events wake up this thread */
1582         ast_debug(1, "Starting waiting for an event!\n");
1583
1584         for (x = 0; x < timeout || timeout < 0; x++) {
1585                 ast_mutex_lock(&s->__lock);
1586                 if (NEW_EVENT(s))
1587                         needexit = 1;
1588                 /* We can have multiple HTTP session point to the same mansession entry.
1589                  * The way we deal with it is not very nice: newcomers kick out the previous
1590                  * HTTP session. XXX this needs to be improved.
1591                  */
1592                 if (s->waiting_thread != pthread_self())
1593                         needexit = 1;
1594                 if (s->needdestroy)
1595                         needexit = 1;
1596                 ast_mutex_unlock(&s->__lock);
1597                 if (needexit)
1598                         break;
1599                 if (s->managerid == 0) {        /* AMI session */
1600                         if (ast_wait_for_input(s->fd, 1000))
1601                                 break;
1602                 } else {        /* HTTP session */
1603                         sleep(1);
1604                 }
1605         }
1606         ast_debug(1, "Finished waiting for an event!\n");
1607         ast_mutex_lock(&s->__lock);
1608         if (s->waiting_thread == pthread_self()) {
1609                 struct eventqent *eqe;
1610                 astman_send_response(s, m, "Success", "Waiting for Event completed.");
1611                 while ( (eqe = NEW_EVENT(s)) ) {
1612                         ref_event(eqe);
1613                         if (((s->readperm & eqe->category) == eqe->category) &&
1614                             ((s->send_events & eqe->category) == eqe->category)) {
1615                                 astman_append(s, "%s", eqe->eventdata);
1616                         }
1617                         s->last_ev = unref_event(s->last_ev);
1618                 }
1619                 astman_append(s,
1620                         "Event: WaitEventComplete\r\n"
1621                         "%s"
1622                         "\r\n", idText);
1623                 s->waiting_thread = AST_PTHREADT_NULL;
1624         } else {
1625                 ast_debug(1, "Abandoning event request!\n");
1626         }
1627         ast_mutex_unlock(&s->__lock);
1628         return 0;
1629 }
1630
1631 static char mandescr_listcommands[] =
1632 "Description: Returns the action name and synopsis for every\n"
1633 "  action that is available to the user\n"
1634 "Variables: NONE\n";
1635
1636 /*! \note The actionlock is read-locked by the caller of this function */
1637 static int action_listcommands(struct mansession *s, const struct message *m)
1638 {
1639         struct manager_action *cur;
1640         struct ast_str *temp = ast_str_alloca(BUFSIZ); /* XXX very large ? */
1641
1642         astman_start_ack(s, m);
1643         AST_RWLIST_TRAVERSE(&actions, cur, list) {
1644                 if (s->writeperm & cur->authority || cur->authority == 0)
1645                         astman_append(s, "%s: %s (Priv: %s)\r\n",
1646                                 cur->action, cur->synopsis, authority_to_str(cur->authority, &temp));
1647         }
1648         astman_append(s, "\r\n");
1649
1650         return 0;
1651 }
1652
1653 static char mandescr_events[] =
1654 "Description: Enable/Disable sending of events to this manager\n"
1655 "  client.\n"
1656 "Variables:\n"
1657 "       EventMask: 'on' if all events should be sent,\n"
1658 "               'off' if no events should be sent,\n"
1659 "               'system,call,log' to select which flags events should have to be sent.\n";
1660
1661 static int action_events(struct mansession *s, const struct message *m)
1662 {
1663         const char *mask = astman_get_header(m, "EventMask");
1664         int res;
1665
1666         res = set_eventmask(s, mask);
1667         if (res > 0)
1668                 astman_append(s, "Response: Success\r\n"
1669                                  "Events: On\r\n");
1670         else if (res == 0)
1671                 astman_append(s, "Response: Success\r\n"
1672                                  "Events: Off\r\n");
1673         return 0;
1674 }
1675
1676 static char mandescr_logoff[] =
1677 "Description: Logoff this manager session\n"
1678 "Variables: NONE\n";
1679
1680 static int action_logoff(struct mansession *s, const struct message *m)
1681 {
1682         astman_send_response(s, m, "Goodbye", "Thanks for all the fish.");
1683         return -1;
1684 }
1685
1686 static int action_login(struct mansession *s, const struct message *m)
1687 {
1688         if (authenticate(s, m)) {
1689                 sleep(1);
1690                 astman_send_error(s, m, "Authentication failed");
1691                 return -1;
1692         }
1693         s->authenticated = 1;
1694         if (manager_displayconnects(s))
1695                 ast_verb(2, "%sManager '%s' logged on from %s\n", (s->managerid ? "HTTP " : ""), s->username, ast_inet_ntoa(s->sin.sin_addr));
1696         ast_log(LOG_EVENT, "%sManager '%s' logged on from %s\n", (s->managerid ? "HTTP " : ""), s->username, ast_inet_ntoa(s->sin.sin_addr));
1697         astman_send_ack(s, m, "Authentication accepted");
1698         return 0;
1699 }
1700
1701 static int action_challenge(struct mansession *s, const struct message *m)
1702 {
1703         const char *authtype = astman_get_header(m, "AuthType");
1704
1705         if (!strcasecmp(authtype, "MD5")) {
1706                 if (ast_strlen_zero(s->challenge))
1707                         snprintf(s->challenge, sizeof(s->challenge), "%ld", ast_random());
1708                 ast_mutex_lock(&s->__lock);
1709                 astman_start_ack(s, m);
1710                 astman_append(s, "Challenge: %s\r\n\r\n", s->challenge);
1711                 ast_mutex_unlock(&s->__lock);
1712         } else {
1713                 astman_send_error(s, m, "Must specify AuthType");
1714         }
1715         return 0;
1716 }
1717
1718 static char mandescr_hangup[] =
1719 "Description: Hangup a channel\n"
1720 "Variables: \n"
1721 "       Channel: The channel name to be hungup\n";
1722
1723 static int action_hangup(struct mansession *s, const struct message *m)
1724 {
1725         struct ast_channel *c = NULL;
1726         const char *name = astman_get_header(m, "Channel");
1727         if (ast_strlen_zero(name)) {
1728                 astman_send_error(s, m, "No channel specified");
1729                 return 0;
1730         }
1731         c = ast_get_channel_by_name_locked(name);
1732         if (!c) {
1733                 astman_send_error(s, m, "No such channel");
1734                 return 0;
1735         }
1736         ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
1737         ast_channel_unlock(c);
1738         astman_send_ack(s, m, "Channel Hungup");
1739         return 0;
1740 }
1741
1742 static char mandescr_setvar[] =
1743 "Description: Set a global or local channel variable.\n"
1744 "Variables: (Names marked with * are required)\n"
1745 "       Channel: Channel to set variable for\n"
1746 "       *Variable: Variable name\n"
1747 "       *Value: Value\n";
1748
1749 static int action_setvar(struct mansession *s, const struct message *m)
1750 {
1751         struct ast_channel *c = NULL;
1752         const char *name = astman_get_header(m, "Channel");
1753         const char *varname = astman_get_header(m, "Variable");
1754         const char *varval = astman_get_header(m, "Value");
1755
1756         if (ast_strlen_zero(varname)) {
1757                 astman_send_error(s, m, "No variable specified");
1758                 return 0;
1759         }
1760
1761         if (!ast_strlen_zero(name)) {
1762                 c = ast_get_channel_by_name_locked(name);
1763                 if (!c) {
1764                         astman_send_error(s, m, "No such channel");
1765                         return 0;
1766                 }
1767         }
1768
1769         pbx_builtin_setvar_helper(c, varname, S_OR(varval, ""));
1770
1771         if (c)
1772                 ast_channel_unlock(c);
1773
1774         astman_send_ack(s, m, "Variable Set");
1775
1776         return 0;
1777 }
1778
1779 static char mandescr_getvar[] =
1780 "Description: Get the value of a global or local channel variable.\n"
1781 "Variables: (Names marked with * are required)\n"
1782 "       Channel: Channel to read variable from\n"
1783 "       *Variable: Variable name\n"
1784 "       ActionID: Optional Action id for message matching.\n";
1785
1786 static int action_getvar(struct mansession *s, const struct message *m)
1787 {
1788         struct ast_channel *c = NULL;
1789         const char *name = astman_get_header(m, "Channel");
1790         const char *varname = astman_get_header(m, "Variable");
1791         char *varval;
1792         char workspace[1024] = "";
1793
1794         if (ast_strlen_zero(varname)) {
1795                 astman_send_error(s, m, "No variable specified");
1796                 return 0;
1797         }
1798
1799         if (!ast_strlen_zero(name)) {
1800                 c = ast_get_channel_by_name_locked(name);
1801                 if (!c) {
1802                         astman_send_error(s, m, "No such channel");
1803                         return 0;
1804                 }
1805         }
1806
1807         if (varname[strlen(varname) - 1] == ')') {
1808                 if (!c) {
1809                         astman_send_error(s, m, "No such channel");
1810                         return 0;
1811                 }
1812                 ast_func_read(c, (char *) varname, workspace, sizeof(workspace));
1813                 varval = workspace;
1814         } else {
1815                 pbx_retrieve_variable(c, varname, &varval, workspace, sizeof(workspace), NULL);
1816         }
1817
1818         if (c)
1819                 ast_channel_unlock(c);
1820         astman_start_ack(s, m);
1821         astman_append(s, "Variable: %s\r\nValue: %s\r\n\r\n", varname, varval);
1822
1823         return 0;
1824 }
1825
1826 static char mandescr_status[] = 
1827 "Description: Lists channel status along with requested channel vars.\n"
1828 "Variables: (Names marked with * are required)\n"
1829 "       *Channel: Name of the channel to query for status\n"
1830 "       Variables: Comma ',' separated list of variables to include\n"
1831 "       ActionID: Optional ID for this transaction\n"
1832 "Will return the status information of each channel along with the\n"
1833 "value for the specified channel variables.\n";
1834  
1835
1836 /*! \brief Manager "status" command to show channels */
1837 /* Needs documentation... */
1838 static int action_status(struct mansession *s, const struct message *m)
1839 {
1840         const char *name = astman_get_header(m, "Channel");
1841         const char *cvariables = astman_get_header(m, "Variables");
1842         char *variables = ast_strdupa(S_OR(cvariables, ""));
1843         struct ast_channel *c;
1844         char bridge[256];
1845         struct timeval now = ast_tvnow();
1846         long elapsed_seconds = 0;
1847         int channels = 0;
1848         int all = ast_strlen_zero(name); /* set if we want all channels */
1849         const char *id = astman_get_header(m, "ActionID");
1850         char idText[256];
1851         AST_DECLARE_APP_ARGS(vars,
1852                 AST_APP_ARG(name)[100];
1853         );
1854         struct ast_str *str = ast_str_create(1000);
1855
1856         if (!ast_strlen_zero(id))
1857                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
1858         else
1859                 idText[0] = '\0';
1860
1861         if (all)
1862                 c = ast_channel_walk_locked(NULL);
1863         else {
1864                 c = ast_get_channel_by_name_locked(name);
1865                 if (!c) {
1866                         astman_send_error(s, m, "No such channel");
1867                         return 0;
1868                 }
1869         }
1870         astman_send_ack(s, m, "Channel status will follow");
1871
1872         if (!ast_strlen_zero(cvariables)) {
1873                 AST_STANDARD_APP_ARGS(vars, variables);
1874         }
1875
1876         /* if we look by name, we break after the first iteration */
1877         while (c) {
1878                 if (!ast_strlen_zero(cvariables)) {
1879                         int i;
1880                         ast_str_reset(str);
1881                         for (i = 0; i < vars.argc; i++) {
1882                                 char valbuf[512], *ret = NULL;
1883
1884                                 if (vars.name[i][strlen(vars.name[i]) - 1] == ')') {
1885                                         if (ast_func_read(c, vars.name[i], valbuf, sizeof(valbuf)) < 0) {
1886                                                 valbuf[0] = '\0';
1887                                         }
1888                                         ret = valbuf;
1889                                 } else {
1890                                         pbx_retrieve_variable(c, vars.name[i], &ret, valbuf, sizeof(valbuf), NULL);
1891                                 }
1892
1893                                 ast_str_append(&str, 0, "Variable: %s=%s\r\n", vars.name[i], ret);
1894                         }
1895                 }
1896
1897                 channels++;
1898                 if (c->_bridge)
1899                         snprintf(bridge, sizeof(bridge), "BridgedChannel: %s\r\nBridgedUniqueid: %s\r\n", c->_bridge->name, c->_bridge->uniqueid);
1900                 else
1901                         bridge[0] = '\0';
1902                 if (c->pbx) {
1903                         if (c->cdr) {
1904                                 elapsed_seconds = now.tv_sec - c->cdr->start.tv_sec;
1905                         }
1906                         astman_append(s,
1907                         "Event: Status\r\n"
1908                         "Privilege: Call\r\n"
1909                         "Channel: %s\r\n"
1910                         "CallerIDNum: %s\r\n"
1911                         "CallerIDName: %s\r\n"
1912                         "Accountcode: %s\r\n"
1913                         "ChannelState: %d\r\n"
1914                         "ChannelStateDesc: %s\r\n"
1915                         "Context: %s\r\n"
1916                         "Extension: %s\r\n"
1917                         "Priority: %d\r\n"
1918                         "Seconds: %ld\r\n"
1919                         "%s"
1920                         "Uniqueid: %s\r\n"
1921                         "%s"
1922                         "%s"
1923                         "\r\n",
1924                         c->name,
1925                         S_OR(c->cid.cid_num, ""),
1926                         S_OR(c->cid.cid_name, ""),
1927                         c->accountcode,
1928                         c->_state,
1929                         ast_state2str(c->_state), c->context,
1930                         c->exten, c->priority, (long)elapsed_seconds, bridge, c->uniqueid, str->str, idText);
1931                 } else {
1932                         astman_append(s,
1933                         "Event: Status\r\n"
1934                         "Privilege: Call\r\n"
1935                         "Channel: %s\r\n"
1936                         "CallerIDNum: %s\r\n"
1937                         "CallerIDName: %s\r\n"
1938                         "Account: %s\r\n"
1939                         "State: %s\r\n"
1940                         "%s"
1941                         "Uniqueid: %s\r\n"
1942                         "%s"
1943                         "%s"
1944                         "\r\n",
1945                         c->name,
1946                         S_OR(c->cid.cid_num, "<unknown>"),
1947                         S_OR(c->cid.cid_name, "<unknown>"),
1948                         c->accountcode,
1949                         ast_state2str(c->_state), bridge, c->uniqueid, str->str, idText);
1950                 }
1951                 ast_channel_unlock(c);
1952                 if (!all)
1953                         break;
1954                 c = ast_channel_walk_locked(c);
1955         }
1956         astman_append(s,
1957         "Event: StatusComplete\r\n"
1958         "%s"
1959         "Items: %d\r\n"
1960         "\r\n", idText, channels);
1961         ast_free(str);
1962         return 0;
1963 }
1964
1965 static char mandescr_sendtext[] =
1966 "Description: Sends A Text Message while in a call.\n"
1967 "Variables: (Names marked with * are required)\n"
1968 "       *Channel: Channel to send message to\n"
1969 "       *Message: Message to send\n"
1970 "       ActionID: Optional Action id for message matching.\n";
1971
1972 static int action_sendtext(struct mansession *s, const struct message *m)
1973 {
1974         struct ast_channel *c = NULL;
1975         const char *name = astman_get_header(m, "Channel");
1976         const char *textmsg = astman_get_header(m, "Message");
1977         int res = 0;
1978
1979         if (ast_strlen_zero(name)) {
1980                 astman_send_error(s, m, "No channel specified");
1981                 return 0;
1982         }
1983
1984         if (ast_strlen_zero(textmsg)) {
1985                 astman_send_error(s, m, "No Message specified");
1986                 return 0;
1987         }
1988
1989         c = ast_get_channel_by_name_locked(name);
1990         if (!c) {
1991                 astman_send_error(s, m, "No such channel");
1992                 return 0;
1993         }
1994
1995         res = ast_sendtext(c, textmsg);
1996         ast_channel_unlock(c);
1997         
1998         if (res > 0)
1999                 astman_send_ack(s, m, "Success");
2000         else
2001                 astman_send_error(s, m, "Failure");
2002         
2003         return res;
2004 }
2005
2006 static char mandescr_redirect[] =
2007 "Description: Redirect (transfer) a call.\n"
2008 "Variables: (Names marked with * are required)\n"
2009 "       *Channel: Channel to redirect\n"
2010 "       ExtraChannel: Second call leg to transfer (optional)\n"
2011 "       *Exten: Extension to transfer to\n"
2012 "       *Context: Context to transfer to\n"
2013 "       *Priority: Priority to transfer to\n"
2014 "       ActionID: Optional Action id for message matching.\n";
2015
2016 /*! \brief  action_redirect: The redirect manager command */
2017 static int action_redirect(struct mansession *s, const struct message *m)
2018 {
2019         const char *name = astman_get_header(m, "Channel");
2020         const char *name2 = astman_get_header(m, "ExtraChannel");
2021         const char *exten = astman_get_header(m, "Exten");
2022         const char *context = astman_get_header(m, "Context");
2023         const char *priority = astman_get_header(m, "Priority");
2024         struct ast_channel *chan, *chan2 = NULL;
2025         int pi = 0;
2026         int res;
2027
2028         if (ast_strlen_zero(name)) {
2029                 astman_send_error(s, m, "Channel not specified");
2030                 return 0;
2031         }
2032         if (!ast_strlen_zero(priority) && (sscanf(priority, "%d", &pi) != 1)) {
2033                 if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) {
2034                         astman_send_error(s, m, "Invalid priority");
2035                         return 0;
2036                 }
2037         }
2038         /* XXX watch out, possible deadlock - we are trying to get two channels!!! */
2039         chan = ast_get_channel_by_name_locked(name);
2040         if (!chan) {
2041                 char buf[256];
2042                 snprintf(buf, sizeof(buf), "Channel does not exist: %s", name);
2043                 astman_send_error(s, m, buf);
2044                 return 0;
2045         }
2046         if (ast_check_hangup(chan)) {
2047                 astman_send_error(s, m, "Redirect failed, channel not up.");
2048                 ast_channel_unlock(chan);
2049                 return 0;
2050         }
2051         if (!ast_strlen_zero(name2))
2052                 chan2 = ast_get_channel_by_name_locked(name2);
2053         if (chan2 && ast_check_hangup(chan2)) {
2054                 astman_send_error(s, m, "Redirect failed, extra channel not up.");
2055                 ast_channel_unlock(chan);
2056                 ast_channel_unlock(chan2);
2057                 return 0;
2058         }
2059         res = ast_async_goto(chan, context, exten, pi);
2060         if (!res) {
2061                 if (!ast_strlen_zero(name2)) {
2062                         if (chan2)
2063                                 res = ast_async_goto(chan2, context, exten, pi);
2064                         else
2065                                 res = -1;
2066                         if (!res)
2067                                 astman_send_ack(s, m, "Dual Redirect successful");
2068                         else
2069                                 astman_send_error(s, m, "Secondary redirect failed");
2070                 } else
2071                         astman_send_ack(s, m, "Redirect successful");
2072         } else
2073                 astman_send_error(s, m, "Redirect failed");
2074         if (chan)
2075                 ast_channel_unlock(chan);
2076         if (chan2)
2077                 ast_channel_unlock(chan2);
2078         return 0;
2079 }
2080
2081 static char mandescr_atxfer[] =
2082 "Description: Attended transfer.\n"
2083 "Variables: (Names marked with * are required)\n"
2084 "       *Channel: Transferer's channel\n"
2085 "       *Exten: Extension to transfer to\n"
2086 "       *Context: Context to transfer to\n"
2087 "       *Priority: Priority to transfer to\n"
2088 "       ActionID: Optional Action id for message matching.\n";
2089
2090 static int action_atxfer(struct mansession *s, const struct message *m)
2091 {
2092         const char *name = astman_get_header(m, "Channel");
2093         const char *exten = astman_get_header(m, "Exten");
2094         const char *context = astman_get_header(m, "Context");
2095         struct ast_channel *chan = NULL;
2096         struct ast_call_feature *atxfer_feature = NULL;
2097         char *feature_code = NULL;
2098
2099         if (ast_strlen_zero(name)) { 
2100                 astman_send_error(s, m, "No channel specified");
2101                 return 0;
2102         }
2103         if (ast_strlen_zero(exten)) {
2104                 astman_send_error(s, m, "No extension specified");
2105                 return 0;
2106         }
2107
2108         if (!(atxfer_feature = ast_find_call_feature("atxfer"))) {
2109                 astman_send_error(s, m, "No attended transfer feature found");
2110                 return 0;
2111         }
2112
2113         if (!(chan = ast_get_channel_by_name_locked(name))) {
2114                 astman_send_error(s, m, "Channel specified does not exist");
2115                 return 0;
2116         }
2117
2118         if (!ast_strlen_zero(context)) {
2119                 pbx_builtin_setvar_helper(chan, "TRANSFER_CONTEXT", context);
2120         }
2121
2122         for (feature_code = atxfer_feature->exten; feature_code && *feature_code; ++feature_code) {
2123                 struct ast_frame f = {AST_FRAME_DTMF, *feature_code};
2124                 ast_queue_frame(chan, &f);
2125         }
2126
2127         for (feature_code = (char *)exten; feature_code && *feature_code; ++feature_code) {
2128                 struct ast_frame f = {AST_FRAME_DTMF, *feature_code};
2129                 ast_queue_frame(chan, &f);
2130         }
2131
2132         astman_send_ack(s, m, "Atxfer successfully queued");
2133         ast_channel_unlock(chan);
2134
2135         return 0;
2136 }
2137
2138 static int check_blacklist(const char *cmd)
2139 {
2140         char *cmd_copy, *cur_cmd;
2141         char *cmd_words[MAX_BLACKLIST_CMD_LEN] = { NULL, };
2142         int i;
2143
2144         cmd_copy = ast_strdupa(cmd);
2145         for (i = 0; i < MAX_BLACKLIST_CMD_LEN && (cur_cmd = strsep(&cmd_copy, " ")); i++) {
2146                 cur_cmd = ast_strip(cur_cmd);
2147                 if (ast_strlen_zero(cur_cmd)) {
2148                         i--;
2149                         continue;
2150                 }
2151
2152                 cmd_words[i] = cur_cmd;
2153         }
2154
2155         for (i = 0; i < ARRAY_LEN(command_blacklist); i++) {
2156                 int j, match = 1;
2157
2158                 for (j = 0; command_blacklist[i].words[j]; j++) {
2159                         if (ast_strlen_zero(cmd_words[j]) || strcasecmp(cmd_words[j], command_blacklist[i].words[j])) {
2160                                 match = 0;
2161                                 break;
2162                         }
2163                 }
2164
2165                 if (match) {
2166                         return 1;
2167                 }
2168         }
2169
2170         return 0;
2171 }
2172
2173 static char mandescr_command[] =
2174 "Description: Run a CLI command.\n"
2175 "Variables: (Names marked with * are required)\n"
2176 "       *Command: Asterisk CLI command to run\n"
2177 "       ActionID: Optional Action id for message matching.\n";
2178
2179 /*! \brief  Manager command "command" - execute CLI command */
2180 static int action_command(struct mansession *s, const struct message *m)
2181 {
2182         const char *cmd = astman_get_header(m, "Command");
2183         const char *id = astman_get_header(m, "ActionID");
2184         char *buf, *final_buf;
2185         char template[] = "/tmp/ast-ami-XXXXXX";        /* template for temporary file */
2186         int fd = mkstemp(template);
2187         off_t l;
2188
2189         if (ast_strlen_zero(cmd)) {
2190                 astman_send_error(s, m, "No command provided");
2191                 return 0;
2192         }
2193
2194         if (check_blacklist(cmd)) {
2195                 astman_send_error(s, m, "Command blacklisted");
2196                 return 0;
2197         }
2198
2199         astman_append(s, "Response: Follows\r\nPrivilege: Command\r\n");
2200         if (!ast_strlen_zero(id))
2201                 astman_append(s, "ActionID: %s\r\n", id);
2202         /* FIXME: Wedge a ActionID response in here, waiting for later changes */
2203         ast_cli_command(fd, cmd);       /* XXX need to change this to use a FILE * */
2204         l = lseek(fd, 0, SEEK_END);     /* how many chars available */
2205
2206         /* This has a potential to overflow the stack.  Hence, use the heap. */
2207         buf = ast_calloc(1, l + 1);
2208         final_buf = ast_calloc(1, l + 1);
2209         if (buf) {
2210                 lseek(fd, 0, SEEK_SET);
2211                 read(fd, buf, l);
2212                 buf[l] = '\0';
2213                 if (final_buf) {
2214                         term_strip(final_buf, buf, l);
2215                         final_buf[l] = '\0';
2216                 }
2217                 astman_append(s, "%s", S_OR(final_buf, buf));
2218                 ast_free(buf);
2219         }
2220         close(fd);
2221         unlink(template);
2222         astman_append(s, "--END COMMAND--\r\n\r\n");
2223         if (final_buf)
2224                 ast_free(final_buf);
2225         return 0;
2226 }
2227
2228 /*! \brief helper function for originate */
2229 struct fast_originate_helper {
2230         char tech[AST_MAX_EXTENSION];
2231         char data[AST_MAX_EXTENSION];
2232         int timeout;
2233         int format;                             /*!< Codecs used for a call */
2234         char app[AST_MAX_APP];
2235         char appdata[AST_MAX_EXTENSION];
2236         char cid_name[AST_MAX_EXTENSION];
2237         char cid_num[AST_MAX_EXTENSION];
2238         char context[AST_MAX_CONTEXT];
2239         char exten[AST_MAX_EXTENSION];
2240         char idtext[AST_MAX_EXTENSION];
2241         char account[AST_MAX_ACCOUNT_CODE];
2242         int priority;
2243         struct ast_variable *vars;
2244 };
2245
2246 static void *fast_originate(void *data)
2247 {
2248         struct fast_originate_helper *in = data;
2249         int res;
2250         int reason = 0;
2251         struct ast_channel *chan = NULL;
2252         char requested_channel[AST_CHANNEL_NAME];
2253
2254         if (!ast_strlen_zero(in->app)) {
2255                 res = ast_pbx_outgoing_app(in->tech, in->format, in->data, in->timeout, in->app, in->appdata, &reason, 1,
2256                         S_OR(in->cid_num, NULL),
2257                         S_OR(in->cid_name, NULL),
2258                         in->vars, in->account, &chan);
2259         } else {
2260                 res = ast_pbx_outgoing_exten(in->tech, in->format, in->data, in->timeout, in->context, in->exten, in->priority, &reason, 1,
2261                         S_OR(in->cid_num, NULL),
2262                         S_OR(in->cid_name, NULL),
2263                         in->vars, in->account, &chan);
2264         }
2265
2266         if (!chan)
2267                 snprintf(requested_channel, AST_CHANNEL_NAME, "%s/%s", in->tech, in->data);     
2268         /* Tell the manager what happened with the channel */
2269         manager_event(EVENT_FLAG_CALL, "OriginateResponse",
2270                 "%s"
2271                 "Response: %s\r\n"
2272                 "Channel: %s\r\n"
2273                 "Context: %s\r\n"
2274                 "Exten: %s\r\n"
2275                 "Reason: %d\r\n"
2276                 "Uniqueid: %s\r\n"
2277                 "CallerIDNum: %s\r\n"
2278                 "CallerIDName: %s\r\n",
2279                 in->idtext, res ? "Failure" : "Success", chan ? chan->name : requested_channel, in->context, in->exten, reason, 
2280                 chan ? chan->uniqueid : "<null>",
2281                 S_OR(in->cid_num, "<unknown>"),
2282                 S_OR(in->cid_name, "<unknown>")
2283                 );
2284
2285         /* Locked by ast_pbx_outgoing_exten or ast_pbx_outgoing_app */
2286         if (chan)
2287                 ast_channel_unlock(chan);
2288         ast_free(in);
2289         return NULL;
2290 }
2291
2292 static char mandescr_originate[] =
2293 "Description: Generates an outgoing call to a Extension/Context/Priority or\n"
2294 "  Application/Data\n"
2295 "Variables: (Names marked with * are required)\n"
2296 "       *Channel: Channel name to call\n"
2297 "       Exten: Extension to use (requires 'Context' and 'Priority')\n"
2298 "       Context: Context to use (requires 'Exten' and 'Priority')\n"
2299 "       Priority: Priority to use (requires 'Exten' and 'Context')\n"
2300 "       Application: Application to use\n"
2301 "       Data: Data to use (requires 'Application')\n"
2302 "       Timeout: How long to wait for call to be answered (in ms)\n"
2303 "       CallerID: Caller ID to be set on the outgoing channel\n"
2304 "       Variable: Channel variable to set, multiple Variable: headers are allowed\n"
2305 "       Account: Account code\n"
2306 "       Async: Set to 'true' for fast origination\n";
2307
2308 static int action_originate(struct mansession *s, const struct message *m)
2309 {
2310         const char *name = astman_get_header(m, "Channel");
2311         const char *exten = astman_get_header(m, "Exten");
2312         const char *context = astman_get_header(m, "Context");
2313         const char *priority = astman_get_header(m, "Priority");
2314         const char *timeout = astman_get_header(m, "Timeout");
2315         const char *callerid = astman_get_header(m, "CallerID");
2316         const char *account = astman_get_header(m, "Account");
2317         const char *app = astman_get_header(m, "Application");
2318         const char *appdata = astman_get_header(m, "Data");
2319         const char *async = astman_get_header(m, "Async");
2320         const char *id = astman_get_header(m, "ActionID");
2321         const char *codecs = astman_get_header(m, "Codecs");
2322         struct ast_variable *vars = astman_get_variables(m);
2323         char *tech, *data;
2324         char *l = NULL, *n = NULL;
2325         int pi = 0;
2326         int res;
2327         int to = 30000;
2328         int reason = 0;
2329         char tmp[256];
2330         char tmp2[256];
2331         int format = AST_FORMAT_SLINEAR;
2332
2333         pthread_t th;
2334         if (ast_strlen_zero(name)) {
2335                 astman_send_error(s, m, "Channel not specified");
2336                 return 0;
2337         }
2338         if (!ast_strlen_zero(priority) && (sscanf(priority, "%d", &pi) != 1)) {
2339                 if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) {
2340                         astman_send_error(s, m, "Invalid priority");
2341                         return 0;
2342                 }
2343         }
2344         if (!ast_strlen_zero(timeout) && (sscanf(timeout, "%d", &to) != 1)) {
2345                 astman_send_error(s, m, "Invalid timeout");
2346                 return 0;
2347         }
2348         ast_copy_string(tmp, name, sizeof(tmp));
2349         tech = tmp;
2350         data = strchr(tmp, '/');
2351         if (!data) {
2352                 astman_send_error(s, m, "Invalid channel");
2353                 return 0;
2354         }
2355         *data++ = '\0';
2356         ast_copy_string(tmp2, callerid, sizeof(tmp2));
2357         ast_callerid_parse(tmp2, &n, &l);
2358         if (n) {
2359                 if (ast_strlen_zero(n))
2360                         n = NULL;
2361         }
2362         if (l) {
2363                 ast_shrink_phone_number(l);
2364                 if (ast_strlen_zero(l))
2365                         l = NULL;
2366         }
2367         if (!ast_strlen_zero(codecs)) {
2368                 format = 0;
2369                 ast_parse_allow_disallow(NULL, &format, codecs, 1);
2370         }
2371         if (ast_true(async)) {
2372                 struct fast_originate_helper *fast = ast_calloc(1, sizeof(*fast));
2373                 if (!fast) {
2374                         res = -1;
2375                 } else {
2376                         if (!ast_strlen_zero(id))
2377                                 snprintf(fast->idtext, sizeof(fast->idtext), "ActionID: %s\r\n", id);
2378                         ast_copy_string(fast->tech, tech, sizeof(fast->tech));
2379                         ast_copy_string(fast->data, data, sizeof(fast->data));
2380                         ast_copy_string(fast->app, app, sizeof(fast->app));
2381                         ast_copy_string(fast->appdata, appdata, sizeof(fast->appdata));
2382                         if (l)
2383                                 ast_copy_string(fast->cid_num, l, sizeof(fast->cid_num));
2384                         if (n)
2385                                 ast_copy_string(fast->cid_name, n, sizeof(fast->cid_name));
2386                         fast->vars = vars;
2387                         ast_copy_string(fast->context, context, sizeof(fast->context));
2388                         ast_copy_string(fast->exten, exten, sizeof(fast->exten));
2389                         ast_copy_string(fast->account, account, sizeof(fast->account));
2390                         fast->format = format;
2391                         fast->timeout = to;
2392                         fast->priority = pi;
2393                         if (ast_pthread_create_detached(&th, NULL, fast_originate, fast)) {
2394                                 ast_free(fast);
2395                                 res = -1;
2396                         } else {
2397                                 res = 0;
2398                         }
2399                 }
2400         } else if (!ast_strlen_zero(app)) {
2401                 /* To run the System application (or anything else that goes to shell), you must have the additional System privilege */
2402                 if (!(s->writeperm & EVENT_FLAG_SYSTEM)
2403                         && (
2404                                 strcasestr(app, "system") == 0 || /* System(rm -rf /)
2405                                                                      TrySystem(rm -rf /)       */
2406                                 strcasestr(app, "exec") ||        /* Exec(System(rm -rf /))
2407                                                                      TryExec(System(rm -rf /)) */
2408                                 strcasestr(app, "agi") ||         /* AGI(/bin/rm,-rf /)
2409                                                                      EAGI(/bin/rm,-rf /)       */
2410                                 strstr(appdata, "SHELL") ||       /* NoOp(${SHELL(rm -rf /)})  */
2411                                 strstr(appdata, "EVAL")           /* NoOp(${EVAL(${some_var_containing_SHELL})}) */
2412                                 )) {
2413                         astman_send_error(s, m, "Originate with certain 'Application' arguments requires the additional System privilege, which you do not have.");
2414                         return 0;
2415                 }
2416                 res = ast_pbx_outgoing_app(tech, format, data, to, app, appdata, &reason, 1, l, n, vars, account, NULL);
2417         } else {
2418                 if (exten && context && pi)
2419                         res = ast_pbx_outgoing_exten(tech, format, data, to, context, exten, pi, &reason, 1, l, n, vars, account, NULL);
2420                 else {
2421                         astman_send_error(s, m, "Originate with 'Exten' requires 'Context' and 'Priority'");
2422                         return 0;
2423                 }
2424         }
2425         if (!res)
2426                 astman_send_ack(s, m, "Originate successfully queued");
2427         else
2428                 astman_send_error(s, m, "Originate failed");
2429         return 0;
2430 }
2431
2432 /*! \brief Help text for manager command mailboxstatus
2433  */
2434 static char mandescr_mailboxstatus[] =
2435 "Description: Checks a voicemail account for status.\n"
2436 "Variables: (Names marked with * are required)\n"
2437 "       *Mailbox: Full mailbox ID <mailbox>@<vm-context>\n"
2438 "       ActionID: Optional ActionID for message matching.\n"
2439 "Returns number of messages.\n"
2440 "       Message: Mailbox Status\n"
2441 "       Mailbox: <mailboxid>\n"
2442 "       Waiting: <count>\n"
2443 "\n";
2444
2445 static int action_mailboxstatus(struct mansession *s, const struct message *m)
2446 {
2447         const char *mailbox = astman_get_header(m, "Mailbox");
2448         int ret;
2449
2450         if (ast_strlen_zero(mailbox)) {
2451                 astman_send_error(s, m, "Mailbox not specified");
2452                 return 0;
2453         }
2454         ret = ast_app_has_voicemail(mailbox, NULL);
2455         astman_start_ack(s, m);
2456         astman_append(s, "Message: Mailbox Status\r\n"
2457                          "Mailbox: %s\r\n"
2458                          "Waiting: %d\r\n\r\n", mailbox, ret);
2459         return 0;
2460 }
2461
2462 static char mandescr_mailboxcount[] =
2463 "Description: Checks a voicemail account for new messages.\n"
2464 "Variables: (Names marked with * are required)\n"
2465 "       *Mailbox: Full mailbox ID <mailbox>@<vm-context>\n"
2466 "       ActionID: Optional ActionID for message matching.\n"
2467 "Returns number of urgent, new and old messages.\n"
2468 "       Message: Mailbox Message Count\n"
2469 "       Mailbox: <mailboxid>\n"
2470 "       UrgentMessages: <count>\n"
2471 "       NewMessages: <count>\n"
2472 "       OldMessages: <count>\n"
2473 "\n";
2474 static int action_mailboxcount(struct mansession *s, const struct message *m)
2475 {
2476         const char *mailbox = astman_get_header(m, "Mailbox");
2477         int newmsgs = 0, oldmsgs = 0, urgentmsgs = 0;;
2478
2479         if (ast_strlen_zero(mailbox)) {
2480                 astman_send_error(s, m, "Mailbox not specified");
2481                 return 0;
2482         }
2483         ast_app_inboxcount2(mailbox, &urgentmsgs, &newmsgs, &oldmsgs);
2484         astman_start_ack(s, m);
2485         astman_append(s,   "Message: Mailbox Message Count\r\n"
2486                            "Mailbox: %s\r\n"
2487                            "UrgMessages: %d\r\n"
2488                            "NewMessages: %d\r\n"
2489                            "OldMessages: %d\r\n"
2490                            "\r\n",
2491                            mailbox, urgentmsgs, newmsgs, oldmsgs);
2492         return 0;
2493 }
2494
2495 static char mandescr_extensionstate[] =
2496 "Description: Report the extension state for given extension.\n"
2497 "  If the extension has a hint, will use devicestate to check\n"
2498 "  the status of the device connected to the extension.\n"
2499 "Variables: (Names marked with * are required)\n"
2500 "       *Exten: Extension to check state on\n"
2501 "       *Context: Context for extension\n"
2502 "       ActionId: Optional ID for this transaction\n"
2503 "Will return an \"Extension Status\" message.\n"
2504 "The response will include the hint for the extension and the status.\n";
2505
2506 static int action_extensionstate(struct mansession *s, const struct message *m)
2507 {
2508         const char *exten = astman_get_header(m, "Exten");
2509         const char *context = astman_get_header(m, "Context");
2510         char hint[256] = "";
2511         int status;
2512         if (ast_strlen_zero(exten)) {
2513                 astman_send_error(s, m, "Extension not specified");
2514                 return 0;
2515         }
2516         if (ast_strlen_zero(context))
2517                 context = "default";
2518         status = ast_extension_state(NULL, context, exten);
2519         ast_get_hint(hint, sizeof(hint) - 1, NULL, 0, NULL, context, exten);
2520         astman_start_ack(s, m);
2521         astman_append(s,   "Message: Extension Status\r\n"
2522                            "Exten: %s\r\n"
2523                            "Context: %s\r\n"
2524                            "Hint: %s\r\n"
2525                            "Status: %d\r\n\r\n",
2526                            exten, context, hint, status);
2527         return 0;
2528 }
2529
2530 static char mandescr_timeout[] =
2531 "Description: Hangup a channel after a certain time.\n"
2532 "Variables: (Names marked with * are required)\n"
2533 "       *Channel: Channel name to hangup\n"
2534 "       *Timeout: Maximum duration of the call (sec)\n"
2535 "Acknowledges set time with 'Timeout Set' message\n";
2536
2537 static int action_timeout(struct mansession *s, const struct message *m)
2538 {
2539         struct ast_channel *c;
2540         const char *name = astman_get_header(m, "Channel");
2541         double timeout = atof(astman_get_header(m, "Timeout"));
2542         struct timeval when = { timeout, 0 };
2543
2544         if (ast_strlen_zero(name)) {
2545                 astman_send_error(s, m, "No channel specified");
2546                 return 0;
2547         }
2548         if (!timeout || timeout < 0) {
2549                 astman_send_error(s, m, "No timeout specified");
2550                 return 0;
2551         }
2552         c = ast_get_channel_by_name_locked(name);
2553         if (!c) {
2554                 astman_send_error(s, m, "No such channel");
2555                 return 0;
2556         }
2557
2558         when.tv_usec = (timeout - when.tv_sec) * 1000000.0;
2559         ast_channel_setwhentohangup_tv(c, when);
2560         ast_channel_unlock(c);
2561         astman_send_ack(s, m, "Timeout Set");
2562         return 0;
2563 }
2564
2565 /*!
2566  * Send any applicable events to the client listening on this socket.
2567  * Wait only for a finite time on each event, and drop all events whether
2568  * they are successfully sent or not.
2569  */
2570 static int process_events(struct mansession *s)
2571 {
2572         int ret = 0;
2573
2574         ast_mutex_lock(&s->__lock);
2575         if (s->f != NULL) {
2576                 struct eventqent *eqe;
2577
2578                 while ( (eqe = NEW_EVENT(s)) ) {
2579                         ref_event(eqe);
2580                         if (!ret && s->authenticated &&
2581                             (s->readperm & eqe->category) == eqe->category &&
2582                             (s->send_events & eqe->category) == eqe->category) {
2583                                 if (send_string(s, eqe->eventdata) < 0)
2584                                         ret = -1;       /* don't send more */
2585                         }
2586                         s->last_ev = unref_event(s->last_ev);
2587                 }
2588         }
2589         ast_mutex_unlock(&s->__lock);
2590         return ret;
2591 }
2592
2593 static char mandescr_userevent[] =
2594 "Description: Send an event to manager sessions.\n"
2595 "Variables: (Names marked with * are required)\n"
2596 "       *UserEvent: EventStringToSend\n"
2597 "       Header1: Content1\n"
2598 "       HeaderN: ContentN\n";
2599
2600 static int action_userevent(struct mansession *s, const struct message *m)
2601 {
2602         const char *event = astman_get_header(m, "UserEvent");
2603         char body[2048] = "";
2604         int x, bodylen = 0;
2605         for (x = 0; x < m->hdrcount; x++) {
2606                 if (strncasecmp("UserEvent:", m->headers[x], strlen("UserEvent:"))) {
2607                         ast_copy_string(body + bodylen, m->headers[x], sizeof(body) - bodylen - 3);
2608                         bodylen += strlen(m->headers[x]);
2609                         ast_copy_string(body + bodylen, "\r\n", 3);
2610                         bodylen += 2;
2611                 }
2612         }
2613
2614         manager_event(EVENT_FLAG_USER, "UserEvent", "UserEvent: %s\r\n%s", event, body);
2615         return 0;
2616 }
2617
2618 static char mandescr_coresettings[] =
2619 "Description: Query for Core PBX settings.\n"
2620 "Variables: (Names marked with * are optional)\n"
2621 "       *ActionID: ActionID of this transaction\n";
2622
2623 /*! \brief Show PBX core settings information */
2624 static int action_coresettings(struct mansession *s, const struct message *m)
2625 {
2626         const char *actionid = astman_get_header(m, "ActionID");
2627         char idText[150];
2628
2629         if (!ast_strlen_zero(actionid))
2630                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
2631         else
2632                 idText[0] = '\0';
2633
2634         astman_append(s, "Response: Success\r\n"
2635                         "%s"
2636                         "AMIversion: %s\r\n"
2637                         "AsteriskVersion: %s\r\n"
2638                         "SystemName: %s\r\n"
2639                         "CoreMaxCalls: %d\r\n"
2640                         "CoreMaxLoadAvg: %f\r\n"
2641                         "CoreRunUser: %s\r\n"
2642                         "CoreRunGroup: %s\r\n"
2643                         "CoreMaxFilehandles: %d\r\n" 
2644                         "CoreRealTimeEnabled: %s\r\n"
2645                         "CoreCDRenabled: %s\r\n"
2646                         "CoreHTTPenabled: %s\r\n"
2647                         "\r\n",
2648                         idText,
2649                         AMI_VERSION,
2650                         ast_get_version(), 
2651                         ast_config_AST_SYSTEM_NAME,
2652                         option_maxcalls,
2653                         option_maxload,
2654                         ast_config_AST_RUN_USER,
2655                         ast_config_AST_RUN_GROUP,
2656                         option_maxfiles,
2657                         ast_realtime_enabled() ? "Yes" : "No",
2658                         check_cdr_enabled() ? "Yes" : "No",
2659                         check_webmanager_enabled() ? "Yes" : "No"
2660                         );
2661         return 0;
2662 }
2663
2664 static char mandescr_corestatus[] =
2665 "Description: Query for Core PBX status.\n"
2666 "Variables: (Names marked with * are optional)\n"
2667 "       *ActionID: ActionID of this transaction\n";
2668
2669 /*! \brief Show PBX core status information */
2670 static int action_corestatus(struct mansession *s, const struct message *m)
2671 {
2672         const char *actionid = astman_get_header(m, "ActionID");
2673         char idText[150];
2674         char startuptime[150];
2675         char reloadtime[150];
2676         struct ast_tm tm;
2677
2678         if (!ast_strlen_zero(actionid))
2679                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
2680         else
2681                 idText[0] = '\0';
2682
2683         ast_localtime(&ast_startuptime, &tm, NULL);
2684         ast_strftime(startuptime, sizeof(startuptime), "%H:%M:%S", &tm);
2685         ast_localtime(&ast_lastreloadtime, &tm, NULL);
2686         ast_strftime(reloadtime, sizeof(reloadtime), "%H:%M:%S", &tm);
2687
2688         astman_append(s, "Response: Success\r\n"
2689                         "%s"
2690                         "CoreStartupTime: %s\r\n"
2691                         "CoreReloadTime: %s\r\n"
2692                         "CoreCurrentCalls: %d\r\n"
2693                         "\r\n",
2694                         idText,
2695                         startuptime,
2696                         reloadtime,
2697                         ast_active_channels()
2698                         );
2699         return 0;
2700 }
2701
2702 static char mandescr_reload[] =
2703 "Description: Send a reload event.\n"
2704 "Variables: (Names marked with * are optional)\n"
2705 "       *ActionID: ActionID of this transaction\n"
2706 "       *Module: Name of the module to reload\n";
2707
2708 /*! \brief Send a reload event */
2709 static int action_reload(struct mansession *s, const struct message *m)
2710 {
2711         const char *module = astman_get_header(m, "Module");
2712         int res = ast_module_reload(S_OR(module, NULL));
2713
2714         if (res == 2)
2715                 astman_send_ack(s, m, "Module Reloaded");
2716         else
2717                 astman_send_error(s, m, s == 0 ? "No such module" : "Module does not support reload");
2718         return 0;
2719 }
2720
2721 static char mandescr_coreshowchannels[] =
2722 "Description: List currently defined channels and some information\n"
2723 "             about them.\n"
2724 "Variables:\n"
2725 "          ActionID: Optional Action id for message matching.\n";
2726
2727 /*! \brief  Manager command "CoreShowChannels" - List currently defined channels 
2728  *          and some information about them. */
2729 static int action_coreshowchannels(struct mansession *s, const struct message *m)
2730 {
2731         const char *actionid = astman_get_header(m, "ActionID");
2732         char actionidtext[256];
2733         struct ast_channel *c = NULL;
2734         int numchans = 0;
2735         int duration, durh, durm, durs;
2736
2737         if (!ast_strlen_zero(actionid))
2738                 snprintf(actionidtext, sizeof(actionidtext), "ActionID: %s\r\n", actionid);
2739         else
2740                 actionidtext[0] = '\0';
2741
2742         astman_send_listack(s, m, "Channels will follow", "start");     
2743
2744         while ((c = ast_channel_walk_locked(c)) != NULL) {
2745                 struct ast_channel *bc = ast_bridged_channel(c);
2746                 char durbuf[10] = "";
2747
2748                 if (c->cdr && !ast_tvzero(c->cdr->start)) {
2749                         duration = (int)(ast_tvdiff_ms(ast_tvnow(), c->cdr->start) / 1000);
2750                         durh = duration / 3600;
2751                         durm = (duration % 3600) / 60;
2752                         durs = duration % 60;
2753                         snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
2754                 }
2755
2756                 astman_append(s,
2757                         "Channel: %s\r\n"
2758                         "UniqueID: %s\r\n"
2759                         "Context: %s\r\n"
2760                         "Extension: %s\r\n"
2761                         "Priority: %d\r\n"
2762                         "ChannelState: %d\r\n"
2763                         "ChannelStateDesc: %s\r\n"
2764                         "Application: %s\r\n"
2765                         "ApplicationData: %s\r\n"
2766                         "CallerIDnum: %s\r\n"
2767                         "Duration: %s\r\n"
2768                         "AccountCode: %s\r\n"
2769                         "BridgedChannel: %s\r\n"
2770                         "BridgedUniqueID: %s\r\n"
2771                         "\r\n", c->name, c->uniqueid, c->context, c->exten, c->priority, c->_state, ast_state2str(c->_state),
2772                         c->appl ? c->appl : "", c->data ? S_OR(c->data, ""): "",
2773                         S_OR(c->cid.cid_num, ""), durbuf, S_OR(c->accountcode, ""), bc ? bc->name : "", bc ? bc->uniqueid : "");
2774                 ast_channel_unlock(c);
2775                 numchans++;
2776         }
2777
2778         astman_append(s,
2779                 "Event: CoreShowChannelsComplete\r\n"
2780                 "EventList: Complete\r\n"
2781                 "ListItems: %d\r\n"
2782                 "%s"
2783                 "\r\n", numchans, actionidtext);
2784
2785         return 0;
2786 }
2787
2788 static char mandescr_modulecheck[] = 
2789 "Description: Checks if Asterisk module is loaded\n"
2790 "Variables: \n"
2791 "  ActionID: <id>          Action ID for this transaction. Will be returned.\n"
2792 "  Module: <name>          Asterisk module name (not including extension)\n"
2793 "\n"
2794 "Will return Success/Failure\n"
2795 "For success returns, the module revision number is included.\n";
2796
2797 /* Manager function to check if module is loaded */
2798 static int manager_modulecheck(struct mansession *s, const struct message *m)
2799 {
2800         int res;
2801         const char *module = astman_get_header(m, "Module");
2802         const char *id = astman_get_header(m, "ActionID");
2803         char idText[256];
2804 #if !defined(LOW_MEMORY)
2805         const char *version;
2806 #endif
2807         char filename[PATH_MAX];
2808         char *cut;
2809
2810         ast_copy_string(filename, module, sizeof(filename));
2811         if ((cut = strchr(filename, '.'))) {
2812                 *cut = '\0';
2813         } else {
2814                 cut = filename + strlen(filename);
2815         }
2816         snprintf(cut, (sizeof(filename) - strlen(filename)) - 1, ".so");
2817         ast_log(LOG_DEBUG, "**** ModuleCheck .so file %s\n", filename);
2818         res = ast_module_check(filename);
2819         if (!res) {
2820                 astman_send_error(s, m, "Module not loaded");
2821                 return 0;
2822         }
2823         snprintf(cut, (sizeof(filename) - strlen(filename)) - 1, ".c");
2824         ast_log(LOG_DEBUG, "**** ModuleCheck .c file %s\n", filename);
2825 #if !defined(LOW_MEMORY)
2826         version = ast_file_version_find(filename);
2827 #endif
2828
2829         if (!ast_strlen_zero(id))
2830                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
2831         else
2832                 idText[0] = '\0';
2833         astman_append(s, "Response: Success\r\n%s", idText);
2834 #if !defined(LOW_MEMORY)
2835         astman_append(s, "Version: %s\r\n\r\n", version ? version : "");
2836 #endif
2837         return 0;
2838 }
2839
2840 static char mandescr_moduleload[] = 
2841 "Description: Loads, unloads or reloads an Asterisk module in a running system.\n"
2842 "Variables: \n"
2843 "  ActionID: <id>          Action ID for this transaction. Will be returned.\n"
2844 "  Module: <name>          Asterisk module name (including .so extension)\n"
2845 "                          or subsystem identifier:\n"
2846 "                               cdr, enum, dnsmgr, extconfig, manager, rtp, http\n"
2847 "  LoadType: load | unload | reload\n"
2848 "                          The operation to be done on module\n"
2849 " If no module is specified for a reload loadtype, all modules are reloaded";
2850
2851 static int manager_moduleload(struct mansession *s, const struct message *m)
2852 {
2853         int res;
2854         const char *module = astman_get_header(m, "Module");
2855         const char *loadtype = astman_get_header(m, "LoadType");
2856
2857         if (!loadtype || strlen(loadtype) == 0)
2858                 astman_send_error(s, m, "Incomplete ModuleLoad action.");
2859         if ((!module || strlen(module) == 0) && strcasecmp(loadtype, "reload") != 0)
2860                 astman_send_error(s, m, "Need module name");
2861
2862         if (!strcasecmp(loadtype, "load")) {
2863                 res = ast_load_resource(module);
2864                 if (res)
2865                         astman_send_error(s, m, "Could not load module.");
2866                 else
2867                         astman_send_ack(s, m, "Module loaded.");
2868         } else if (!strcasecmp(loadtype, "unload")) {
2869                 res = ast_unload_resource(module, AST_FORCE_SOFT);
2870                 if (res)
2871                         astman_send_error(s, m, "Could not unload module.");
2872                 else
2873                         astman_send_ack(s, m, "Module unloaded.");
2874         } else if (!strcasecmp(loadtype, "reload")) {
2875                 if (module != NULL) {
2876                         res = ast_module_reload(module);
2877                         if (res == 0)
2878                                 astman_send_error(s, m, "No such module.");
2879                         else if (res == 1)
2880                                 astman_send_error(s, m, "Module does not support reload action.");
2881                         else
2882                                 astman_send_ack(s, m, "Module reloaded.");
2883                 } else {
2884                         ast_module_reload(NULL);        /* Reload all modules */
2885                         astman_send_ack(s, m, "All modules reloaded");
2886                 }
2887         } else 
2888                 astman_send_error(s, m, "Incomplete ModuleLoad action.");
2889         return 0;
2890 }
2891
2892 /*
2893  * Done with the action handlers here, we start with the code in charge
2894  * of accepting connections and serving them.
2895  * accept_thread() forks a new thread for each connection, session_do(),
2896  * which in turn calls get_input() repeatedly until a full message has
2897  * been accumulated, and then invokes process_message() to pass it to
2898  * the appropriate handler.
2899  */
2900
2901 /*
2902  * Process an AMI message, performing desired action.
2903  * Return 0 on success, -1 on error that require the session to be destroyed.
2904  */
2905 static int process_message(struct mansession *s, const struct message *m)
2906 {
2907         char action[80] = "";
2908         int ret = 0;
2909         struct manager_action *tmp;
2910         const char *user = astman_get_header(m, "Username");
2911
2912         ast_copy_string(action, __astman_get_header(m, "Action", GET_HEADER_SKIP_EMPTY), sizeof(action));
2913         ast_debug(1, "Manager received command '%s'\n", action);
2914
2915         if (ast_strlen_zero(action)) {
2916                 ast_mutex_lock(&s->__lock);
2917                 astman_send_error(s, m, "Missing action in request");
2918                 ast_mutex_unlock(&s->__lock);
2919                 return 0;
2920         }
2921
2922         if (!s->authenticated && strcasecmp(action, "Login") && strcasecmp(action, "Logoff") && strcasecmp(action, "Challenge")) {
2923                 ast_mutex_lock(&s->__lock);
2924                 astman_send_error(s, m, "Permission denied");
2925                 ast_mutex_unlock(&s->__lock);
2926                 return 0;
2927         }
2928
2929         if (!allowmultiplelogin && !s->authenticated && user &&
2930                 (!strcasecmp(action, "Login") || !strcasecmp(action, "Challenge"))) {
2931                 if (check_manager_session_inuse(user)) {
2932                         sleep(1);
2933                         ast_mutex_lock(&s->__lock);
2934                         astman_send_error(s, m, "Login Already In Use");
2935                         ast_mutex_unlock(&s->__lock);
2936                         return -1;
2937                 }
2938         }
2939
2940         AST_RWLIST_RDLOCK(&actions);
2941         AST_RWLIST_TRAVERSE(&actions, tmp, list) {
2942                 if (strcasecmp(action, tmp->action))
2943                         continue;
2944                 if (s->writeperm & tmp->authority || tmp->authority == 0)
2945                         ret = tmp->func(s, m);
2946                 else
2947                         astman_send_error(s, m, "Permission denied");
2948                 break;
2949         }
2950         AST_RWLIST_UNLOCK(&actions);
2951
2952         if (!tmp) {
2953                 char buf[512];
2954                 snprintf(buf, sizeof(buf), "Invalid/unknown command: %s. Use Action: ListCommands to show available commands.", action);
2955                 ast_mutex_lock(&s->__lock);
2956                 astman_send_error(s, m, buf);
2957                 ast_mutex_unlock(&s->__lock);
2958         }
2959         if (ret)
2960                 return ret;
2961         /* Once done with our message, deliver any pending events */
2962         return process_events(s);
2963 }
2964
2965 /*!
2966  * Read one full line (including crlf) from the manager socket.
2967  * \note \verbatim
2968  * \r\n is the only valid terminator for the line.
2969  * (Note that, later, '\0' will be considered as the end-of-line marker,
2970  * so everything between the '\0' and the '\r\n' will not be used).
2971  * Also note that we assume output to have at least "maxlen" space.
2972  * \endverbatim
2973  */
2974 static int get_input(struct mansession *s, char *output)
2975 {
2976         int res, x;
2977         int maxlen = sizeof(s->inbuf) - 1;
2978         char *src = s->inbuf;
2979
2980         /*
2981          * Look for \r\n within the buffer. If found, copy to the output
2982          * buffer and return, trimming the \r\n (not used afterwards).
2983          */
2984         for (x = 0; x < s->inlen; x++) {
2985                 int cr; /* set if we have \r */
2986                 if (src[x] == '\r' && x+1 < s->inlen && src[x+1] == '\n')
2987                         cr = 2; /* Found. Update length to include \r\n */
2988                 else if (src[x] == '\n')
2989                         cr = 1; /* also accept \n only */
2990                 else
2991                         continue;
2992                 memmove(output, src, x);        /*... but trim \r\n */
2993                 output[x] = '\0';               /* terminate the string */
2994                 x += cr;                        /* number of bytes used */
2995                 s->inlen -= x;                  /* remaining size */
2996                 memmove(src, src + x, s->inlen); /* remove used bytes */
2997                 return 1;
2998         }
2999         if (s->inlen >= maxlen) {
3000                 /* no crlf found, and buffer full - sorry, too long for us */
3001                 ast_log(LOG_WARNING, "Dumping long line with no return from %s: %s\n", ast_inet_ntoa(s->sin.sin_addr), src);
3002                 s->inlen = 0;
3003         }
3004         res = 0;
3005         while (res == 0) {
3006                 /* XXX do we really need this locking ? */
3007                 ast_mutex_lock(&s->__lock);
3008                 if (s->pending_event) {
3009                         s->pending_event = 0;
3010                         ast_mutex_unlock(&s->__lock);
3011                         return 0;
3012                 }
3013                 s->waiting_thread = pthread_self();
3014                 ast_mutex_unlock(&s->__lock);
3015
3016                 res = ast_wait_for_input(s->fd, -1);    /* return 0 on timeout ? */
3017
3018                 ast_mutex_lock(&s->__lock);
3019                 s->waiting_thread = AST_PTHREADT_NULL;
3020                 ast_mutex_unlock(&s->__lock);
3021         }
3022         if (res < 0) {
3023                 /* If we get a signal from some other thread (typically because
3024                  * there are new events queued), return 0 to notify the caller.
3025                  */
3026                 if (errno == EINTR || errno == EAGAIN)
3027                         return 0;
3028                 ast_log(LOG_WARNING, "poll() returned error: %s\n", strerror(errno));
3029                 return -1;
3030         }
3031         ast_mutex_lock(&s->__lock);
3032         res = fread(src + s->inlen, 1, maxlen - s->inlen, s->f);
3033         if (res < 1)
3034                 res = -1;       /* error return */
3035         else {
3036                 s->inlen += res;
3037                 src[s->inlen] = '\0';
3038                 res = 0;
3039         }
3040         ast_mutex_unlock(&s->__lock);
3041         return res;
3042 }
3043
3044 static int do_message(struct mansession *s)
3045 {
3046         struct message m = { 0 };
3047         char header_buf[sizeof(s->inbuf)] = { '\0' };
3048         int res;
3049
3050         for (;;) {
3051                 /* Check if any events are pending and do them if needed */
3052                 if (process_events(s))
3053                         return -1;
3054                 res = get_input(s, header_buf);
3055                 if (res == 0) {
3056                         continue;
3057                 } else if (res > 0) {
3058                         if (ast_strlen_zero(header_buf))
3059                                 return process_message(s, &m) ? -1 : 0;
3060                         else if (m.hdrcount < (AST_MAX_MANHEADERS - 1))
3061                                 m.headers[m.hdrcount++] = ast_strdupa(header_buf);
3062                 } else {
3063                         return res;
3064                 }
3065         }
3066 }
3067
3068 /*! \brief The body of the individual manager session.
3069  * Call get_input() to read one line at a time
3070  * (or be woken up on new events), collect the lines in a
3071  * message until found an empty line, and execute the request.
3072  * In any case, deliver events asynchronously through process_events()
3073  * (called from here if no line is available, or at the end of
3074  * process_message(). )
3075  */
3076 static void *session_do(void *data)
3077 {
3078         struct ast_tcptls_session_instance *ser = data;
3079         struct mansession *s = ast_calloc(1, sizeof(*s));
3080         int flags;
3081         int res;
3082
3083         if (s == NULL)
3084                 goto done;
3085
3086         s->writetimeout = 100;
3087         s->waiting_thread = AST_PTHREADT_NULL;
3088
3089         flags = fcntl(ser->fd, F_GETFL);
3090         if (!block_sockets) /* make sure socket is non-blocking */
3091                 flags |= O_NONBLOCK;
3092         else
3093                 flags &= ~O_NONBLOCK;
3094         fcntl(ser->fd, F_SETFL, flags);
3095
3096         ast_mutex_init(&s->__lock);
3097         s->send_events = -1;
3098         /* Hook to the tail of the event queue */
3099         s->last_ev = grab_last();
3100
3101         /* these fields duplicate those in the 'ser' structure */
3102         s->fd = ser->fd;
3103         s->f = ser->f;
3104         s->sin = ser->requestor;
3105
3106         AST_LIST_HEAD_INIT_NOLOCK(&s->datastores);
3107
3108         AST_LIST_LOCK(&sessions);
3109         AST_LIST_INSERT_HEAD(&sessions, s, list);
3110         ast_atomic_fetchadd_int(&num_sessions, 1);
3111         AST_LIST_UNLOCK(&sessions);
3112
3113         astman_append(s, "Asterisk Call Manager/%s\r\n", AMI_VERSION);  /* welcome prompt */
3114         for (;;) {
3115                 if ((res = do_message(s)) < 0)
3116                         break;
3117         }
3118         /* session is over, explain why and terminate */
3119         if (s->authenticated) {
3120                         if (manager_displayconnects(s))
3121                         ast_verb(2, "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr));
3122                 ast_log(LOG_EVENT, "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr));
3123         } else {
3124                         if (displayconnects)
3125                         ast_verb(2, "Connect attempt from '%s' unable to authenticate\n", ast_inet_ntoa(s->sin.sin_addr));
3126                 ast_log(LOG_EVENT, "Failed attempt from %s\n", ast_inet_ntoa(s->sin.sin_addr));
3127         }
3128
3129         /* It is possible under certain circumstances for this session thread
3130            to complete its work and exit *before* the thread that created it
3131            has finished executing the ast_pthread_create_background() function.
3132            If this occurs, some versions of glibc appear to act in a buggy
3133            fashion and attempt to write data into memory that it thinks belongs
3134            to the thread but is in fact not owned by the thread (or may have
3135            been freed completely).
3136
3137            Causing this thread to yield to other threads at least one time
3138            appears to work around this bug.
3139         */
3140         usleep(1);
3141
3142         destroy_session(s);
3143
3144 done:
3145         ao2_ref(ser, -1);
3146         ser = NULL;
3147         return NULL;
3148 }
3149
3150 /*! \brief remove at most n_max stale session from the list. */
3151 static void purge_sessions(int n_max)
3152 {
3153         struct mansession *s;
3154         time_t now = time(NULL);
3155
3156         AST_LIST_LOCK(&sessions);
3157         AST_LIST_TRAVERSE_SAFE_BEGIN(&sessions, s, list) {
3158                 if (s->sessiontimeout && (now > s->sessiontimeout) && !s->inuse) {
3159                         AST_LIST_REMOVE_CURRENT(list);
3160                         ast_atomic_fetchadd_int(&num_sessions, -1);
3161                         if (s->authenticated && (VERBOSITY_ATLEAST(2)) && manager_displayconnects(s)) {
3162                                 ast_verb(2, "HTTP Manager '%s' timed out from %s\n",
3163                                         s->username, ast_inet_ntoa(s->sin.sin_addr));
3164                         }
3165                         free_session(s);        /* XXX outside ? */
3166                         if (--n_max <= 0)
3167                                 break;
3168                 }
3169         }
3170         AST_LIST_TRAVERSE_SAFE_END;
3171         AST_LIST_UNLOCK(&sessions);
3172 }
3173
3174 /*
3175  * events are appended to a queue from where they
3176  * can be dispatched to clients.
3177  */
3178 static int append_event(const char *str, int category)
3179 {
3180         struct eventqent *tmp = ast_malloc(sizeof(*tmp) + strlen(str));
3181         static int seq; /* sequence number */
3182
3183         if (!tmp)
3184                 return -1;
3185
3186         /* need to init all fields, because ast_malloc() does not */
3187         tmp->usecount = 0;
3188         tmp->category = category;
3189         tmp->seq = ast_atomic_fetchadd_int(&seq, 1);
3190         AST_LIST_NEXT(tmp, eq_next) = NULL;
3191         strcpy(tmp->eventdata, str);
3192
3193         AST_LIST_LOCK(&all_events);
3194         AST_LIST_INSERT_TAIL(&all_events, tmp, eq_next);
3195         AST_LIST_UNLOCK(&all_events);
3196
3197         return 0;
3198 }
3199
3200 /* XXX see if can be moved inside the function */
3201 AST_THREADSTORAGE(manager_event_buf);
3202 #define MANAGER_EVENT_BUF_INITSIZE   256
3203
3204 /*! \brief  manager_event: Send AMI event to client */
3205 int __manager_event(int category, const char *event,
3206         const char *file, int line, const char *func, const char *fmt, ...)
3207 {
3208         struct mansession *s;
3209         struct manager_custom_hook *hook;
3210         struct ast_str *auth = ast_str_alloca(80);
3211         const char *cat_str;
3212         va_list ap;
3213         struct timeval now;
3214         struct ast_str *buf;
3215
3216         /* Abort if there aren't any manager sessions */
3217         if (!num_sessions)
3218                 return 0;
3219
3220         if (!(buf = ast_str_thread_get(&manager_event_buf, MANAGER_EVENT_BUF_INITSIZE)))
3221                 return -1;
3222
3223         cat_str = authority_to_str(category, &auth);
3224         ast_str_set(&buf, 0,
3225                         "Event: %s\r\nPrivilege: %s\r\n",
3226                          event, cat_str);
3227
3228         if (timestampevents) {
3229                 now = ast_tvnow();
3230                 ast_str_append(&buf, 0,
3231                                 "Timestamp: %ld.%06lu\r\n",
3232                                  (long)now.tv_sec, (unsigned long) now.tv_usec);
3233         }
3234         if (manager_debug) {
3235                 static int seq;
3236                 ast_str_append(&buf, 0,