channels/chan_agent.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Implementation of Session Initiation Protocol
   5  *
   6  * Copyright (C) 1999, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14 #include <stdio.h>
  15 #include <pthread.h>
  16 #include <string.h>
  17 #include <asterisk/lock.h>
  18 #include <asterisk/channel.h>
  19 #include <asterisk/channel_pvt.h>
  20 #include <asterisk/config.h>
  21 #include <asterisk/logger.h>
  22 #include <asterisk/module.h>
  23 #include <asterisk/pbx.h>
  24 #include <asterisk/options.h>
  25 #include <asterisk/lock.h>
  26 #include <asterisk/sched.h>
  27 #include <asterisk/io.h>
  28 #include <asterisk/rtp.h>
  29 #include <asterisk/acl.h>
  30 #include <asterisk/callerid.h>
  31 #include <asterisk/file.h>
  32 #include <asterisk/cli.h>
  33 #include <asterisk/app.h>
  34 #include <asterisk/musiconhold.h>
  35 #include <asterisk/manager.h>
  36 #include <asterisk/parking.h>
  37 #include <sys/socket.h>
  38 #include <errno.h>
  39 #include <unistd.h>
  40 #include <stdlib.h>
  41 #include <fcntl.h>
  42 #include <netdb.h>
  43 #include <arpa/inet.h>
  44 #include <sys/signal.h>
  45
  46 static char *desc = "Agent Proxy Channel";
  47 static char *type = "Agent";
  48 static char *tdesc = "Call Agent Proxy Channel";
  49 static char *config = "agents.conf";
  50
  51 static char *app = "AgentLogin";
  52 static char *app2 = "AgentCallbackLogin";
  53
  54 static char *synopsis = "Call agent login";
  55 static char *synopsis2 = "Call agent callback login";
  56
  57 static char *descrip =
  58 "  AgentLogin([AgentNo][|options]):\n"
  59 "Asks the agent to login to the system.  Always returns -1.  While\n"
  60 "logged in, the agent can receive calls and will hear a 'beep'\n"
  61 "when a new call comes in.  The agent can dump the call by pressing\n"
  62 "the star key.\n"
  63 "The option string may contain zero or more of the following characters:\n"
  64 "      's' -- silent login - do not announce the login ok segment\n";
  65
  66 static char *descrip2 =
  67 "  AgentCallbackLogin([AgentNo][|[options][exten]@context]):\n"
  68 "Asks the agent to login to the system with callback.  Always returns -1.\n"
  69 "The agent's callback extension is called (optionally with the specified\n"
  70 "context. \n";
  71
  72 static char moh[80] = "default";
  73
  74 #define AST_MAX_AGENT   80              /* Agent ID or Password max length */
  75
  76 static int capability = -1;
  77
  78 static unsigned int group;
  79 static int autologoff;
  80 static int wrapuptime;
  81 static int ackcall;
  82
  83 static int usecnt =0;
  84 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
  85
  86 /* Protect the interface list (of sip_pvt's) */
  87 static ast_mutex_t agentlock = AST_MUTEX_INITIALIZER;
  88
  89 static struct agent_pvt {
  90         ast_mutex_t lock;                               /* Channel private lock */
  91         int dead;                                                       /* Poised for destruction? */
  92         int pending;                                            /* Not a real agent -- just pending a match */
  93         int abouttograb;                                        /* About to grab */
  94         int autologoff;                                 /* Auto timeout time */
  95         int ackcall;                                    /* ackcall */
  96         time_t start;                                           /* When call started */
  97         struct timeval lastdisc;                        /* When last disconnected */
  98         int wrapuptime;                                         /* Wrapup time in ms */
  99         unsigned int group;                                     /* Group memberships */
 100         int acknowledged;                                       /* Acknowledged */
 101         char moh[80];                                           /* Which music on hold */
 102         char agent[AST_MAX_AGENT];                      /* Agent ID */
 103         char password[AST_MAX_AGENT];           /* Password for Agent login */
 104         char name[AST_MAX_AGENT];
 105         ast_mutex_t app_lock;                   /* Synchronization between owning applications */
 106         volatile pthread_t owning_app;          /* Owning application thread id */
 107         volatile int app_sleep_cond;            /* Sleep condition for the login app */
 108         struct ast_channel *owner;                      /* Agent */
 109         char loginchan[80];
 110         struct ast_channel *chan;                       /* Channel we use */
 111         struct agent_pvt *next;                         /* Agent */
 112 } *agents = NULL;
 113
 114 #define CHECK_FORMATS(ast, p) do { \
 115         if (p->chan) {\
 116                 if (ast->nativeformats != p->chan->nativeformats) { \
 117                         ast_log(LOG_DEBUG, "Native formats changing from %d to %d\n", ast->nativeformats, p->chan->nativeformats); \
 118                         /* Native formats changed, reset things */ \
 119                         ast->nativeformats = p->chan->nativeformats; \
 120                         ast_log(LOG_DEBUG, "Resetting read to %d and write to %d\n", ast->readformat, ast->writeformat);\
 121                         ast_set_read_format(ast, ast->readformat); \
 122                         ast_set_write_format(ast, ast->writeformat); \
 123                 } \
 124                 if (p->chan->readformat != ast->pvt->rawreadformat)  \
 125                         ast_set_read_format(p->chan, ast->pvt->rawreadformat); \
 126                 if (p->chan->writeformat != ast->pvt->rawwriteformat) \
 127                         ast_set_write_format(p->chan, ast->pvt->rawwriteformat); \
 128         } \
 129 } while(0)
 130
 131 #define CLEANUP(ast, p) do { \
 132         int x; \
 133         if (p->chan) { \
 134                 for (x=0;x<AST_MAX_FDS;x++) \
 135                         ast->fds[x] = p->chan->fds[x]; \
 136         } \
 137 } while(0)
 138
 139
 140 static void agent_unlink(struct agent_pvt *agent)
 141 {
 142         struct agent_pvt *p, *prev;
 143         prev = NULL;
 144         p = agents;
 145         while(p) {
 146                 if (p == agent) {
 147                         if (prev)
 148                                 prev->next = agent->next;
 149                         else
 150                                 agents = agent->next;
 151                         break;
 152                 }
 153                 prev = p;
 154                 p = p->next;
 155         }
 156 }
 157
 158 static struct agent_pvt *add_agent(char *agent, int pending)
 159 {
 160         char tmp[256];
 161         char *password=NULL, *name=NULL;
 162         struct agent_pvt *p, *prev;
 163
 164         strncpy(tmp, agent, sizeof(tmp));
 165         if ((password = strchr(tmp, ','))) {
 166                 *password = '\0';
 167                 password++;
 168                 while (*password < 33) password++;
 169         }
 170         if (password && (name = strchr(password, ','))) {
 171                 *name = '\0';
 172                 name++;
 173                 while (*name < 33) name++;
 174         }
 175         prev=NULL;
 176         p = agents;
 177         while(p) {
 178                 if (!pending && !strcmp(p->agent, tmp))
 179                         break;
 180                 prev = p;
 181                 p = p->next;
 182         }
 183         if (!p) {
 184                 p = malloc(sizeof(struct agent_pvt));
 185                 if (p) {
 186                         memset(p, 0, sizeof(struct agent_pvt));
 187                         strncpy(p->agent, tmp, sizeof(p->agent) -1);
 188                         ast_mutex_init( &p->lock );
 189                         ast_mutex_init( &p->app_lock );
 190                         p->owning_app = -1;
 191                         p->app_sleep_cond = 1;
 192                         p->group = group;
 193                         p->pending = pending;
 194                         p->next = NULL;
 195                         if (prev)
 196                                 prev->next = p;
 197                         else
 198                                 agents = p;
 199
 200                 }
 201         }
 202         if (!p)
 203                 return NULL;
 204         strncpy(p->password, password ? password : "", sizeof(p->password) - 1);
 205         strncpy(p->name, name ? name : "", sizeof(p->name) - 1);
 206         strncpy(p->moh, moh, sizeof(p->moh) - 1);
 207         p->ackcall = ackcall;
 208         p->autologoff = autologoff;
 209         p->wrapuptime = wrapuptime;
 210         if (pending)
 211                 p->dead = 1;
 212         else
 213                 p->dead = 0;
 214         return p;
 215 }
 216
 217 static int agent_cleanup(struct agent_pvt *p)
 218 {
 219         struct ast_channel *chan = p->owner;
 220         p->owner = NULL;
 221         chan->pvt->pvt = NULL;
 222         p->app_sleep_cond = 1;
 223         /* Release ownership of the agent to other threads (presumably running the login app). */
 224         ast_mutex_unlock(&p->app_lock);
 225         if (chan)
 226                 ast_channel_free(chan);
 227         if (p->dead)
 228                 free(p);
 229         return 0;
 230 }
 231
 232 static int check_availability(struct agent_pvt *newlyavailable, int needlock);
 233
 234 static int agent_answer(struct ast_channel *ast)
 235 {
 236         ast_log(LOG_WARNING, "Huh?  Agent is being asked to answer?\n");
 237         return -1;
 238 }
 239
 240 static struct ast_frame  *agent_read(struct ast_channel *ast)
 241 {
 242         struct agent_pvt *p = ast->pvt->pvt;
 243         struct ast_frame *f = NULL;
 244         static struct ast_frame null_frame = { AST_FRAME_NULL, };
 245         static struct ast_frame answer_frame = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
 246         ast_mutex_lock(&p->lock);
 247         CHECK_FORMATS(ast, p);
 248         if (p->chan) {
 249                 p->chan->exception = ast->exception;
 250                 p->chan->fdno = ast->fdno;
 251                 f = ast_read(p->chan);
 252         } else
 253                 f = &null_frame;
 254         if (!f) {
 255                 /* If there's a channel, hang it up  (if it's on a callback) make it NULL */
 256                 if (p->chan) {
 257                         if (strlen(p->loginchan))
 258                                 ast_hangup(p->chan);
 259                         p->chan = NULL;
 260                         p->acknowledged = 0;
 261                 }
 262         }
 263         if (f && (f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_ANSWER)) {
 264 /* TC */
 265                 if (p->ackcall) {
 266                         if (option_verbose > 2)
 267                                 ast_verbose(VERBOSE_PREFIX_3 "%s answered, waiting for '#' to acknowledge\n", p->chan->name);
 268                         /* Don't pass answer along */
 269                         ast_frfree(f);
 270                         f = &null_frame;
 271                 }
 272         else {
 273                         p->acknowledged = 1;
 274                         f = &answer_frame;
 275         }
 276         }
 277         if (f && (f->frametype == AST_FRAME_DTMF) && (f->subclass == '#')) {
 278                 if (!p->acknowledged) {
 279                         if (option_verbose > 2)
 280                                 ast_verbose(VERBOSE_PREFIX_3 "%s acknowledged\n", p->chan->name);
 281                         p->acknowledged = 1;
 282                         ast_frfree(f);
 283                         f = &answer_frame;
 284                 }
 285         }
 286         if (f && (f->frametype == AST_FRAME_DTMF) && (f->subclass == '*')) {
 287                 /* * terminates call */
 288                 ast_frfree(f);
 289                 f = NULL;
 290         }
 291         CLEANUP(ast,p);
 292         ast_mutex_unlock(&p->lock);
 293         return f;
 294 }
 295
 296 static int agent_write(struct ast_channel *ast, struct ast_frame *f)
 297 {
 298         struct agent_pvt *p = ast->pvt->pvt;
 299         int res = -1;
 300         CHECK_FORMATS(ast, p);
 301         ast_mutex_lock(&p->lock);
 302         if (p->chan) {
 303                 if ((f->frametype != AST_FRAME_VOICE) ||
 304                         (f->subclass == p->chan->writeformat)) {
 305                         res = ast_write(p->chan, f);
 306                 } else {
 307                         ast_log(LOG_DEBUG, "Dropping one incompatible voice frame on '%s' to '%s'\n", ast->name, p->chan->name);
 308                         res = 0;
 309                 }
 310         } else
 311                 res = 0;
 312         CLEANUP(ast, p);
 313         ast_mutex_unlock(&p->lock);
 314         return res;
 315 }
 316
 317 static int agent_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
 318 {
 319         struct agent_pvt *p = newchan->pvt->pvt;
 320         ast_mutex_lock(&p->lock);
 321         if (p->owner != oldchan) {
 322                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
 323                 ast_mutex_unlock(&p->lock);
 324                 return -1;
 325         }
 326         p->owner = newchan;
 327         ast_mutex_unlock(&p->lock);
 328         return 0;
 329 }
 330
 331 static int agent_indicate(struct ast_channel *ast, int condition)
 332 {
 333         struct agent_pvt *p = ast->pvt->pvt;
 334         int res = -1;
 335         ast_mutex_lock(&p->lock);
 336         if (p->chan)
 337                 res = ast_indicate(p->chan, condition);
 338         else
 339                 res = 0;
 340         ast_mutex_unlock(&p->lock);
 341         return res;
 342 }
 343
 344 static int agent_digit(struct ast_channel *ast, char digit)
 345 {
 346         struct agent_pvt *p = ast->pvt->pvt;
 347         int res = -1;
 348         ast_mutex_lock(&p->lock);
 349         if (p->chan)
 350                 res = p->chan->pvt->send_digit(p->chan, digit);
 351         else
 352                 res = 0;
 353         ast_mutex_unlock(&p->lock);
 354         return res;
 355 }
 356
 357 static int agent_call(struct ast_channel *ast, char *dest, int timeout)
 358 {
 359         struct agent_pvt *p = ast->pvt->pvt;
 360         int res = -1;
 361         ast_mutex_lock(&p->lock);
 362         if (!p->chan) {
 363                 if (p->pending) {
 364                         ast_log(LOG_DEBUG, "Pretending to dial on pending agent\n");
 365                         ast_setstate(ast, AST_STATE_DIALING);
 366                         res = 0;
 367                 } else {
 368                         ast_log(LOG_NOTICE, "Whoa, they hung up between alloc and call...  what are the odds of that?\n");
 369                         res = -1;
 370                 }
 371                 ast_mutex_unlock(&p->lock);
 372                 return res;
 373         } else if (strlen(p->loginchan)) {
 374                 time(&p->start);
 375                 /* Call on this agent */
 376                 if (option_verbose > 2)
 377                         ast_verbose(VERBOSE_PREFIX_3 "outgoing agentcall, to agent '%s', on '%s'\n", p->agent, p->chan->name);
 378                 if (p->chan->callerid)
 379                         free(p->chan->callerid);
 380                 if (ast->callerid)
 381                         p->chan->callerid = strdup(ast->callerid);
 382                 else
 383                         p->chan->callerid = NULL;
 384                 res = ast_call(p->chan, p->loginchan, 0);
 385                 CLEANUP(ast,p);
 386                 ast_mutex_unlock(&p->lock);
 387                 return res;
 388         }
 389         ast_verbose( VERBOSE_PREFIX_3 "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name);
 390         ast_log( LOG_DEBUG, "Playing beep, lang '%s'\n", p->chan->language);
 391         res = ast_streamfile(p->chan, "beep", p->chan->language);
 392         ast_log( LOG_DEBUG, "Played beep, result '%d'\n", res);
 393         if (!res) {
 394                 res = ast_waitstream(p->chan, "");
 395                 ast_log( LOG_DEBUG, "Waited for stream, result '%d'\n", res);
 396         }
 397         if (!res) {
 398                 res = ast_set_read_format(p->chan, ast_best_codec(p->chan->nativeformats));
 399                 ast_log( LOG_DEBUG, "Set read format, result '%d'\n", res);
 400                 if (res)
 401                         ast_log(LOG_WARNING, "Unable to set read format to %s\n", ast_getformatname(ast_best_codec(p->chan->nativeformats)));
 402         } else {
 403                 // Agent hung-up
 404                 p->chan = NULL;
 405         }
 406
 407         if (!res) {
 408                 ast_set_write_format(p->chan, ast_best_codec(p->chan->nativeformats));
 409                 ast_log( LOG_DEBUG, "Set write format, result '%d'\n", res);
 410                 if (res)
 411                         ast_log(LOG_WARNING, "Unable to set write format to %s\n", ast_getformatname(ast_best_codec(p->chan->nativeformats)));
 412         }
 413         if( !res )
 414         {
 415                 /* Call is immediately up */
 416                 ast_setstate(ast, AST_STATE_UP);
 417         }
 418         CLEANUP(ast,p);
 419         ast_mutex_unlock(&p->lock);
 420         return res;
 421 }
 422
 423 static int agent_hangup(struct ast_channel *ast)
 424 {
 425         struct agent_pvt *p = ast->pvt->pvt;
 426         int howlong = 0;
 427         ast_mutex_lock(&p->lock);
 428         p->owner = NULL;
 429         ast->pvt->pvt = NULL;
 430         p->app_sleep_cond = 1;
 431         if (p->start && (ast->_state != AST_STATE_UP))
 432                 howlong = time(NULL) - p->start;
 433         time(&p->start);
 434         if (p->chan) {
 435                 /* If they're dead, go ahead and hang up on the agent now */
 436                 if (strlen(p->loginchan)) {
 437                         p->acknowledged = 0;
 438                         if (p->chan) {
 439                                 /* Recognize the hangup and pass it along immediately */
 440                                 ast_hangup(p->chan);
 441                                 p->chan = NULL;
 442                         }
 443                         ast_log(LOG_DEBUG, "Hungup, howlong is %d, autologoff is %d\n", howlong, p->autologoff);
 444                         if (howlong  && p->autologoff && (howlong > p->autologoff)) {
 445                                 ast_log(LOG_NOTICE, "Agent '%s' didn't answer/confirm within %d seconds (waited %d)\n", p->name, p->autologoff, howlong);
 446                                 strcpy(p->loginchan, "");
 447                         }
 448                 } else if (p->dead) {
 449                         ast_mutex_lock(&p->chan->lock);
 450                         ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
 451                         ast_mutex_unlock(&p->chan->lock);
 452                 } else {
 453                         ast_mutex_lock(&p->chan->lock);
 454                         ast_moh_start(p->chan, p->moh);
 455                         ast_mutex_unlock(&p->chan->lock);
 456                 }
 457         }
 458 #if 0
 459                 ast_mutex_unlock(&p->lock);
 460                 /* Release ownership of the agent to other threads (presumably running the login app). */
 461                 ast_mutex_unlock(&p->app_lock);
 462         } else if (p->dead) {
 463                 /* Go ahead and lose it */
 464                 ast_mutex_unlock(&p->lock);
 465                 /* Release ownership of the agent to other threads (presumably running the login app). */
 466                 ast_mutex_unlock(&p->app_lock);
 467         } else {
 468                 ast_mutex_unlock(&p->lock);
 469                 /* Release ownership of the agent to other threads (presumably running the login app). */
 470                 ast_mutex_unlock(&p->app_lock);
 471         }
 472 #endif
 473         ast_mutex_unlock(&p->lock);
 474         /* Release ownership of the agent to other threads (presumably running the login app). */
 475         ast_mutex_unlock(&p->app_lock);
 476
 477         if (p->pending) {
 478                 ast_mutex_lock(&agentlock);
 479                 agent_unlink(p);
 480                 ast_mutex_unlock(&agentlock);
 481         }
 482         if (p->abouttograb) {
 483                 /* Let the "about to grab" thread know this isn't valid anymore, and let it
 484                    kill it later */
 485                 p->abouttograb = 0;
 486         } else if (p->dead) {
 487                 free(p);
 488         } else if (p->chan) {
 489                 /* Not dead -- check availability now */
 490                 ast_mutex_lock(&p->lock);
 491                 /* check_availability(p, 1); */
 492                 /* Store last disconnect time */
 493                 gettimeofday(&p->lastdisc, NULL);
 494                 ast_mutex_unlock(&p->lock);
 495         }
 496         return 0;
 497 }
 498
 499 static int agent_cont_sleep( void *data )
 500 {
 501         struct agent_pvt *p;
 502         struct timeval tv;
 503         int res;
 504
 505         p = (struct agent_pvt *)data;
 506
 507         ast_mutex_lock(&p->lock);
 508         res = p->app_sleep_cond;
 509         if (p->lastdisc.tv_sec) {
 510                 gettimeofday(&tv, NULL);
 511                 if ((tv.tv_sec - p->lastdisc.tv_sec) * 1000 +
 512                         (tv.tv_usec - p->lastdisc.tv_usec) / 1000 > p->wrapuptime)
 513                         res = 1;
 514         }
 515         ast_mutex_unlock(&p->lock);
 516 #if 0
 517         if( !res )
 518                 ast_log( LOG_DEBUG, "agent_cont_sleep() returning %d\n", res );
 519 #endif
 520         return res;
 521 }
 522
 523 static struct ast_channel *agent_new(struct agent_pvt *p, int state)
 524 {
 525         struct ast_channel *tmp;
 526         struct ast_frame null_frame = { AST_FRAME_NULL };
 527 #if 0
 528         if (!p->chan) {
 529                 ast_log(LOG_WARNING, "No channel? :(\n");
 530                 return NULL;
 531         }
 532 #endif
 533         tmp = ast_channel_alloc(0);
 534         if (tmp) {
 535                 if (p->chan) {
 536                         tmp->nativeformats = p->chan->nativeformats;
 537                         tmp->writeformat = p->chan->writeformat;
 538                         tmp->pvt->rawwriteformat = p->chan->writeformat;
 539                         tmp->readformat = p->chan->readformat;
 540                         tmp->pvt->rawreadformat = p->chan->readformat;
 541                         strncpy(tmp->language, p->chan->language, sizeof(tmp->language)-1);
 542                         strncpy(tmp->context, p->chan->context, sizeof(tmp->context)-1);
 543                         strncpy(tmp->exten, p->chan->exten, sizeof(tmp->exten)-1);
 544                 } else {
 545                         tmp->nativeformats = AST_FORMAT_SLINEAR;
 546                         tmp->writeformat = AST_FORMAT_SLINEAR;
 547                         tmp->pvt->rawwriteformat = AST_FORMAT_SLINEAR;
 548                         tmp->readformat = AST_FORMAT_SLINEAR;
 549                         tmp->pvt->rawreadformat = AST_FORMAT_SLINEAR;
 550                 }
 551                 if (p->pending)
 552                         snprintf(tmp->name, sizeof(tmp->name), "Agent/P%s-%d", p->agent, rand() & 0xffff);
 553                 else
 554                         snprintf(tmp->name, sizeof(tmp->name), "Agent/%s", p->agent);
 555                 tmp->type = type;
 556                 ast_setstate(tmp, state);
 557                 tmp->pvt->pvt = p;
 558                 tmp->pvt->send_digit = agent_digit;
 559                 tmp->pvt->call = agent_call;
 560                 tmp->pvt->hangup = agent_hangup;
 561                 tmp->pvt->answer = agent_answer;
 562                 tmp->pvt->read = agent_read;
 563                 tmp->pvt->write = agent_write;
 564                 tmp->pvt->exception = agent_read;
 565                 tmp->pvt->indicate = agent_indicate;
 566                 tmp->pvt->fixup = agent_fixup;
 567                 p->owner = tmp;
 568                 ast_mutex_lock(&usecnt_lock);
 569                 usecnt++;
 570                 ast_mutex_unlock(&usecnt_lock);
 571                 ast_update_use_count();
 572                 tmp->priority = 1;
 573                 /* Wake up and wait for other applications (by definition the login app)
 574                  * to release this channel). Takes ownership of the agent channel
 575                  * to this thread only.
 576                  * For signalling the other thread, ast_queue_frame is used until we
 577                  * can safely use signals for this purpose. The pselect() needs to be
 578                  * implemented in the kernel for this.
 579                  */
 580                 p->app_sleep_cond = 0;
 581                 if( ast_mutex_trylock(&p->app_lock) )
 582                 {
 583                         if (p->chan) {
 584                                 ast_queue_frame(p->chan, &null_frame, 1);
 585                                 ast_mutex_unlock(&p->lock);     /* For other thread to read the condition. */
 586                                 ast_mutex_lock(&p->app_lock);
 587                                 ast_mutex_lock(&p->lock);
 588                         }
 589                         if( !p->chan )
 590                         {
 591                                 ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n");
 592                                 p->owner = NULL;
 593                                 tmp->pvt->pvt = NULL;
 594                                 p->app_sleep_cond = 1;
 595                                 ast_channel_free( tmp );
 596                                 ast_mutex_unlock(&p->lock);     /* For other thread to read the condition. */
 597                                 ast_mutex_unlock(&p->app_lock);
 598                                 return NULL;
 599                         }
 600                 }
 601                 p->owning_app = pthread_self();
 602                 /* After the above step, there should not be any blockers. */
 603                 if (p->chan) {
 604                         if (p->chan->blocking) {
 605                                 ast_log( LOG_ERROR, "A blocker exists after agent channel ownership acquired\n" );
 606                                 CRASH;
 607                         }
 608                         ast_moh_stop(p->chan);
 609                 }
 610         } else
 611                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
 612         return tmp;
 613 }
 614
 615
 616 static int read_agent_config(void)
 617 {
 618         struct ast_config *cfg;
 619         struct ast_variable *v;
 620         struct agent_pvt *p, *pl, *pn;
 621         group = 0;
 622         autologoff = 0;
 623         wrapuptime = 0;
 624         ackcall = 1;
 625         cfg = ast_load(config);
 626         if (!cfg) {
 627                 ast_log(LOG_NOTICE, "No agent configuration found -- agent support disabled\n");
 628                 return 0;
 629         }
 630         ast_mutex_lock(&agentlock);
 631         p = agents;
 632         while(p) {
 633                 p->dead = 1;
 634                 p = p->next;
 635         }
 636         strcpy(moh, "default");
 637         v = ast_variable_browse(cfg, "agents");
 638         while(v) {
 639                 /* Create the interface list */
 640                 if (!strcasecmp(v->name, "agent")) {
 641                         add_agent(v->value, 0);
 642                 } else if (!strcasecmp(v->name, "group")) {
 643                         group = ast_get_group(v->value);
 644                 } else if (!strcasecmp(v->name, "autologoff")) {
 645                         autologoff = atoi(v->value);
 646                         if (autologoff < 0)
 647                                 autologoff = 0;
 648                 } else if (!strcasecmp(v->name, "ackcall")) {
 649                         ackcall = ast_true(v->value);
 650                 } else if (!strcasecmp(v->name, "wrapuptime")) {
 651                         wrapuptime = atoi(v->value);
 652                         if (wrapuptime < 0)
 653                                 wrapuptime = 0;
 654                 } else if (!strcasecmp(v->name, "musiconhold")) {
 655                         strncpy(moh, v->value, sizeof(moh) - 1);
 656                 }
 657                 v = v->next;
 658         }
 659         p = agents;
 660         pl = NULL;
 661         while(p) {
 662                 pn = p->next;
 663                 if (p->dead) {
 664                         /* Unlink */
 665                         if (pl)
 666                                 pl->next = p->next;
 667                         else
 668                                 agents = p->next;
 669                         /* Destroy if  appropriate */
 670                         if (!p->owner) {
 671                                 if (!p->chan) {
 672                                         free(p);
 673                                 } else {
 674                                         /* Cause them to hang up */
 675                                         ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT);
 676                                 }
 677                         }
 678                 } else
 679                         pl = p;
 680                 p = pn;
 681         }
 682         ast_mutex_unlock(&agentlock);
 683         ast_destroy(cfg);
 684         return 0;
 685 }
 686
 687 static int check_availability(struct agent_pvt *newlyavailable, int needlock)
 688 {
 689         struct ast_channel *chan=NULL, *parent=NULL;
 690         struct agent_pvt *p;
 691         int res;
 692         ast_log(LOG_DEBUG, "Checking availability of '%s'\n", newlyavailable->agent);
 693         if (needlock)
 694                 ast_mutex_lock(&agentlock);
 695         p = agents;
 696         while(p) {
 697                 if (p == newlyavailable) {
 698                         p = p->next;
 699                         continue;
 700                 }
 701                 ast_mutex_lock(&p->lock);
 702                 if (!p->abouttograb && p->pending && ((p->group && (newlyavailable->group & p->group)) || !strcmp(p->agent, newlyavailable->agent))) {
 703                         ast_log(LOG_DEBUG, "Call '%s' looks like a winner for agent '%s'\n", p->owner->name, newlyavailable->agent);
 704                         /* We found a pending call, time to merge */
 705                         chan = agent_new(newlyavailable, AST_STATE_DOWN);
 706                         parent = p->owner;
 707                         p->abouttograb = 1;
 708                         ast_mutex_unlock(&p->lock);
 709                         break;
 710                 }
 711                 ast_mutex_unlock(&p->lock);
 712                 p = p->next;
 713         }
 714         if (needlock)
 715                 ast_mutex_unlock(&agentlock);
 716         if (parent && chan)  {
 717                 ast_log( LOG_DEBUG, "Playing beep, lang '%s'\n", newlyavailable->chan->language);
 718                 res = ast_streamfile(newlyavailable->chan, "beep", newlyavailable->chan->language);
 719                 ast_log( LOG_DEBUG, "Played beep, result '%d'\n", res);
 720                 if (!res) {
 721                         res = ast_waitstream(newlyavailable->chan, "");
 722                         ast_log( LOG_DEBUG, "Waited for stream, result '%d'\n", res);
 723                 }
 724                 if (!res) {
 725                         /* Note -- parent may have disappeared */
 726                         if (p->abouttograb) {
 727                                 ast_setstate(parent, AST_STATE_UP);
 728                                 ast_setstate(chan, AST_STATE_UP);
 729                                 /* Go ahead and mark the channel as a zombie so that masquerade will
 730                                    destroy it for us, and we need not call ast_hangup */
 731                                 ast_mutex_lock(&parent->lock);
 732                                 chan->zombie = 1;
 733                                 ast_channel_masquerade(parent, chan);
 734                                 ast_mutex_unlock(&parent->lock);
 735                                 p->abouttograb = 0;
 736                         } else {
 737                                 ast_log(LOG_DEBUG, "Sneaky, parent disappeared in the mean time...\n");
 738                                 agent_cleanup(newlyavailable);
 739                         }
 740                 } else {
 741                         ast_log(LOG_DEBUG, "Ugh...  Agent hung up at exactly the wrong time\n");
 742                         agent_cleanup(newlyavailable);
 743                 }
 744         }
 745         return 0;
 746 }
 747
 748 static struct ast_channel *agent_request(char *type, int format, void *data)
 749 {
 750         struct agent_pvt *p;
 751         struct ast_channel *chan = NULL;
 752         char *s;
 753         unsigned int groupmatch;
 754         int waitforagent=0;
 755         int hasagent = 0;
 756         s = data;
 757         if ((s[0] == '@') && (sscanf(s + 1, "%d", &groupmatch) == 1)) {
 758                 groupmatch = (1 << groupmatch);
 759         } else if ((s[0] == ':') && (sscanf(s + 1, "%d", &groupmatch) == 1)) {
 760                 groupmatch = (1 << groupmatch);
 761                 waitforagent = 1;
 762         } else {
 763                 groupmatch = 0;
 764         }
 765
 766         /* Check actual logged in agents first */
 767         ast_mutex_lock(&agentlock);
 768         p = agents;
 769         while(p) {
 770                 ast_mutex_lock(&p->lock);
 771                 if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent)) &&
 772                                 !strlen(p->loginchan)) {
 773                         if (p->chan)
 774                                 hasagent++;
 775                         if (!p->lastdisc.tv_sec) {
 776                                 /* Agent must be registered, but not have any active call, and not be in a waiting state */
 777                                 if (!p->owner && p->chan) {
 778                                         /* Fixed agent */
 779                                         chan = agent_new(p, AST_STATE_DOWN);
 780                                 }
 781                                 if (chan) {
 782                                         ast_mutex_unlock(&p->lock);
 783                                         break;
 784                                 }
 785                         }
 786                 }
 787                 ast_mutex_unlock(&p->lock);
 788                 p = p->next;
 789         }
 790         if (!p) {
 791                 p = agents;
 792                 while(p) {
 793                         ast_mutex_lock(&p->lock);
 794                         if (!p->pending && ((groupmatch && (p->group & groupmatch)) || !strcmp(data, p->agent))) {
 795                                 if (p->chan || strlen(p->loginchan))
 796                                         hasagent++;
 797                                 if (!p->lastdisc.tv_sec) {
 798                                         /* Agent must be registered, but not have any active call, and not be in a waiting state */
 799                                         if (!p->owner && p->chan) {
 800                                                 /* Could still get a fixed agent */
 801                                                 chan = agent_new(p, AST_STATE_DOWN);
 802                                         } else if (!p->owner && strlen(p->loginchan)) {
 803                                                 /* Adjustable agent */
 804                                                 p->chan = ast_request("Local", format, p->loginchan);
 805                                                 if (p->chan)
 806                                                         chan = agent_new(p, AST_STATE_DOWN);
 807                                         }
 808                                         if (chan) {
 809                                                 ast_mutex_unlock(&p->lock);
 810                                                 break;
 811                                         }
 812                                 }
 813                         }
 814                         ast_mutex_unlock(&p->lock);
 815                         p = p->next;
 816                 }
 817         }
 818
 819         if (!chan && waitforagent) {
 820                 /* No agent available -- but we're requesting to wait for one.
 821                    Allocate a place holder */
 822                 if (hasagent) {
 823                         ast_log(LOG_DEBUG, "Creating place holder for '%s'\n", s);
 824                         p = add_agent(data, 1);
 825                         p->group = groupmatch;
 826                         chan = agent_new(p, AST_STATE_DOWN);
 827                         if (!chan) {
 828                                 ast_log(LOG_WARNING, "Weird...  Fix this to drop the unused pending agent\n");
 829                         }
 830                 } else
 831                         ast_log(LOG_DEBUG, "Not creating place holder for '%s' since nobody logged in\n");
 832         }
 833         ast_mutex_unlock(&agentlock);
 834         return chan;
 835 }
 836
 837 static int powerof(unsigned int v)
 838 {
 839         int x;
 840         for (x=0;x<32;x++) {
 841                 if (v & (1 << x)) return x;
 842         }
 843         return 0;
 844 }
 845
 846 static int agents_show(int fd, int argc, char **argv)
 847 {
 848         struct agent_pvt *p;
 849         char username[256];
 850         char location[256];
 851         char talkingto[256];
 852         char moh[256];
 853
 854         if (argc != 2)
 855                 return RESULT_SHOWUSAGE;
 856         ast_mutex_lock(&agentlock);
 857         p = agents;
 858         while(p) {
 859                 ast_mutex_lock(&p->lock);
 860                 if (p->pending) {
 861                         if (p->group)
 862                                 ast_cli(fd, "-- Pending call to group %d\n", powerof(p->group));
 863                         else
 864                                 ast_cli(fd, "-- Pending call to agent %s\n", p->agent);
 865                 } else {
 866                         if (strlen(p->name))
 867                                 snprintf(username, sizeof(username), "(%s) ", p->name);
 868                         else
 869                                 strcpy(username, "");
 870                         if (p->chan) {
 871                                 snprintf(location, sizeof(location), "logged in on %s", p->chan->name);
 872                                 if (p->owner && p->owner->bridge) {
 873                                         snprintf(talkingto, sizeof(talkingto), " talking to %s", p->owner->bridge->name);
 874                                 } else {
 875                                         strcpy(talkingto, " is idle");
 876                                 }
 877                         } else if (strlen(p->loginchan)) {
 878                                 snprintf(location, sizeof(location) - 20, "available at '%s'", p->loginchan);
 879                                 strcpy(talkingto, "");
 880                                 if (p->acknowledged)
 881                                         strcat(location, " (Confirmed)");
 882                         } else {
 883                                 strcpy(location, "not logged in");
 884                                 strcpy(talkingto, "");
 885                         }
 886                         if (strlen(p->moh))
 887                                 snprintf(moh, sizeof(moh), " (musiconhold is '%s')", p->moh);
 888                         ast_cli(fd, "%-12.12s %s%s%s%s\n", p->agent,
 889                                         username, location, talkingto, moh);
 890                 }
 891                 ast_mutex_unlock(&p->lock);
 892                 p = p->next;
 893         }
 894         ast_mutex_unlock(&agentlock);
 895         return RESULT_SUCCESS;
 896 }
 897
 898 static char show_agents_usage[] =
 899 "Usage: show agents\n"
 900 "       Provides summary information on agents.\n";
 901
 902 static struct ast_cli_entry cli_show_agents = {
 903         { "show", "agents", NULL }, agents_show,
 904         "Show status of agents", show_agents_usage, NULL };
 905
 906 STANDARD_LOCAL_USER;
 907 LOCAL_USER_DECL;
 908
 909 static int __login_exec(struct ast_channel *chan, void *data, int callbackmode)
 910 {
 911         int res=0;
 912         int tries = 0;
 913         struct agent_pvt *p;
 914         struct localuser *u;
 915         struct timeval tv;
 916         char user[AST_MAX_AGENT];
 917         char pass[AST_MAX_AGENT];
 918         char xpass[AST_MAX_AGENT] = "";
 919         char *errmsg;
 920         char info[512];
 921         char *opt_user = NULL;
 922         char *options = NULL;
 923         char *context = NULL;
 924         char *exten = NULL;
 925         int play_announcement;
 926         char *filename = "agent-loginok";
 927
 928         LOCAL_USER_ADD(u);
 929
 930         /* Parse the arguments XXX Check for failure XXX */
 931         strncpy(info, (char *)data, strlen((char *)data) + AST_MAX_EXTENSION-1);
 932         opt_user = info;
 933         if( opt_user ) {
 934                 options = strchr(opt_user, '|');
 935                 if (options) {
 936                         *options = '\0';
 937                         options++;
 938                         if (callbackmode) {
 939                                 context = strchr(options, '@');
 940                                 if (context) {
 941                                         *context = '\0';
 942                                         context++;
 943                                 }
 944                                 exten = options;
 945                                 while(*exten && ((*exten < '0') || (*exten > '9'))) exten++;
 946                                 if (!*exten)
 947                                         exten = NULL;
 948                         }
 949                 }
 950         }
 951
 952         if (chan->_state != AST_STATE_UP)
 953                 res = ast_answer(chan);
 954         if (!res) {
 955                 if( opt_user && strlen(opt_user))
 956                         strncpy( user, opt_user, AST_MAX_AGENT );
 957                 else
 958                         res = ast_app_getdata(chan, "agent-user", user, sizeof(user) - 1, 0);
 959         }
 960         while (!res && (tries < 3)) {
 961                 /* Check for password */
 962                 ast_mutex_lock(&agentlock);
 963                 p = agents;
 964                 while(p) {
 965                         if (!strcmp(p->agent, user) && !p->pending)
 966                                 strncpy(xpass, p->password, sizeof(xpass) - 1);
 967                         p = p->next;
 968                 }
 969                 ast_mutex_unlock(&agentlock);
 970                 if (!res) {
 971                         if (strlen(xpass))
 972                                 res = ast_app_getdata(chan, "agent-pass", pass, sizeof(pass) - 1, 0);
 973                         else
 974                                 strcpy(pass, "");
 975                 }
 976                 errmsg = "agent-incorrect";
 977
 978 #if 0
 979                 ast_log(LOG_NOTICE, "user: %s, pass: %s\n", user, pass);
 980 #endif
 981
 982                 /* Check again for accuracy */
 983                 ast_mutex_lock(&agentlock);
 984                 p = agents;
 985                 while(p) {
 986                         ast_mutex_lock(&p->lock);
 987                         if (!strcmp(p->agent, user) &&
 988                                 !strcmp(p->password, pass) && !p->pending) {
 989                                         if (!p->chan) {
 990                                                 if (callbackmode) {
 991                                                         char tmpchan[256] = "";
 992                                                         int pos = 0;
 993                                                         /* Retrieve login chan */
 994                                                         for (;;) {
 995                                                                 if (exten) {
 996                                                                         strncpy(tmpchan, exten, sizeof(tmpchan) - 1);
 997                                                                         res = 0;
 998                                                                 } else
 999                                                                         res = ast_app_getdata(chan, "agent-newlocation", tmpchan+pos, sizeof(tmpchan) - 2, 0);
1000                                                                 if (!strlen(tmpchan) || ast_exists_extension(chan, context && strlen(context) ? context : "default", tmpchan,
1001                                                                                         1, NULL))
1002                                                                         break;
1003                                                                 if (exten) {
1004                                                                         ast_log(LOG_WARNING, "Extension '%s' is not valid for automatic login of agent '%s'\n", exten, p->agent);
1005                                                                         exten = NULL;
1006                                                                         pos = 0;
1007                                                                 } else {
1008                                                                         res = ast_streamfile(chan, "invalid", chan->language);
1009                                                                         if (!res)
1010                                                                                 res = ast_waitstream(chan, AST_DIGIT_ANY);
1011                                                                         if (res > 0) {
1012                                                                                 tmpchan[0] = res;
1013                                                                                 tmpchan[1] = '\0';
1014                                                                                 pos = 1;
1015                                                                         } else {
1016                                                                                 tmpchan[0] = '\0';
1017                                                                                 pos = 0;
1018                                                                         }
1019                                                                 }
1020                                                         }
1021                                                         if (!res) {
1022                                                                 if (context && strlen(context) && strlen(tmpchan))
1023                                                                         snprintf(p->loginchan, sizeof(p->loginchan), "%s@%s", tmpchan, context);
1024                                                                 else
1025                                                                         strncpy(p->loginchan, tmpchan, sizeof(p->loginchan) - 1);
1026                                                                 if (!strlen(p->loginchan))
1027                                                                         filename = "agent-loggedoff";
1028                                                                 p->acknowledged = 0;
1029                                                         }
1030                                                 } else {
1031                                                         strcpy(p->loginchan, "");
1032                                                         p->acknowledged = 0;
1033                                                 }
1034                                                 play_announcement = 1;
1035                                                 if( options )
1036                                                         if( strchr( options, 's' ) )
1037                                                                 play_announcement = 0;
1038                                                 if( !res && play_announcement )
1039                                                         res = ast_streamfile(chan, filename, chan->language);
1040                                                 if (!res)
1041                                                         ast_waitstream(chan, "");
1042                                                 if (!res) {
1043                                                         res = ast_set_read_format(chan, ast_best_codec(chan->nativeformats));
1044                                                         if (res)
1045                                                                 ast_log(LOG_WARNING, "Unable to set read format to %d\n", ast_best_codec(chan->nativeformats));
1046                                                 }
1047                                                 if (!res) {
1048                                                         ast_set_write_format(chan, ast_best_codec(chan->nativeformats));
1049                                                         if (res)
1050                                                                 ast_log(LOG_WARNING, "Unable to set write format to %d\n", ast_best_codec(chan->nativeformats));
1051                                                 }
1052                                                 /* Check once more just in case */
1053                                                 if (p->chan)
1054                                                         res = -1;
1055                                                 if (callbackmode && !res) {
1056                                                         /* Just say goodbye and be done with it */
1057                                                         if (!res)
1058                                                                 res = ast_safe_sleep(chan, 500);
1059                                                         res = ast_streamfile(chan, "vm-goodbye", chan->language);
1060                                                         if (!res)
1061                                                                 res = ast_waitstream(chan, "");
1062                                                         if (!res)
1063                                                                 res = ast_safe_sleep(chan, 1000);
1064                                                         ast_mutex_unlock(&p->lock);
1065                                                         ast_mutex_unlock(&agentlock);
1066                                                 } else if (!res) {
1067 #ifdef HONOR_MUSIC_CLASS
1068                                                         /* check if the moh class was changed with setmusiconhold */
1069                                                         if (*(chan->musicclass))
1070                                                                 strncpy(p->moh, chan->musicclass, sizeof(p->moh) - 1);
1071 #endif
1072                                                         ast_moh_start(chan, p->moh);
1073                                                         manager_event(EVENT_FLAG_AGENT, "Agentlogin",
1074                                                                 "Agent: %s\r\n"
1075                                                                 "Channel: %s\r\n",
1076                                                                 p->agent, chan->name);
1077                                                         if (option_verbose > 2)
1078                                                                 ast_verbose(VERBOSE_PREFIX_3 "Agent '%s' logged in (format %s/%s)\n", p->agent,
1079                                                                                                 ast_getformatname(chan->readformat), ast_getformatname(chan->writeformat));
1080                                                         /* Login this channel and wait for it to
1081                                                            go away */
1082                                                         p->chan = chan;
1083                                                         p->acknowledged = 1;
1084                                                         check_availability(p, 0);
1085                                                         ast_mutex_unlock(&p->lock);
1086                                                         ast_mutex_unlock(&agentlock);
1087                                                         while (res >= 0) {
1088                                                                 ast_mutex_lock(&p->lock);
1089                                                                 if (p->chan != chan)
1090                                                                         res = -1;
1091                                                                 ast_mutex_unlock(&p->lock);
1092                                                                 /* Yield here so other interested threads can kick in. */
1093                                                                 sched_yield();
1094                                                                 if (res)
1095                                                                         break;
1096
1097                                                                 ast_mutex_lock(&p->lock);
1098                                                                 if (p->lastdisc.tv_sec) {
1099                                                                         gettimeofday(&tv, NULL);
1100                                                                         if ((tv.tv_sec - p->lastdisc.tv_sec) * 1000 +
1101                                                                                 (tv.tv_usec - p->lastdisc.tv_usec) / 1000 > p->wrapuptime) {
1102                                                                                         ast_log(LOG_DEBUG, "Wrapup time expired!\n");
1103                                                                                 memset(&p->lastdisc, 0, sizeof(p->lastdisc));
1104                                                                                 check_availability(p, 1);
1105                                                                         }
1106                                                                 }
1107                                                                 ast_mutex_unlock(&p->lock);
1108                                                                 /*      Synchronize channel ownership between call to agent and itself. */
1109                                                                 ast_mutex_lock( &p->app_lock );
1110                                                                 ast_mutex_lock(&p->lock);
1111                                                                 p->owning_app = pthread_self();
1112                                                                 ast_mutex_unlock(&p->lock);
1113                                                                 res = ast_safe_sleep_conditional( chan, 1000,
1114                                                                                                                 agent_cont_sleep, p );
1115                                                                 ast_mutex_unlock( &p->app_lock );
1116                                                                 sched_yield();
1117                                                         }
1118                                                         ast_mutex_lock(&p->lock);
1119                                                         if (res && p->owner)
1120                                                                 ast_log(LOG_WARNING, "Huh?  We broke out when there was still an owner?\n");
1121                                                         /* Log us off if appropriate */
1122                                                         if (p->chan == chan)
1123                                                                 p->chan = NULL;
1124                                                         p->acknowledged = 0;
1125                                                         ast_mutex_unlock(&p->lock);
1126                                                         if (option_verbose > 2)
1127                                                                 ast_verbose(VERBOSE_PREFIX_3 "Agent '%s' logged out\n", p->agent);
1128                                                         manager_event(EVENT_FLAG_AGENT, "Agentlogoff",
1129                                                                 "Agent: %s\r\n",
1130                                                                 p->agent);
1131                                                         /* If there is no owner, go ahead and kill it now */
1132                                                         if (p->dead && !p->owner)
1133                                                                 free(p);
1134                                                 }
1135                                                 else {
1136                                                         ast_mutex_unlock(&p->lock);
1137                                                         p = NULL;
1138                                                 }
1139                                                 res = -1;
1140                                         } else {
1141                                                 ast_mutex_unlock(&p->lock);
1142                                                 errmsg = "agent-alreadyon";
1143                                                 p = NULL;
1144                                         }
1145                                         break;
1146                         }
1147                         ast_mutex_unlock(&p->lock);
1148                         p = p->next;
1149                 }
1150                 if (!p)
1151                         ast_mutex_unlock(&agentlock);
1152
1153                 if (!res)
1154                         res = ast_app_getdata(chan, errmsg, user, sizeof(user) - 1, 0);
1155         }
1156
1157         LOCAL_USER_REMOVE(u);
1158         /* Always hangup */
1159         return -1;
1160 }
1161
1162 static int login_exec(struct ast_channel *chan, void *data)
1163 {
1164         return __login_exec(chan, data, 0);
1165 }
1166
1167 static int callback_exec(struct ast_channel *chan, void *data)
1168 {
1169         return __login_exec(chan, data, 1);
1170 }
1171
1172 int load_module()
1173 {
1174         /* Make sure we can register our sip channel type */
1175         if (ast_channel_register(type, tdesc, capability, agent_request)) {
1176                 ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
1177                 return -1;
1178         }
1179         ast_register_application(app, login_exec, synopsis, descrip);
1180         ast_register_application(app2, callback_exec, synopsis2, descrip2);
1181         ast_cli_register(&cli_show_agents);
1182         /* Read in the config */
1183         read_agent_config();
1184         return 0;
1185 }
1186
1187 int reload()
1188 {
1189         read_agent_config();
1190         return 0;
1191 }
1192
1193 int unload_module()
1194 {
1195         struct agent_pvt *p;
1196         /* First, take us out of the channel loop */
1197         ast_cli_unregister(&cli_show_agents);
1198         ast_unregister_application(app);
1199         ast_unregister_application(app2);
1200         ast_channel_unregister(type);
1201         if (!ast_mutex_lock(&agentlock)) {
1202                 /* Hangup all interfaces if they have an owner */
1203                 p = agents;
1204                 while(p) {
1205                         if (p->owner)
1206                                 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
1207                         p = p->next;
1208                 }
1209                 agents = NULL;
1210                 ast_mutex_unlock(&agentlock);
1211         } else {
1212                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
1213                 return -1;
1214         }
1215         return 0;
1216 }
1217
1218 int usecount()
1219 {
1220         int res;
1221         ast_mutex_lock(&usecnt_lock);
1222         res = usecnt;
1223         ast_mutex_unlock(&usecnt_lock);
1224         return res;
1225 }
1226
1227 char *key()
1228 {
1229         return ASTERISK_GPL_KEY;
1230 }
1231
1232 char *description()
1233 {
1234         return desc;
1235 }
1236