The priority was unnecessary for the manager atxfer, so it has
[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                 ast_func_read(c, (char *) varname, workspace, sizeof(workspace));
1809                 varval = workspace;
1810         } else {
1811                 pbx_retrieve_variable(c, varname, &varval, workspace, sizeof(workspace), NULL);
1812         }
1813
1814         if (c)
1815                 ast_channel_unlock(c);
1816         astman_start_ack(s, m);
1817         astman_append(s, "Variable: %s\r\nValue: %s\r\n\r\n", varname, varval);
1818
1819         return 0;
1820 }
1821
1822 static char mandescr_status[] = 
1823 "Description: Lists channel status along with requested channel vars.\n"
1824 "Variables: (Names marked with * are required)\n"
1825 "       *Channel: Name of the channel to query for status\n"
1826 "       Variables: Comma ',' separated list of variables to include\n"
1827 "       ActionID: Optional ID for this transaction\n"
1828 "Will return the status information of each channel along with the\n"
1829 "value for the specified channel variables.\n";
1830  
1831
1832 /*! \brief Manager "status" command to show channels */
1833 /* Needs documentation... */
1834 static int action_status(struct mansession *s, const struct message *m)
1835 {
1836         const char *name = astman_get_header(m, "Channel");
1837         const char *cvariables = astman_get_header(m, "Variables");
1838         char *variables = ast_strdupa(S_OR(cvariables, ""));
1839         struct ast_channel *c;
1840         char bridge[256];
1841         struct timeval now = ast_tvnow();
1842         long elapsed_seconds = 0;
1843         int channels = 0;
1844         int all = ast_strlen_zero(name); /* set if we want all channels */
1845         const char *id = astman_get_header(m, "ActionID");
1846         char idText[256];
1847         AST_DECLARE_APP_ARGS(vars,
1848                 AST_APP_ARG(name)[100];
1849         );
1850         struct ast_str *str = ast_str_create(1000);
1851
1852         if (!ast_strlen_zero(id))
1853                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
1854         else
1855                 idText[0] = '\0';
1856
1857         if (all)
1858                 c = ast_channel_walk_locked(NULL);
1859         else {
1860                 c = ast_get_channel_by_name_locked(name);
1861                 if (!c) {
1862                         astman_send_error(s, m, "No such channel");
1863                         return 0;
1864                 }
1865         }
1866         astman_send_ack(s, m, "Channel status will follow");
1867
1868         if (!ast_strlen_zero(cvariables)) {
1869                 AST_STANDARD_APP_ARGS(vars, variables);
1870         }
1871
1872         /* if we look by name, we break after the first iteration */
1873         while (c) {
1874                 if (!ast_strlen_zero(cvariables)) {
1875                         int i;
1876                         ast_str_reset(str);
1877                         for (i = 0; i < vars.argc; i++) {
1878                                 char valbuf[512], *ret = NULL;
1879
1880                                 if (vars.name[i][strlen(vars.name[i]) - 1] == ')') {
1881                                         if (ast_func_read(c, vars.name[i], valbuf, sizeof(valbuf)) < 0) {
1882                                                 valbuf[0] = '\0';
1883                                         }
1884                                         ret = valbuf;
1885                                 } else {
1886                                         pbx_retrieve_variable(c, vars.name[i], &ret, valbuf, sizeof(valbuf), NULL);
1887                                 }
1888
1889                                 ast_str_append(&str, 0, "Variable: %s=%s\r\n", vars.name[i], ret);
1890                         }
1891                 }
1892
1893                 channels++;
1894                 if (c->_bridge)
1895                         snprintf(bridge, sizeof(bridge), "BridgedChannel: %s\r\nBridgedUniqueid: %s\r\n", c->_bridge->name, c->_bridge->uniqueid);
1896                 else
1897                         bridge[0] = '\0';
1898                 if (c->pbx) {
1899                         if (c->cdr) {
1900                                 elapsed_seconds = now.tv_sec - c->cdr->start.tv_sec;
1901                         }
1902                         astman_append(s,
1903                         "Event: Status\r\n"
1904                         "Privilege: Call\r\n"
1905                         "Channel: %s\r\n"
1906                         "CallerIDNum: %s\r\n"
1907                         "CallerIDName: %s\r\n"
1908                         "Accountcode: %s\r\n"
1909                         "ChannelState: %d\r\n"
1910                         "ChannelStateDesc: %s\r\n"
1911                         "Context: %s\r\n"
1912                         "Extension: %s\r\n"
1913                         "Priority: %d\r\n"
1914                         "Seconds: %ld\r\n"
1915                         "%s"
1916                         "Uniqueid: %s\r\n"
1917                         "%s"
1918                         "%s"
1919                         "\r\n",
1920                         c->name,
1921                         S_OR(c->cid.cid_num, ""),
1922                         S_OR(c->cid.cid_name, ""),
1923                         c->accountcode,
1924                         c->_state,
1925                         ast_state2str(c->_state), c->context,
1926                         c->exten, c->priority, (long)elapsed_seconds, bridge, c->uniqueid, str->str, idText);
1927                 } else {
1928                         astman_append(s,
1929                         "Event: Status\r\n"
1930                         "Privilege: Call\r\n"
1931                         "Channel: %s\r\n"
1932                         "CallerIDNum: %s\r\n"
1933                         "CallerIDName: %s\r\n"
1934                         "Account: %s\r\n"
1935                         "State: %s\r\n"
1936                         "%s"
1937                         "Uniqueid: %s\r\n"
1938                         "%s"
1939                         "%s"
1940                         "\r\n",
1941                         c->name,
1942                         S_OR(c->cid.cid_num, "<unknown>"),
1943                         S_OR(c->cid.cid_name, "<unknown>"),
1944                         c->accountcode,
1945                         ast_state2str(c->_state), bridge, c->uniqueid, str->str, idText);
1946                 }
1947                 ast_channel_unlock(c);
1948                 if (!all)
1949                         break;
1950                 c = ast_channel_walk_locked(c);
1951         }
1952         astman_append(s,
1953         "Event: StatusComplete\r\n"
1954         "%s"
1955         "Items: %d\r\n"
1956         "\r\n", idText, channels);
1957         ast_free(str);
1958         return 0;
1959 }
1960
1961 static char mandescr_sendtext[] =
1962 "Description: Sends A Text Message while in a call.\n"
1963 "Variables: (Names marked with * are required)\n"
1964 "       *Channel: Channel to send message to\n"
1965 "       *Message: Message to send\n"
1966 "       ActionID: Optional Action id for message matching.\n";
1967
1968 static int action_sendtext(struct mansession *s, const struct message *m)
1969 {
1970         struct ast_channel *c = NULL;
1971         const char *name = astman_get_header(m, "Channel");
1972         const char *textmsg = astman_get_header(m, "Message");
1973         int res = 0;
1974
1975         if (ast_strlen_zero(name)) {
1976                 astman_send_error(s, m, "No channel specified");
1977                 return 0;
1978         }
1979
1980         if (ast_strlen_zero(textmsg)) {
1981                 astman_send_error(s, m, "No Message specified");
1982                 return 0;
1983         }
1984
1985         c = ast_get_channel_by_name_locked(name);
1986         if (!c) {
1987                 astman_send_error(s, m, "No such channel");
1988                 return 0;
1989         }
1990
1991         res = ast_sendtext(c, textmsg);
1992         ast_channel_unlock(c);
1993         
1994         if (res > 0)
1995                 astman_send_ack(s, m, "Success");
1996         else
1997                 astman_send_error(s, m, "Failure");
1998         
1999         return res;
2000 }
2001
2002 static char mandescr_redirect[] =
2003 "Description: Redirect (transfer) a call.\n"
2004 "Variables: (Names marked with * are required)\n"
2005 "       *Channel: Channel to redirect\n"
2006 "       ExtraChannel: Second call leg to transfer (optional)\n"
2007 "       *Exten: Extension to transfer to\n"
2008 "       *Context: Context to transfer to\n"
2009 "       *Priority: Priority to transfer to\n"
2010 "       ActionID: Optional Action id for message matching.\n";
2011
2012 /*! \brief  action_redirect: The redirect manager command */
2013 static int action_redirect(struct mansession *s, const struct message *m)
2014 {
2015         const char *name = astman_get_header(m, "Channel");
2016         const char *name2 = astman_get_header(m, "ExtraChannel");
2017         const char *exten = astman_get_header(m, "Exten");
2018         const char *context = astman_get_header(m, "Context");
2019         const char *priority = astman_get_header(m, "Priority");
2020         struct ast_channel *chan, *chan2 = NULL;
2021         int pi = 0;
2022         int res;
2023
2024         if (ast_strlen_zero(name)) {
2025                 astman_send_error(s, m, "Channel not specified");
2026                 return 0;
2027         }
2028         if (!ast_strlen_zero(priority) && (sscanf(priority, "%d", &pi) != 1)) {
2029                 if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) {
2030                         astman_send_error(s, m, "Invalid priority");
2031                         return 0;
2032                 }
2033         }
2034         /* XXX watch out, possible deadlock - we are trying to get two channels!!! */
2035         chan = ast_get_channel_by_name_locked(name);
2036         if (!chan) {
2037                 char buf[256];
2038                 snprintf(buf, sizeof(buf), "Channel does not exist: %s", name);
2039                 astman_send_error(s, m, buf);
2040                 return 0;
2041         }
2042         if (ast_check_hangup(chan)) {
2043                 astman_send_error(s, m, "Redirect failed, channel not up.");
2044                 ast_channel_unlock(chan);
2045                 return 0;
2046         }
2047         if (!ast_strlen_zero(name2))
2048                 chan2 = ast_get_channel_by_name_locked(name2);
2049         if (chan2 && ast_check_hangup(chan2)) {
2050                 astman_send_error(s, m, "Redirect failed, extra channel not up.");
2051                 ast_channel_unlock(chan);
2052                 ast_channel_unlock(chan2);
2053                 return 0;
2054         }
2055         res = ast_async_goto(chan, context, exten, pi);
2056         if (!res) {
2057                 if (!ast_strlen_zero(name2)) {
2058                         if (chan2)
2059                                 res = ast_async_goto(chan2, context, exten, pi);
2060                         else
2061                                 res = -1;
2062                         if (!res)
2063                                 astman_send_ack(s, m, "Dual Redirect successful");
2064                         else
2065                                 astman_send_error(s, m, "Secondary redirect failed");
2066                 } else
2067                         astman_send_ack(s, m, "Redirect successful");
2068         } else
2069                 astman_send_error(s, m, "Redirect failed");
2070         if (chan)
2071                 ast_channel_unlock(chan);
2072         if (chan2)
2073                 ast_channel_unlock(chan2);
2074         return 0;
2075 }
2076
2077 static char mandescr_atxfer[] =
2078 "Description: Attended transfer.\n"
2079 "Variables: (Names marked with * are required)\n"
2080 "       *Channel: Transferer's channel\n"
2081 "       *Exten: Extension to transfer to\n"
2082 "       *Context: Context to transfer to\n"
2083 "       *Priority: Priority to transfer to\n"
2084 "       ActionID: Optional Action id for message matching.\n";
2085
2086 static int action_atxfer(struct mansession *s, const struct message *m)
2087 {
2088         const char *name = astman_get_header(m, "Channel");
2089         const char *exten = astman_get_header(m, "Exten");
2090         const char *context = astman_get_header(m, "Context");
2091         struct ast_channel *chan = NULL;
2092         struct ast_call_feature *atxfer_feature = NULL;
2093         char *feature_code = NULL;
2094
2095         if (ast_strlen_zero(name)) { 
2096                 astman_send_error(s, m, "No channel specified");
2097                 return 0;
2098         }
2099         if (ast_strlen_zero(exten)) {
2100                 astman_send_error(s, m, "No extension specified");
2101                 return 0;
2102         }
2103
2104         if (!(atxfer_feature = ast_find_call_feature("atxfer"))) {
2105                 astman_send_error(s, m, "No attended transfer feature found");
2106                 return 0;
2107         }
2108
2109         if (!(chan = ast_get_channel_by_name_locked(name))) {
2110                 astman_send_error(s, m, "Channel specified does not exist");
2111                 return 0;
2112         }
2113
2114         if (!ast_strlen_zero(context)) {
2115                 pbx_builtin_setvar_helper(chan, "TRANSFER_CONTEXT", context);
2116         }
2117
2118         for (feature_code = atxfer_feature->exten; feature_code && *feature_code; ++feature_code) {
2119                 struct ast_frame f = {AST_FRAME_DTMF, *feature_code};
2120                 ast_queue_frame(chan, &f);
2121         }
2122
2123         for (feature_code = (char *)exten; feature_code && *feature_code; ++feature_code) {
2124                 struct ast_frame f = {AST_FRAME_DTMF, *feature_code};
2125                 ast_queue_frame(chan, &f);
2126         }
2127
2128         astman_send_ack(s, m, "Atxfer successfully queued");
2129         ast_channel_unlock(chan);
2130
2131         return 0;
2132 }
2133
2134 static int check_blacklist(const char *cmd)
2135 {
2136         char *cmd_copy, *cur_cmd;
2137         char *cmd_words[MAX_BLACKLIST_CMD_LEN] = { NULL, };
2138         int i;
2139
2140         cmd_copy = ast_strdupa(cmd);
2141         for (i = 0; i < MAX_BLACKLIST_CMD_LEN && (cur_cmd = strsep(&cmd_copy, " ")); i++) {
2142                 cur_cmd = ast_strip(cur_cmd);
2143                 if (ast_strlen_zero(cur_cmd)) {
2144                         i--;
2145                         continue;
2146                 }
2147
2148                 cmd_words[i] = cur_cmd;
2149         }
2150
2151         for (i = 0; i < ARRAY_LEN(command_blacklist); i++) {
2152                 int j, match = 1;
2153
2154                 for (j = 0; command_blacklist[i].words[j]; j++) {
2155                         if (ast_strlen_zero(cmd_words[j]) || strcasecmp(cmd_words[j], command_blacklist[i].words[j])) {
2156                                 match = 0;
2157                                 break;
2158                         }
2159                 }
2160
2161                 if (match) {
2162                         return 1;
2163                 }
2164         }
2165
2166         return 0;
2167 }
2168
2169 static char mandescr_command[] =
2170 "Description: Run a CLI command.\n"
2171 "Variables: (Names marked with * are required)\n"
2172 "       *Command: Asterisk CLI command to run\n"
2173 "       ActionID: Optional Action id for message matching.\n";
2174
2175 /*! \brief  Manager command "command" - execute CLI command */
2176 static int action_command(struct mansession *s, const struct message *m)
2177 {
2178         const char *cmd = astman_get_header(m, "Command");
2179         const char *id = astman_get_header(m, "ActionID");
2180         char *buf, *final_buf;
2181         char template[] = "/tmp/ast-ami-XXXXXX";        /* template for temporary file */
2182         int fd = mkstemp(template);
2183         off_t l;
2184
2185         if (ast_strlen_zero(cmd)) {
2186                 astman_send_error(s, m, "No command provided");
2187                 return 0;
2188         }
2189
2190         if (check_blacklist(cmd)) {
2191                 astman_send_error(s, m, "Command blacklisted");
2192                 return 0;
2193         }
2194
2195         astman_append(s, "Response: Follows\r\nPrivilege: Command\r\n");
2196         if (!ast_strlen_zero(id))
2197                 astman_append(s, "ActionID: %s\r\n", id);
2198         /* FIXME: Wedge a ActionID response in here, waiting for later changes */
2199         ast_cli_command(fd, cmd);       /* XXX need to change this to use a FILE * */
2200         l = lseek(fd, 0, SEEK_END);     /* how many chars available */
2201
2202         /* This has a potential to overflow the stack.  Hence, use the heap. */
2203         buf = ast_calloc(1, l + 1);
2204         final_buf = ast_calloc(1, l + 1);
2205         if (buf) {
2206                 lseek(fd, 0, SEEK_SET);
2207                 read(fd, buf, l);
2208                 buf[l] = '\0';
2209                 if (final_buf) {
2210                         term_strip(final_buf, buf, l);
2211                         final_buf[l] = '\0';
2212                 }
2213                 astman_append(s, "%s", S_OR(final_buf, buf));
2214                 ast_free(buf);
2215         }
2216         close(fd);
2217         unlink(template);
2218         astman_append(s, "--END COMMAND--\r\n\r\n");
2219         if (final_buf)
2220                 ast_free(final_buf);
2221         return 0;
2222 }
2223
2224 /*! \brief helper function for originate */
2225 struct fast_originate_helper {
2226         char tech[AST_MAX_EXTENSION];
2227         char data[AST_MAX_EXTENSION];
2228         int timeout;
2229         int format;                             /*!< Codecs used for a call */
2230         char app[AST_MAX_APP];
2231         char appdata[AST_MAX_EXTENSION];
2232         char cid_name[AST_MAX_EXTENSION];
2233         char cid_num[AST_MAX_EXTENSION];
2234         char context[AST_MAX_CONTEXT];
2235         char exten[AST_MAX_EXTENSION];
2236         char idtext[AST_MAX_EXTENSION];
2237         char account[AST_MAX_ACCOUNT_CODE];
2238         int priority;
2239         struct ast_variable *vars;
2240 };
2241
2242 static void *fast_originate(void *data)
2243 {
2244         struct fast_originate_helper *in = data;
2245         int res;
2246         int reason = 0;
2247         struct ast_channel *chan = NULL;
2248         char requested_channel[AST_CHANNEL_NAME];
2249
2250         if (!ast_strlen_zero(in->app)) {
2251                 res = ast_pbx_outgoing_app(in->tech, in->format, in->data, in->timeout, in->app, in->appdata, &reason, 1,
2252                         S_OR(in->cid_num, NULL),
2253                         S_OR(in->cid_name, NULL),
2254                         in->vars, in->account, &chan);
2255         } else {
2256                 res = ast_pbx_outgoing_exten(in->tech, in->format, in->data, in->timeout, in->context, in->exten, in->priority, &reason, 1,
2257                         S_OR(in->cid_num, NULL),
2258                         S_OR(in->cid_name, NULL),
2259                         in->vars, in->account, &chan);
2260         }
2261
2262         if (!chan)
2263                 snprintf(requested_channel, AST_CHANNEL_NAME, "%s/%s", in->tech, in->data);     
2264         /* Tell the manager what happened with the channel */
2265         manager_event(EVENT_FLAG_CALL, "OriginateResponse",
2266                 "%s"
2267                 "Response: %s\r\n"
2268                 "Channel: %s\r\n"
2269                 "Context: %s\r\n"
2270                 "Exten: %s\r\n"
2271                 "Reason: %d\r\n"
2272                 "Uniqueid: %s\r\n"
2273                 "CallerIDNum: %s\r\n"
2274                 "CallerIDName: %s\r\n",
2275                 in->idtext, res ? "Failure" : "Success", chan ? chan->name : requested_channel, in->context, in->exten, reason, 
2276                 chan ? chan->uniqueid : "<null>",
2277                 S_OR(in->cid_num, "<unknown>"),
2278                 S_OR(in->cid_name, "<unknown>")
2279                 );
2280
2281         /* Locked by ast_pbx_outgoing_exten or ast_pbx_outgoing_app */
2282         if (chan)
2283                 ast_channel_unlock(chan);
2284         ast_free(in);
2285         return NULL;
2286 }
2287
2288 static char mandescr_originate[] =
2289 "Description: Generates an outgoing call to a Extension/Context/Priority or\n"
2290 "  Application/Data\n"
2291 "Variables: (Names marked with * are required)\n"
2292 "       *Channel: Channel name to call\n"
2293 "       Exten: Extension to use (requires 'Context' and 'Priority')\n"
2294 "       Context: Context to use (requires 'Exten' and 'Priority')\n"
2295 "       Priority: Priority to use (requires 'Exten' and 'Context')\n"
2296 "       Application: Application to use\n"
2297 "       Data: Data to use (requires 'Application')\n"
2298 "       Timeout: How long to wait for call to be answered (in ms)\n"
2299 "       CallerID: Caller ID to be set on the outgoing channel\n"
2300 "       Variable: Channel variable to set, multiple Variable: headers are allowed\n"
2301 "       Account: Account code\n"
2302 "       Async: Set to 'true' for fast origination\n";
2303
2304 static int action_originate(struct mansession *s, const struct message *m)
2305 {
2306         const char *name = astman_get_header(m, "Channel");
2307         const char *exten = astman_get_header(m, "Exten");
2308         const char *context = astman_get_header(m, "Context");
2309         const char *priority = astman_get_header(m, "Priority");
2310         const char *timeout = astman_get_header(m, "Timeout");
2311         const char *callerid = astman_get_header(m, "CallerID");
2312         const char *account = astman_get_header(m, "Account");
2313         const char *app = astman_get_header(m, "Application");
2314         const char *appdata = astman_get_header(m, "Data");
2315         const char *async = astman_get_header(m, "Async");
2316         const char *id = astman_get_header(m, "ActionID");
2317         const char *codecs = astman_get_header(m, "Codecs");
2318         struct ast_variable *vars = astman_get_variables(m);
2319         char *tech, *data;
2320         char *l = NULL, *n = NULL;
2321         int pi = 0;
2322         int res;
2323         int to = 30000;
2324         int reason = 0;
2325         char tmp[256];
2326         char tmp2[256];
2327         int format = AST_FORMAT_SLINEAR;
2328
2329         pthread_t th;
2330         if (ast_strlen_zero(name)) {
2331                 astman_send_error(s, m, "Channel not specified");
2332                 return 0;
2333         }
2334         if (!ast_strlen_zero(priority) && (sscanf(priority, "%d", &pi) != 1)) {
2335                 if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) {
2336                         astman_send_error(s, m, "Invalid priority");
2337                         return 0;
2338                 }
2339         }
2340         if (!ast_strlen_zero(timeout) && (sscanf(timeout, "%d", &to) != 1)) {
2341                 astman_send_error(s, m, "Invalid timeout");
2342                 return 0;
2343         }
2344         ast_copy_string(tmp, name, sizeof(tmp));
2345         tech = tmp;
2346         data = strchr(tmp, '/');
2347         if (!data) {
2348                 astman_send_error(s, m, "Invalid channel");
2349                 return 0;
2350         }
2351         *data++ = '\0';
2352         ast_copy_string(tmp2, callerid, sizeof(tmp2));
2353         ast_callerid_parse(tmp2, &n, &l);
2354         if (n) {
2355                 if (ast_strlen_zero(n))
2356                         n = NULL;
2357         }
2358         if (l) {
2359                 ast_shrink_phone_number(l);
2360                 if (ast_strlen_zero(l))
2361                         l = NULL;
2362         }
2363         if (!ast_strlen_zero(codecs)) {
2364                 format = 0;
2365                 ast_parse_allow_disallow(NULL, &format, codecs, 1);
2366         }
2367         if (ast_true(async)) {
2368                 struct fast_originate_helper *fast = ast_calloc(1, sizeof(*fast));
2369                 if (!fast) {
2370                         res = -1;
2371                 } else {
2372                         if (!ast_strlen_zero(id))
2373                                 snprintf(fast->idtext, sizeof(fast->idtext), "ActionID: %s\r\n", id);
2374                         ast_copy_string(fast->tech, tech, sizeof(fast->tech));
2375                         ast_copy_string(fast->data, data, sizeof(fast->data));
2376                         ast_copy_string(fast->app, app, sizeof(fast->app));
2377                         ast_copy_string(fast->appdata, appdata, sizeof(fast->appdata));
2378                         if (l)
2379                                 ast_copy_string(fast->cid_num, l, sizeof(fast->cid_num));
2380                         if (n)
2381                                 ast_copy_string(fast->cid_name, n, sizeof(fast->cid_name));
2382                         fast->vars = vars;
2383                         ast_copy_string(fast->context, context, sizeof(fast->context));
2384                         ast_copy_string(fast->exten, exten, sizeof(fast->exten));
2385                         ast_copy_string(fast->account, account, sizeof(fast->account));
2386                         fast->format = format;
2387                         fast->timeout = to;
2388                         fast->priority = pi;
2389                         if (ast_pthread_create_detached(&th, NULL, fast_originate, fast)) {
2390                                 ast_free(fast);
2391                                 res = -1;
2392                         } else {
2393                                 res = 0;
2394                         }
2395                 }
2396         } else if (!ast_strlen_zero(app)) {
2397                 /* To run the System application (or anything else that goes to shell), you must have the additional System privilege */
2398                 if (!(s->writeperm & EVENT_FLAG_SYSTEM)
2399                         && (
2400                                 strcasestr(app, "system") == 0 || /* System(rm -rf /)
2401                                                                      TrySystem(rm -rf /)       */
2402                                 strcasestr(app, "exec") ||        /* Exec(System(rm -rf /))
2403                                                                      TryExec(System(rm -rf /)) */
2404                                 strcasestr(app, "agi") ||         /* AGI(/bin/rm,-rf /)
2405                                                                      EAGI(/bin/rm,-rf /)       */
2406                                 strstr(appdata, "SHELL") ||       /* NoOp(${SHELL(rm -rf /)})  */
2407                                 strstr(appdata, "EVAL")           /* NoOp(${EVAL(${some_var_containing_SHELL})}) */
2408                                 )) {
2409                         astman_send_error(s, m, "Originate with certain 'Application' arguments requires the additional System privilege, which you do not have.");
2410                         return 0;
2411                 }
2412                 res = ast_pbx_outgoing_app(tech, format, data, to, app, appdata, &reason, 1, l, n, vars, account, NULL);
2413         } else {
2414                 if (exten && context && pi)
2415                         res = ast_pbx_outgoing_exten(tech, format, data, to, context, exten, pi, &reason, 1, l, n, vars, account, NULL);
2416                 else {
2417                         astman_send_error(s, m, "Originate with 'Exten' requires 'Context' and 'Priority'");
2418                         return 0;
2419                 }
2420         }
2421         if (!res)
2422                 astman_send_ack(s, m, "Originate successfully queued");
2423         else
2424                 astman_send_error(s, m, "Originate failed");
2425         return 0;
2426 }
2427
2428 /*! \brief Help text for manager command mailboxstatus
2429  */
2430 static char mandescr_mailboxstatus[] =
2431 "Description: Checks a voicemail account for status.\n"
2432 "Variables: (Names marked with * are required)\n"
2433 "       *Mailbox: Full mailbox ID <mailbox>@<vm-context>\n"
2434 "       ActionID: Optional ActionID for message matching.\n"
2435 "Returns number of messages.\n"
2436 "       Message: Mailbox Status\n"
2437 "       Mailbox: <mailboxid>\n"
2438 "       Waiting: <count>\n"
2439 "\n";
2440
2441 static int action_mailboxstatus(struct mansession *s, const struct message *m)
2442 {
2443         const char *mailbox = astman_get_header(m, "Mailbox");
2444         int ret;
2445
2446         if (ast_strlen_zero(mailbox)) {
2447                 astman_send_error(s, m, "Mailbox not specified");
2448                 return 0;
2449         }
2450         ret = ast_app_has_voicemail(mailbox, NULL);
2451         astman_start_ack(s, m);
2452         astman_append(s, "Message: Mailbox Status\r\n"
2453                          "Mailbox: %s\r\n"
2454                          "Waiting: %d\r\n\r\n", mailbox, ret);
2455         return 0;
2456 }
2457
2458 static char mandescr_mailboxcount[] =
2459 "Description: Checks a voicemail account for new messages.\n"
2460 "Variables: (Names marked with * are required)\n"
2461 "       *Mailbox: Full mailbox ID <mailbox>@<vm-context>\n"
2462 "       ActionID: Optional ActionID for message matching.\n"
2463 "Returns number of urgent, new and old messages.\n"
2464 "       Message: Mailbox Message Count\n"
2465 "       Mailbox: <mailboxid>\n"
2466 "       UrgentMessages: <count>\n"
2467 "       NewMessages: <count>\n"
2468 "       OldMessages: <count>\n"
2469 "\n";
2470 static int action_mailboxcount(struct mansession *s, const struct message *m)
2471 {
2472         const char *mailbox = astman_get_header(m, "Mailbox");
2473         int newmsgs = 0, oldmsgs = 0, urgentmsgs = 0;;
2474
2475         if (ast_strlen_zero(mailbox)) {
2476                 astman_send_error(s, m, "Mailbox not specified");
2477                 return 0;
2478         }
2479         ast_app_inboxcount2(mailbox, &urgentmsgs, &newmsgs, &oldmsgs);
2480         astman_start_ack(s, m);
2481         astman_append(s,   "Message: Mailbox Message Count\r\n"
2482                            "Mailbox: %s\r\n"
2483                            "UrgMessages: %d\r\n"
2484                            "NewMessages: %d\r\n"
2485                            "OldMessages: %d\r\n"
2486                            "\r\n",
2487                            mailbox, urgentmsgs, newmsgs, oldmsgs);
2488         return 0;
2489 }
2490
2491 static char mandescr_extensionstate[] =
2492 "Description: Report the extension state for given extension.\n"
2493 "  If the extension has a hint, will use devicestate to check\n"
2494 "  the status of the device connected to the extension.\n"
2495 "Variables: (Names marked with * are required)\n"
2496 "       *Exten: Extension to check state on\n"
2497 "       *Context: Context for extension\n"
2498 "       ActionId: Optional ID for this transaction\n"
2499 "Will return an \"Extension Status\" message.\n"
2500 "The response will include the hint for the extension and the status.\n";
2501
2502 static int action_extensionstate(struct mansession *s, const struct message *m)
2503 {
2504         const char *exten = astman_get_header(m, "Exten");
2505         const char *context = astman_get_header(m, "Context");
2506         char hint[256] = "";
2507         int status;
2508         if (ast_strlen_zero(exten)) {
2509                 astman_send_error(s, m, "Extension not specified");
2510                 return 0;
2511         }
2512         if (ast_strlen_zero(context))
2513                 context = "default";
2514         status = ast_extension_state(NULL, context, exten);
2515         ast_get_hint(hint, sizeof(hint) - 1, NULL, 0, NULL, context, exten);
2516         astman_start_ack(s, m);
2517         astman_append(s,   "Message: Extension Status\r\n"
2518                            "Exten: %s\r\n"
2519                            "Context: %s\r\n"
2520                            "Hint: %s\r\n"
2521                            "Status: %d\r\n\r\n",
2522                            exten, context, hint, status);
2523         return 0;
2524 }
2525
2526 static char mandescr_timeout[] =
2527 "Description: Hangup a channel after a certain time.\n"
2528 "Variables: (Names marked with * are required)\n"
2529 "       *Channel: Channel name to hangup\n"
2530 "       *Timeout: Maximum duration of the call (sec)\n"
2531 "Acknowledges set time with 'Timeout Set' message\n";
2532
2533 static int action_timeout(struct mansession *s, const struct message *m)
2534 {
2535         struct ast_channel *c;
2536         const char *name = astman_get_header(m, "Channel");
2537         double timeout = atof(astman_get_header(m, "Timeout"));
2538         struct timeval when = { timeout, 0 };
2539
2540         if (ast_strlen_zero(name)) {
2541                 astman_send_error(s, m, "No channel specified");
2542                 return 0;
2543         }
2544         if (!timeout || timeout < 0) {
2545                 astman_send_error(s, m, "No timeout specified");
2546                 return 0;
2547         }
2548         c = ast_get_channel_by_name_locked(name);
2549         if (!c) {
2550                 astman_send_error(s, m, "No such channel");
2551                 return 0;
2552         }
2553
2554         when.tv_usec = (timeout - when.tv_sec) * 1000000.0;
2555         ast_channel_setwhentohangup_tv(c, when);
2556         ast_channel_unlock(c);
2557         astman_send_ack(s, m, "Timeout Set");
2558         return 0;
2559 }
2560
2561 /*!
2562  * Send any applicable events to the client listening on this socket.
2563  * Wait only for a finite time on each event, and drop all events whether
2564  * they are successfully sent or not.
2565  */
2566 static int process_events(struct mansession *s)
2567 {
2568         int ret = 0;
2569
2570         ast_mutex_lock(&s->__lock);
2571         if (s->f != NULL) {
2572                 struct eventqent *eqe;
2573
2574                 while ( (eqe = NEW_EVENT(s)) ) {
2575                         ref_event(eqe);
2576                         if (!ret && s->authenticated &&
2577                             (s->readperm & eqe->category) == eqe->category &&
2578                             (s->send_events & eqe->category) == eqe->category) {
2579                                 if (send_string(s, eqe->eventdata) < 0)
2580                                         ret = -1;       /* don't send more */
2581                         }
2582                         s->last_ev = unref_event(s->last_ev);
2583                 }
2584         }
2585         ast_mutex_unlock(&s->__lock);
2586         return ret;
2587 }
2588
2589 static char mandescr_userevent[] =
2590 "Description: Send an event to manager sessions.\n"
2591 "Variables: (Names marked with * are required)\n"
2592 "       *UserEvent: EventStringToSend\n"
2593 "       Header1: Content1\n"
2594 "       HeaderN: ContentN\n";
2595
2596 static int action_userevent(struct mansession *s, const struct message *m)
2597 {
2598         const char *event = astman_get_header(m, "UserEvent");
2599         char body[2048] = "";
2600         int x, bodylen = 0;
2601         for (x = 0; x < m->hdrcount; x++) {
2602                 if (strncasecmp("UserEvent:", m->headers[x], strlen("UserEvent:"))) {
2603                         ast_copy_string(body + bodylen, m->headers[x], sizeof(body) - bodylen - 3);
2604                         bodylen += strlen(m->headers[x]);
2605                         ast_copy_string(body + bodylen, "\r\n", 3);
2606                         bodylen += 2;
2607                 }
2608         }
2609
2610         manager_event(EVENT_FLAG_USER, "UserEvent", "UserEvent: %s\r\n%s", event, body);
2611         return 0;
2612 }
2613
2614 static char mandescr_coresettings[] =
2615 "Description: Query for Core PBX settings.\n"
2616 "Variables: (Names marked with * are optional)\n"
2617 "       *ActionID: ActionID of this transaction\n";
2618
2619 /*! \brief Show PBX core settings information */
2620 static int action_coresettings(struct mansession *s, const struct message *m)
2621 {
2622         const char *actionid = astman_get_header(m, "ActionID");
2623         char idText[150];
2624
2625         if (!ast_strlen_zero(actionid))
2626                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
2627         else
2628                 idText[0] = '\0';
2629
2630         astman_append(s, "Response: Success\r\n"
2631                         "%s"
2632                         "AMIversion: %s\r\n"
2633                         "AsteriskVersion: %s\r\n"
2634                         "SystemName: %s\r\n"
2635                         "CoreMaxCalls: %d\r\n"
2636                         "CoreMaxLoadAvg: %f\r\n"
2637                         "CoreRunUser: %s\r\n"
2638                         "CoreRunGroup: %s\r\n"
2639                         "CoreMaxFilehandles: %d\r\n" 
2640                         "CoreRealTimeEnabled: %s\r\n"
2641                         "CoreCDRenabled: %s\r\n"
2642                         "CoreHTTPenabled: %s\r\n"
2643                         "\r\n",
2644                         idText,
2645                         AMI_VERSION,
2646                         ast_get_version(), 
2647                         ast_config_AST_SYSTEM_NAME,
2648                         option_maxcalls,
2649                         option_maxload,
2650                         ast_config_AST_RUN_USER,
2651                         ast_config_AST_RUN_GROUP,
2652                         option_maxfiles,
2653                         ast_realtime_enabled() ? "Yes" : "No",
2654                         check_cdr_enabled() ? "Yes" : "No",
2655                         check_webmanager_enabled() ? "Yes" : "No"
2656                         );
2657         return 0;
2658 }
2659
2660 static char mandescr_corestatus[] =
2661 "Description: Query for Core PBX status.\n"
2662 "Variables: (Names marked with * are optional)\n"
2663 "       *ActionID: ActionID of this transaction\n";
2664
2665 /*! \brief Show PBX core status information */
2666 static int action_corestatus(struct mansession *s, const struct message *m)
2667 {
2668         const char *actionid = astman_get_header(m, "ActionID");
2669         char idText[150];
2670         char startuptime[150];
2671         char reloadtime[150];
2672         struct ast_tm tm;
2673
2674         if (!ast_strlen_zero(actionid))
2675                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
2676         else
2677                 idText[0] = '\0';
2678
2679         ast_localtime(&ast_startuptime, &tm, NULL);
2680         ast_strftime(startuptime, sizeof(startuptime), "%H:%M:%S", &tm);
2681         ast_localtime(&ast_lastreloadtime, &tm, NULL);
2682         ast_strftime(reloadtime, sizeof(reloadtime), "%H:%M:%S", &tm);
2683
2684         astman_append(s, "Response: Success\r\n"
2685                         "%s"
2686                         "CoreStartupTime: %s\r\n"
2687                         "CoreReloadTime: %s\r\n"
2688                         "CoreCurrentCalls: %d\r\n"
2689                         "\r\n",
2690                         idText,
2691                         startuptime,
2692                         reloadtime,
2693                         ast_active_channels()
2694                         );
2695         return 0;
2696 }
2697
2698 static char mandescr_reload[] =
2699 "Description: Send a reload event.\n"
2700 "Variables: (Names marked with * are optional)\n"
2701 "       *ActionID: ActionID of this transaction\n"
2702 "       *Module: Name of the module to reload\n";
2703
2704 /*! \brief Send a reload event */
2705 static int action_reload(struct mansession *s, const struct message *m)
2706 {
2707         const char *module = astman_get_header(m, "Module");
2708         int res = ast_module_reload(S_OR(module, NULL));
2709
2710         if (res == 2)
2711                 astman_send_ack(s, m, "Module Reloaded");
2712         else
2713                 astman_send_error(s, m, s == 0 ? "No such module" : "Module does not support reload");
2714         return 0;
2715 }
2716
2717 static char mandescr_coreshowchannels[] =
2718 "Description: List currently defined channels and some information\n"
2719 "             about them.\n"
2720 "Variables:\n"
2721 "          ActionID: Optional Action id for message matching.\n";
2722
2723 /*! \brief  Manager command "CoreShowChannels" - List currently defined channels 
2724  *          and some information about them. */
2725 static int action_coreshowchannels(struct mansession *s, const struct message *m)
2726 {
2727         const char *actionid = astman_get_header(m, "ActionID");
2728         char actionidtext[256];
2729         struct ast_channel *c = NULL;
2730         int numchans = 0;
2731         int duration, durh, durm, durs;
2732
2733         if (!ast_strlen_zero(actionid))
2734                 snprintf(actionidtext, sizeof(actionidtext), "ActionID: %s\r\n", actionid);
2735         else
2736                 actionidtext[0] = '\0';
2737
2738         astman_send_listack(s, m, "Channels will follow", "start");     
2739
2740         while ((c = ast_channel_walk_locked(c)) != NULL) {
2741                 struct ast_channel *bc = ast_bridged_channel(c);
2742                 char durbuf[10] = "";
2743
2744                 if (c->cdr && !ast_tvzero(c->cdr->start)) {
2745                         duration = (int)(ast_tvdiff_ms(ast_tvnow(), c->cdr->start) / 1000);
2746                         durh = duration / 3600;
2747                         durm = (duration % 3600) / 60;
2748                         durs = duration % 60;
2749                         snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
2750                 }
2751
2752                 astman_append(s,
2753                         "Channel: %s\r\n"
2754                         "UniqueID: %s\r\n"
2755                         "Context: %s\r\n"
2756                         "Extension: %s\r\n"
2757                         "Priority: %d\r\n"
2758                         "ChannelState: %d\r\n"
2759                         "ChannelStateDesc: %s\r\n"
2760                         "Application: %s\r\n"
2761                         "ApplicationData: %s\r\n"
2762                         "CallerIDnum: %s\r\n"
2763                         "Duration: %s\r\n"
2764                         "AccountCode: %s\r\n"
2765                         "BridgedChannel: %s\r\n"
2766                         "BridgedUniqueID: %s\r\n"
2767                         "\r\n", c->name, c->uniqueid, c->context, c->exten, c->priority, c->_state, ast_state2str(c->_state),
2768                         c->appl ? c->appl : "", c->data ? S_OR(c->data, ""): "",
2769                         S_OR(c->cid.cid_num, ""), durbuf, S_OR(c->accountcode, ""), bc ? bc->name : "", bc ? bc->uniqueid : "");
2770                 ast_channel_unlock(c);
2771                 numchans++;
2772         }
2773
2774         astman_append(s,
2775                 "Event: CoreShowChannelsComplete\r\n"
2776                 "EventList: Complete\r\n"
2777                 "ListItems: %d\r\n"
2778                 "%s"
2779                 "\r\n", numchans, actionidtext);
2780
2781         return 0;
2782 }
2783
2784 static char mandescr_modulecheck[] = 
2785 "Description: Checks if Asterisk module is loaded\n"
2786 "Variables: \n"
2787 "  ActionID: <id>          Action ID for this transaction. Will be returned.\n"
2788 "  Module: <name>          Asterisk module name (not including extension)\n"
2789 "\n"
2790 "Will return Success/Failure\n"
2791 "For success returns, the module revision number is included.\n";
2792
2793 /* Manager function to check if module is loaded */
2794 static int manager_modulecheck(struct mansession *s, const struct message *m)
2795 {
2796         int res;
2797         const char *module = astman_get_header(m, "Module");
2798         const char *id = astman_get_header(m, "ActionID");
2799         char idText[256];
2800 #if !defined(LOW_MEMORY)
2801         const char *version;
2802 #endif
2803         char filename[PATH_MAX];
2804         char *cut;
2805
2806         ast_copy_string(filename, module, sizeof(filename));
2807         if ((cut = strchr(filename, '.'))) {
2808                 *cut = '\0';
2809         } else {
2810                 cut = filename + strlen(filename);
2811         }
2812         snprintf(cut, (sizeof(filename) - strlen(filename)) - 1, ".so");
2813         ast_log(LOG_DEBUG, "**** ModuleCheck .so file %s\n", filename);
2814         res = ast_module_check(filename);
2815         if (!res) {
2816                 astman_send_error(s, m, "Module not loaded");
2817                 return 0;
2818         }
2819         snprintf(cut, (sizeof(filename) - strlen(filename)) - 1, ".c");
2820         ast_log(LOG_DEBUG, "**** ModuleCheck .c file %s\n", filename);
2821 #if !defined(LOW_MEMORY)
2822         version = ast_file_version_find(filename);
2823 #endif
2824
2825         if (!ast_strlen_zero(id))
2826                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
2827         else
2828                 idText[0] = '\0';
2829         astman_append(s, "Response: Success\r\n%s", idText);
2830 #if !defined(LOW_MEMORY)
2831         astman_append(s, "Version: %s\r\n\r\n", version ? version : "");
2832 #endif
2833         return 0;
2834 }
2835
2836 static char mandescr_moduleload[] = 
2837 "Description: Loads, unloads or reloads an Asterisk module in a running system.\n"
2838 "Variables: \n"
2839 "  ActionID: <id>          Action ID for this transaction. Will be returned.\n"
2840 "  Module: <name>          Asterisk module name (including .so extension)\n"
2841 "                          or subsystem identifier:\n"
2842 "                               cdr, enum, dnsmgr, extconfig, manager, rtp, http\n"
2843 "  LoadType: load | unload | reload\n"
2844 "                          The operation to be done on module\n"
2845 " If no module is specified for a reload loadtype, all modules are reloaded";
2846
2847 static int manager_moduleload(struct mansession *s, const struct message *m)
2848 {
2849         int res;
2850         const char *module = astman_get_header(m, "Module");
2851         const char *loadtype = astman_get_header(m, "LoadType");
2852
2853         if (!loadtype || strlen(loadtype) == 0)
2854                 astman_send_error(s, m, "Incomplete ModuleLoad action.");
2855         if ((!module || strlen(module) == 0) && strcasecmp(loadtype, "reload") != 0)
2856                 astman_send_error(s, m, "Need module name");
2857
2858         if (!strcasecmp(loadtype, "load")) {
2859                 res = ast_load_resource(module);
2860                 if (res)
2861                         astman_send_error(s, m, "Could not load module.");
2862                 else
2863                         astman_send_ack(s, m, "Module loaded.");
2864         } else if (!strcasecmp(loadtype, "unload")) {
2865                 res = ast_unload_resource(module, AST_FORCE_SOFT);
2866                 if (res)
2867                         astman_send_error(s, m, "Could not unload module.");
2868                 else
2869                         astman_send_ack(s, m, "Module unloaded.");
2870         } else if (!strcasecmp(loadtype, "reload")) {
2871                 if (module != NULL) {
2872                         res = ast_module_reload(module);
2873                         if (res == 0)
2874                                 astman_send_error(s, m, "No such module.");
2875                         else if (res == 1)
2876                                 astman_send_error(s, m, "Module does not support reload action.");
2877                         else
2878                                 astman_send_ack(s, m, "Module reloaded.");
2879                 } else {
2880                         ast_module_reload(NULL);        /* Reload all modules */
2881                         astman_send_ack(s, m, "All modules reloaded");
2882                 }
2883         } else 
2884                 astman_send_error(s, m, "Incomplete ModuleLoad action.");
2885         return 0;
2886 }
2887
2888 /*
2889  * Done with the action handlers here, we start with the code in charge
2890  * of accepting connections and serving them.
2891  * accept_thread() forks a new thread for each connection, session_do(),
2892  * which in turn calls get_input() repeatedly until a full message has
2893  * been accumulated, and then invokes process_message() to pass it to
2894  * the appropriate handler.
2895  */
2896
2897 /*
2898  * Process an AMI message, performing desired action.
2899  * Return 0 on success, -1 on error that require the session to be destroyed.
2900  */
2901 static int process_message(struct mansession *s, const struct message *m)
2902 {
2903         char action[80] = "";
2904         int ret = 0;
2905         struct manager_action *tmp;
2906         const char *user = astman_get_header(m, "Username");
2907
2908         ast_copy_string(action, __astman_get_header(m, "Action", GET_HEADER_SKIP_EMPTY), sizeof(action));
2909         ast_debug(1, "Manager received command '%s'\n", action);
2910
2911         if (ast_strlen_zero(action)) {
2912                 ast_mutex_lock(&s->__lock);
2913                 astman_send_error(s, m, "Missing action in request");
2914                 ast_mutex_unlock(&s->__lock);
2915                 return 0;
2916         }
2917
2918         if (!s->authenticated && strcasecmp(action, "Login") && strcasecmp(action, "Logoff") && strcasecmp(action, "Challenge")) {
2919                 ast_mutex_lock(&s->__lock);
2920                 astman_send_error(s, m, "Permission denied");
2921                 ast_mutex_unlock(&s->__lock);
2922                 return 0;
2923         }
2924
2925         if (!allowmultiplelogin && !s->authenticated && user &&
2926                 (!strcasecmp(action, "Login") || !strcasecmp(action, "Challenge"))) {
2927                 if (check_manager_session_inuse(user)) {
2928                         sleep(1);
2929                         ast_mutex_lock(&s->__lock);
2930                         astman_send_error(s, m, "Login Already In Use");
2931                         ast_mutex_unlock(&s->__lock);
2932                         return -1;
2933                 }
2934         }
2935
2936         AST_RWLIST_RDLOCK(&actions);
2937         AST_RWLIST_TRAVERSE(&actions, tmp, list) {
2938                 if (strcasecmp(action, tmp->action))
2939                         continue;
2940                 if (s->writeperm & tmp->authority || tmp->authority == 0)
2941                         ret = tmp->func(s, m);
2942                 else
2943                         astman_send_error(s, m, "Permission denied");
2944                 break;
2945         }
2946         AST_RWLIST_UNLOCK(&actions);
2947
2948         if (!tmp) {
2949                 char buf[512];
2950                 snprintf(buf, sizeof(buf), "Invalid/unknown command: %s. Use Action: ListCommands to show available commands.", action);
2951                 ast_mutex_lock(&s->__lock);
2952                 astman_send_error(s, m, buf);
2953                 ast_mutex_unlock(&s->__lock);
2954         }
2955         if (ret)
2956                 return ret;
2957         /* Once done with our message, deliver any pending events */
2958         return process_events(s);
2959 }
2960
2961 /*!
2962  * Read one full line (including crlf) from the manager socket.
2963  * \note \verbatim
2964  * \r\n is the only valid terminator for the line.
2965  * (Note that, later, '\0' will be considered as the end-of-line marker,
2966  * so everything between the '\0' and the '\r\n' will not be used).
2967  * Also note that we assume output to have at least "maxlen" space.
2968  * \endverbatim
2969  */
2970 static int get_input(struct mansession *s, char *output)
2971 {
2972         int res, x;
2973         int maxlen = sizeof(s->inbuf) - 1;
2974         char *src = s->inbuf;
2975
2976         /*
2977          * Look for \r\n within the buffer. If found, copy to the output
2978          * buffer and return, trimming the \r\n (not used afterwards).
2979          */
2980         for (x = 0; x < s->inlen; x++) {
2981                 int cr; /* set if we have \r */
2982                 if (src[x] == '\r' && x+1 < s->inlen && src[x+1] == '\n')
2983                         cr = 2; /* Found. Update length to include \r\n */
2984                 else if (src[x] == '\n')
2985                         cr = 1; /* also accept \n only */
2986                 else
2987                         continue;
2988                 memmove(output, src, x);        /*... but trim \r\n */
2989                 output[x] = '\0';               /* terminate the string */
2990                 x += cr;                        /* number of bytes used */
2991                 s->inlen -= x;                  /* remaining size */
2992                 memmove(src, src + x, s->inlen); /* remove used bytes */
2993                 return 1;
2994         }
2995         if (s->inlen >= maxlen) {
2996                 /* no crlf found, and buffer full - sorry, too long for us */
2997                 ast_log(LOG_WARNING, "Dumping long line with no return from %s: %s\n", ast_inet_ntoa(s->sin.sin_addr), src);
2998                 s->inlen = 0;
2999         }
3000         res = 0;
3001         while (res == 0) {
3002                 /* XXX do we really need this locking ? */
3003                 ast_mutex_lock(&s->__lock);
3004                 if (s->pending_event) {
3005                         s->pending_event = 0;
3006                         ast_mutex_unlock(&s->__lock);
3007                         return 0;
3008                 }
3009                 s->waiting_thread = pthread_self();
3010                 ast_mutex_unlock(&s->__lock);
3011
3012                 res = ast_wait_for_input(s->fd, -1);    /* return 0 on timeout ? */
3013
3014                 ast_mutex_lock(&s->__lock);
3015                 s->waiting_thread = AST_PTHREADT_NULL;
3016                 ast_mutex_unlock(&s->__lock);
3017         }
3018         if (res < 0) {
3019                 /* If we get a signal from some other thread (typically because
3020                  * there are new events queued), return 0 to notify the caller.
3021                  */
3022                 if (errno == EINTR || errno == EAGAIN)
3023                         return 0;
3024                 ast_log(LOG_WARNING, "poll() returned error: %s\n", strerror(errno));
3025                 return -1;
3026         }
3027         ast_mutex_lock(&s->__lock);
3028         res = fread(src + s->inlen, 1, maxlen - s->inlen, s->f);
3029         if (res < 1)
3030                 res = -1;       /* error return */
3031         else {
3032                 s->inlen += res;
3033                 src[s->inlen] = '\0';
3034                 res = 0;
3035         }
3036         ast_mutex_unlock(&s->__lock);
3037         return res;
3038 }
3039
3040 static int do_message(struct mansession *s)
3041 {
3042         struct message m = { 0 };
3043         char header_buf[sizeof(s->inbuf)] = { '\0' };
3044         int res;
3045
3046         for (;;) {
3047                 /* Check if any events are pending and do them if needed */
3048                 if (process_events(s))
3049                         return -1;
3050                 res = get_input(s, header_buf);
3051                 if (res == 0) {
3052                         continue;
3053                 } else if (res > 0) {
3054                         if (ast_strlen_zero(header_buf))
3055                                 return process_message(s, &m) ? -1 : 0;
3056                         else if (m.hdrcount < (AST_MAX_MANHEADERS - 1))
3057                                 m.headers[m.hdrcount++] = ast_strdupa(header_buf);
3058                 } else {
3059                         return res;
3060                 }
3061         }
3062 }
3063
3064 /*! \brief The body of the individual manager session.
3065  * Call get_input() to read one line at a time
3066  * (or be woken up on new events), collect the lines in a
3067  * message until found an empty line, and execute the request.
3068  * In any case, deliver events asynchronously through process_events()
3069  * (called from here if no line is available, or at the end of
3070  * process_message(). )
3071  */
3072 static void *session_do(void *data)
3073 {
3074         struct ast_tcptls_session_instance *ser = data;
3075         struct mansession *s = ast_calloc(1, sizeof(*s));
3076         int flags;
3077         int res;
3078
3079         if (s == NULL)
3080                 goto done;
3081
3082         s->writetimeout = 100;
3083         s->waiting_thread = AST_PTHREADT_NULL;
3084
3085         flags = fcntl(ser->fd, F_GETFL);
3086         if (!block_sockets) /* make sure socket is non-blocking */
3087                 flags |= O_NONBLOCK;
3088         else
3089                 flags &= ~O_NONBLOCK;
3090         fcntl(ser->fd, F_SETFL, flags);
3091
3092         ast_mutex_init(&s->__lock);
3093         s->send_events = -1;
3094         /* Hook to the tail of the event queue */
3095         s->last_ev = grab_last();
3096
3097         /* these fields duplicate those in the 'ser' structure */
3098         s->fd = ser->fd;
3099         s->f = ser->f;
3100         s->sin = ser->requestor;
3101
3102         AST_LIST_HEAD_INIT_NOLOCK(&s->datastores);
3103
3104         AST_LIST_LOCK(&sessions);
3105         AST_LIST_INSERT_HEAD(&sessions, s, list);
3106         ast_atomic_fetchadd_int(&num_sessions, 1);
3107         AST_LIST_UNLOCK(&sessions);
3108
3109         astman_append(s, "Asterisk Call Manager/%s\r\n", AMI_VERSION);  /* welcome prompt */
3110         for (;;) {
3111                 if ((res = do_message(s)) < 0)
3112                         break;
3113         }
3114         /* session is over, explain why and terminate */
3115         if (s->authenticated) {
3116                         if (manager_displayconnects(s))
3117                         ast_verb(2, "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr));
3118                 ast_log(LOG_EVENT, "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr));
3119         } else {
3120                         if (displayconnects)
3121                         ast_verb(2, "Connect attempt from '%s' unable to authenticate\n", ast_inet_ntoa(s->sin.sin_addr));
3122                 ast_log(LOG_EVENT, "Failed attempt from %s\n", ast_inet_ntoa(s->sin.sin_addr));
3123         }
3124
3125         /* It is possible under certain circumstances for this session thread
3126            to complete its work and exit *before* the thread that created it
3127            has finished executing the ast_pthread_create_background() function.
3128            If this occurs, some versions of glibc appear to act in a buggy
3129            fashion and attempt to write data into memory that it thinks belongs
3130            to the thread but is in fact not owned by the thread (or may have
3131            been freed completely).
3132
3133            Causing this thread to yield to other threads at least one time
3134            appears to work around this bug.
3135         */
3136         usleep(1);
3137
3138         destroy_session(s);
3139
3140 done:
3141         ao2_ref(ser, -1);
3142         ser = NULL;
3143         return NULL;
3144 }
3145
3146 /*! \brief remove at most n_max stale session from the list. */
3147 static void purge_sessions(int n_max)
3148 {
3149         struct mansession *s;
3150         time_t now = time(NULL);
3151
3152         AST_LIST_LOCK(&sessions);
3153         AST_LIST_TRAVERSE_SAFE_BEGIN(&sessions, s, list) {
3154                 if (s->sessiontimeout && (now > s->sessiontimeout) && !s->inuse) {
3155                         AST_LIST_REMOVE_CURRENT(list);
3156                         ast_atomic_fetchadd_int(&num_sessions, -1);
3157                         if (s->authenticated && (VERBOSITY_ATLEAST(2)) && manager_displayconnects(s)) {
3158                                 ast_verb(2, "HTTP Manager '%s' timed out from %s\n",
3159                                         s->username, ast_inet_ntoa(s->sin.sin_addr));
3160                         }
3161                         free_session(s);        /* XXX outside ? */
3162                         if (--n_max <= 0)
3163                                 break;
3164                 }
3165         }
3166         AST_LIST_TRAVERSE_SAFE_END;
3167         AST_LIST_UNLOCK(&sessions);
3168 }
3169
3170 /*
3171  * events are appended to a queue from where they
3172  * can be dispatched to clients.
3173  */
3174 static int append_event(const char *str, int category)
3175 {
3176         struct eventqent *tmp = ast_malloc(sizeof(*tmp) + strlen(str));
3177         static int seq; /* sequence number */
3178
3179         if (!tmp)
3180                 return -1;
3181
3182         /* need to init all fields, because ast_malloc() does not */
3183         tmp->usecount = 0;
3184         tmp->category = category;
3185         tmp->seq = ast_atomic_fetchadd_int(&seq, 1);
3186         AST_LIST_NEXT(tmp, eq_next) = NULL;
3187         strcpy(tmp->eventdata, str);
3188
3189         AST_LIST_LOCK(&all_events);
3190         AST_LIST_INSERT_TAIL(&all_events, tmp, eq_next);
3191         AST_LIST_UNLOCK(&all_events);
3192
3193         return 0;
3194 }
3195
3196 /* XXX see if can be moved inside the function */
3197 AST_THREADSTORAGE(manager_event_buf);
3198 #define MANAGER_EVENT_BUF_INITSIZE   256
3199
3200 /*! \brief  manager_event: Send AMI event to client */
3201 int __manager_event(int category, const char *event,
3202         const char *file, int line, const char *func, const char *fmt, ...)
3203 {
3204         struct mansession *s;
3205         struct manager_custom_hook *hook;
3206         struct ast_str *auth = ast_str_alloca(80);
3207         const char *cat_str;
3208         va_list ap;
3209         struct timeval now;
3210         struct ast_str *buf;
3211
3212         /* Abort if there aren't any manager sessions */
3213         if (!num_sessions)
3214                 return 0;
3215
3216         if (!(buf = ast_str_thread_get(&manager_event_buf, MANAGER_EVENT_BUF_INITSIZE)))
3217                 return -1;
3218
3219         cat_str = authority_to_str(category, &auth);
3220         ast_str_set(&buf, 0,
3221                         "Event: %s\r\nPrivilege: %s\r\n",
3222                          event, cat_str);
3223
3224         if (timestampevents) {
3225                 now = ast_tvnow();
3226                 ast_str_append(&buf, 0,
3227                                 "Timestamp: %ld.%06lu\r\n",
3228                                  (long)now.tv_sec, (unsigned long) now.tv_usec);
3229         }
3230         if (manager_debug) {
3231                 static int seq;
3232                 ast_str_append(&buf, 0,
3233                                 "SequenceNumber: %d\r\n",
3234                                  ast_atomic_fetchadd_int(&seq, 1));
3235                 ast_str_append(&buf, 0,
3236