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