channels/chan_local.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2005, 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  * \author Mark Spencer <markster@digium.com>
  22  *
  23  * \brief Local Proxy Channel
  24  *
  25  * \ingroup channel_drivers
  26  */
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <sys/socket.h>
  32 #include <errno.h>
  33 #include <stdlib.h>
  34 #include <fcntl.h>
  35 #include <netdb.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #include <sys/signal.h>
  39
  40 #include "asterisk.h"
  41
  42 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  43
  44 #include "asterisk/lock.h"
  45 #include "asterisk/channel.h"
  46 #include "asterisk/config.h"
  47 #include "asterisk/logger.h"
  48 #include "asterisk/module.h"
  49 #include "asterisk/pbx.h"
  50 #include "asterisk/options.h"
  51 #include "asterisk/lock.h"
  52 #include "asterisk/sched.h"
  53 #include "asterisk/io.h"
  54 #include "asterisk/rtp.h"
  55 #include "asterisk/acl.h"
  56 #include "asterisk/callerid.h"
  57 #include "asterisk/file.h"
  58 #include "asterisk/cli.h"
  59 #include "asterisk/app.h"
  60 #include "asterisk/musiconhold.h"
  61 #include "asterisk/manager.h"
  62 #include "asterisk/stringfields.h"
  63
  64 static const char desc[] = "Local Proxy Channel";
  65 static const char tdesc[] = "Local Proxy Channel Driver";
  66
  67 static int usecnt =0;
  68 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
  69
  70 #define IS_OUTBOUND(a,b) (a == b->chan ? 1 : 0)
  71
  72 static struct ast_channel *local_request(const char *type, int format, void *data, int *cause);
  73 static int local_digit(struct ast_channel *ast, char digit);
  74 static int local_call(struct ast_channel *ast, char *dest, int timeout);
  75 static int local_hangup(struct ast_channel *ast);
  76 static int local_answer(struct ast_channel *ast);
  77 static struct ast_frame *local_read(struct ast_channel *ast);
  78 static int local_write(struct ast_channel *ast, struct ast_frame *f);
  79 static int local_indicate(struct ast_channel *ast, int condition);
  80 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
  81 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen);
  82
  83 /* PBX interface structure for channel registration */
  84 static const struct ast_channel_tech local_tech = {
  85         .type = "Local",
  86         .description = tdesc,
  87         .capabilities = -1,
  88         .requester = local_request,
  89         .send_digit = local_digit,
  90         .call = local_call,
  91         .hangup = local_hangup,
  92         .answer = local_answer,
  93         .read = local_read,
  94         .write = local_write,
  95         .exception = local_read,
  96         .indicate = local_indicate,
  97         .fixup = local_fixup,
  98         .send_html = local_sendhtml,
  99 };
 100
 101 struct local_pvt {
 102         ast_mutex_t lock;                       /* Channel private lock */
 103         char context[AST_MAX_CONTEXT];          /* Context to call */
 104         char exten[AST_MAX_EXTENSION];          /* Extension to call */
 105         int reqformat;                          /* Requested format */
 106         int glaredetect;                        /* Detect glare on hangup */
 107         int cancelqueue;                        /* Cancel queue */
 108         int alreadymasqed;                      /* Already masqueraded */
 109         int launchedpbx;                        /* Did we launch the PBX */
 110         int nooptimization;                     /* Don't leave masq state */
 111         struct ast_channel *owner;              /* Master Channel */
 112         struct ast_channel *chan;               /* Outbound channel */
 113         AST_LIST_ENTRY(local_pvt) list;         /* Next entity */
 114 };
 115
 116 static AST_LIST_HEAD_STATIC(locals, local_pvt);
 117
 118 static int local_queue_frame(struct local_pvt *p, int isoutbound, struct ast_frame *f, struct ast_channel *us)
 119 {
 120         struct ast_channel *other;
 121 retrylock:
 122         /* Recalculate outbound channel */
 123         if (isoutbound) {
 124                 other = p->owner;
 125         } else {
 126                 other = p->chan;
 127         }
 128         /* Set glare detection */
 129         p->glaredetect = 1;
 130         if (p->cancelqueue) {
 131                 /* We had a glare on the hangup.  Forget all this business,
 132                 return and destroy p.  */
 133                 ast_mutex_unlock(&p->lock);
 134                 ast_mutex_destroy(&p->lock);
 135                 free(p);
 136                 return -1;
 137         }
 138         if (!other) {
 139                 p->glaredetect = 0;
 140                 return 0;
 141         }
 142         if (ast_mutex_trylock(&other->lock)) {
 143                 /* Failed to lock.  Release main lock and try again */
 144                 ast_mutex_unlock(&p->lock);
 145                 if (us) {
 146                         if (ast_mutex_unlock(&us->lock)) {
 147                                 ast_log(LOG_WARNING, "%s wasn't locked while sending %d/%d\n",
 148                                         us->name, f->frametype, f->subclass);
 149                                 us = NULL;
 150                         }
 151                 }
 152                 /* Wait just a bit */
 153                 usleep(1);
 154                 /* Only we can destroy ourselves, so we can't disappear here */
 155                 if (us)
 156                         ast_mutex_lock(&us->lock);
 157                 ast_mutex_lock(&p->lock);
 158                 goto retrylock;
 159         }
 160         ast_queue_frame(other, f);
 161         ast_mutex_unlock(&other->lock);
 162         p->glaredetect = 0;
 163         return 0;
 164 }
 165
 166 static int local_answer(struct ast_channel *ast)
 167 {
 168         struct local_pvt *p = ast->tech_pvt;
 169         int isoutbound;
 170         int res = -1;
 171
 172         ast_mutex_lock(&p->lock);
 173         isoutbound = IS_OUTBOUND(ast, p);
 174         if (isoutbound) {
 175                 /* Pass along answer since somebody answered us */
 176                 struct ast_frame answer = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
 177                 res = local_queue_frame(p, isoutbound, &answer, ast);
 178         } else
 179                 ast_log(LOG_WARNING, "Huh?  Local is being asked to answer?\n");
 180         ast_mutex_unlock(&p->lock);
 181         return res;
 182 }
 183
 184 static void check_bridge(struct local_pvt *p, int isoutbound)
 185 {
 186         if (p->alreadymasqed || p->nooptimization)
 187                 return;
 188         if (!p->chan || !p->owner)
 189                 return;
 190         if (isoutbound&& p->chan->_bridge /* Not ast_bridged_channel!  Only go one step! */ && !p->owner->readq) {
 191                 /* Masquerade bridged channel into owner */
 192                 /* Lock everything we need, one by one, and give up if
 193                    we can't get everything.  Remember, we'll get another
 194                    chance in just a little bit */
 195                 if (!ast_mutex_trylock(&(p->chan->_bridge)->lock)) {
 196                         if (!p->chan->_bridge->_softhangup) {
 197                                 if (!ast_mutex_trylock(&p->owner->lock)) {
 198                                         if (!p->owner->_softhangup) {
 199                                                 ast_channel_masquerade(p->owner, p->chan->_bridge);
 200                                                 p->alreadymasqed = 1;
 201                                         }
 202                                         ast_mutex_unlock(&p->owner->lock);
 203                                 }
 204                                 ast_mutex_unlock(&(p->chan->_bridge)->lock);
 205                         }
 206                 }
 207         } else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && !p->chan->readq) {
 208                 /* Masquerade bridged channel into chan */
 209                 if (!ast_mutex_trylock(&(p->owner->_bridge)->lock)) {
 210                         if (!p->owner->_bridge->_softhangup) {
 211                                 if (!ast_mutex_trylock(&p->chan->lock)) {
 212                                         if (!p->chan->_softhangup) {
 213                                                 ast_channel_masquerade(p->chan, p->owner->_bridge);
 214                                                 p->alreadymasqed = 1;
 215                                         }
 216                                         ast_mutex_unlock(&p->chan->lock);
 217                                 }
 218                         }
 219                         ast_mutex_unlock(&(p->owner->_bridge)->lock);
 220                 }
 221         }
 222 }
 223
 224 static struct ast_frame  *local_read(struct ast_channel *ast)
 225 {
 226         return &ast_null_frame;
 227 }
 228
 229 static int local_write(struct ast_channel *ast, struct ast_frame *f)
 230 {
 231         struct local_pvt *p = ast->tech_pvt;
 232         int res = -1;
 233         int isoutbound;
 234
 235         /* Just queue for delivery to the other side */
 236         ast_mutex_lock(&p->lock);
 237         isoutbound = IS_OUTBOUND(ast, p);
 238         if (f && (f->frametype == AST_FRAME_VOICE))
 239                 check_bridge(p, isoutbound);
 240         if (!p->alreadymasqed)
 241                 res = local_queue_frame(p, isoutbound, f, ast);
 242         else {
 243                 ast_log(LOG_DEBUG, "Not posting to queue since already masked on '%s'\n", ast->name);
 244                 res = 0;
 245         }
 246         ast_mutex_unlock(&p->lock);
 247         return res;
 248 }
 249
 250 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
 251 {
 252         struct local_pvt *p = newchan->tech_pvt;
 253         ast_mutex_lock(&p->lock);
 254
 255         if ((p->owner != oldchan) && (p->chan != oldchan)) {
 256                 ast_log(LOG_WARNING, "Old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan);
 257                 ast_mutex_unlock(&p->lock);
 258                 return -1;
 259         }
 260         if (p->owner == oldchan)
 261                 p->owner = newchan;
 262         else
 263                 p->chan = newchan;
 264         ast_mutex_unlock(&p->lock);
 265         return 0;
 266 }
 267
 268 static int local_indicate(struct ast_channel *ast, int condition)
 269 {
 270         struct local_pvt *p = ast->tech_pvt;
 271         int res = -1;
 272         struct ast_frame f = { AST_FRAME_CONTROL, };
 273         int isoutbound;
 274
 275         /* Queue up a frame representing the indication as a control frame */
 276         ast_mutex_lock(&p->lock);
 277         isoutbound = IS_OUTBOUND(ast, p);
 278         f.subclass = condition;
 279         res = local_queue_frame(p, isoutbound, &f, ast);
 280         ast_mutex_unlock(&p->lock);
 281         return res;
 282 }
 283
 284 static int local_digit(struct ast_channel *ast, char digit)
 285 {
 286         struct local_pvt *p = ast->tech_pvt;
 287         int res = -1;
 288         struct ast_frame f = { AST_FRAME_DTMF, };
 289         int isoutbound;
 290
 291         ast_mutex_lock(&p->lock);
 292         isoutbound = IS_OUTBOUND(ast, p);
 293         f.subclass = digit;
 294         res = local_queue_frame(p, isoutbound, &f, ast);
 295         ast_mutex_unlock(&p->lock);
 296         return res;
 297 }
 298
 299 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen)
 300 {
 301         struct local_pvt *p = ast->tech_pvt;
 302         int res = -1;
 303         struct ast_frame f = { AST_FRAME_HTML, };
 304         int isoutbound;
 305
 306         ast_mutex_lock(&p->lock);
 307         isoutbound = IS_OUTBOUND(ast, p);
 308         f.subclass = subclass;
 309         f.data = (char *)data;
 310         f.datalen = datalen;
 311         res = local_queue_frame(p, isoutbound, &f, ast);
 312         ast_mutex_unlock(&p->lock);
 313         return res;
 314 }
 315
 316 /*! \brief Initiate new call, part of PBX interface
 317  *      dest is the dial string */
 318 static int local_call(struct ast_channel *ast, char *dest, int timeout)
 319 {
 320         struct local_pvt *p = ast->tech_pvt;
 321         int res;
 322         struct ast_var_t *varptr = NULL, *new;
 323         size_t len, namelen;
 324
 325         ast_mutex_lock(&p->lock);
 326
 327         p->chan->cid.cid_num = ast_strdup(p->owner->cid.cid_num);
 328         p->chan->cid.cid_name = ast_strdup(p->owner->cid.cid_name);
 329         p->chan->cid.cid_rdnis = ast_strdup(p->owner->cid.cid_rdnis);
 330         p->chan->cid.cid_ani = ast_strdup(p->owner->cid.cid_ani);
 331
 332         ast_string_field_set(p->chan, language, p->owner->language);
 333         ast_string_field_set(p->chan, accountcode, p->owner->accountcode);
 334         p->chan->cdrflags = p->owner->cdrflags;
 335
 336         /* copy the channel variables from the incoming channel to the outgoing channel */
 337         /* Note that due to certain assumptions, they MUST be in the same order */
 338         AST_LIST_TRAVERSE(&p->owner->varshead, varptr, entries) {
 339                 namelen = strlen(varptr->name);
 340                 len = sizeof(struct ast_var_t) + namelen + strlen(varptr->value) + 2;
 341                 if ((new = ast_calloc(1, len))) {
 342                         memcpy(new, varptr, len);
 343                         new->value = &(new->name[0]) + namelen + 1;
 344                         AST_LIST_INSERT_TAIL(&p->chan->varshead, new, entries);
 345                 }
 346         }
 347
 348         p->launchedpbx = 1;
 349
 350         /* Start switch on sub channel */
 351         res = ast_pbx_start(p->chan);
 352         ast_mutex_unlock(&p->lock);
 353         return res;
 354 }
 355
 356 #if 0
 357 static void local_destroy(struct local_pvt *p)
 358 {
 359         struct local_pvt *cur;
 360
 361         AST_LIST_LOCK(&locals);
 362         AST_LIST_TRAVERSE_SAFE_BEGIN(&locals, cur, list) {
 363                 if (cur == p) {
 364                         AST_LIST_REMOVE_CURRENT(&locals, list);
 365                         ast_mutex_destroy(&cur->lock);
 366                         free(cur);
 367                         break;
 368                 }
 369         }
 370         AST_LIST_TRAVERSE_SAFE_END
 371         AST_LIST_UNLOCK(&locals);
 372         if (!cur)
 373                 ast_log(LOG_WARNING, "Unable ot find local '%s@%s' in local list\n", p->exten, p->context);
 374 }
 375 #endif
 376
 377 /*! \brief Hangup a call through the local proxy channel */
 378 static int local_hangup(struct ast_channel *ast)
 379 {
 380         struct local_pvt *p = ast->tech_pvt;
 381         int isoutbound;
 382         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
 383         struct ast_channel *ochan = NULL;
 384         int glaredetect;
 385         const char *status;
 386
 387         ast_mutex_lock(&p->lock);
 388         isoutbound = IS_OUTBOUND(ast, p);
 389         if (isoutbound) {
 390                 status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
 391                 if ((status) && (p->owner))
 392                         pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
 393                 p->chan = NULL;
 394                 p->launchedpbx = 0;
 395         } else
 396                 p->owner = NULL;
 397         ast->tech_pvt = NULL;
 398
 399         ast_mutex_lock(&usecnt_lock);
 400         usecnt--;
 401         ast_mutex_unlock(&usecnt_lock);
 402
 403         if (!p->owner && !p->chan) {
 404                 /* Okay, done with the private part now, too. */
 405                 glaredetect = p->glaredetect;
 406                 /* If we have a queue holding, don't actually destroy p yet, but
 407                    let local_queue do it. */
 408                 if (p->glaredetect)
 409                         p->cancelqueue = 1;
 410                 ast_mutex_unlock(&p->lock);
 411                 /* Remove from list */
 412                 AST_LIST_LOCK(&locals);
 413                 AST_LIST_REMOVE(&locals, p, list);
 414                 AST_LIST_UNLOCK(&locals);
 415                 /* Grab / release lock just in case */
 416                 ast_mutex_lock(&p->lock);
 417                 ast_mutex_unlock(&p->lock);
 418                 /* And destroy */
 419                 if (!glaredetect) {
 420                         ast_mutex_destroy(&p->lock);
 421                         free(p);
 422                 }
 423                 return 0;
 424         }
 425         if (p->chan && !p->launchedpbx)
 426                 /* Need to actually hangup since there is no PBX */
 427                 ochan = p->chan;
 428         else
 429                 local_queue_frame(p, isoutbound, &f, NULL);
 430         ast_mutex_unlock(&p->lock);
 431         if (ochan)
 432                 ast_hangup(ochan);
 433         return 0;
 434 }
 435
 436 /*! \brief Create a call structure */
 437 static struct local_pvt *local_alloc(char *data, int format)
 438 {
 439         struct local_pvt *tmp;
 440         char *c;
 441         char *opts;
 442
 443         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
 444                 return NULL;
 445
 446         ast_mutex_init(&tmp->lock);
 447         strncpy(tmp->exten, data, sizeof(tmp->exten) - 1);
 448         opts = strchr(tmp->exten, '/');
 449         if (opts) {
 450                 *opts='\0';
 451                 opts++;
 452                 if (strchr(opts, 'n'))
 453                         tmp->nooptimization = 1;
 454         }
 455         c = strchr(tmp->exten, '@');
 456         if (c) {
 457                 *c = '\0';
 458                 c++;
 459                 strncpy(tmp->context, c, sizeof(tmp->context) - 1);
 460         } else
 461                 strncpy(tmp->context, "default", sizeof(tmp->context) - 1);
 462         tmp->reqformat = format;
 463         if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
 464                 ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
 465                 ast_mutex_destroy(&tmp->lock);
 466                 free(tmp);
 467                 tmp = NULL;
 468         } else {
 469                 /* Add to list */
 470                 AST_LIST_LOCK(&locals);
 471                 AST_LIST_INSERT_HEAD(&locals, tmp, list);
 472                 AST_LIST_UNLOCK(&locals);
 473         }
 474
 475         return tmp;
 476 }
 477
 478 /*! \brief Start new local channel */
 479 static struct ast_channel *local_new(struct local_pvt *p, int state)
 480 {
 481         struct ast_channel *tmp, *tmp2;
 482         int randnum = rand() & 0xffff;
 483
 484         tmp = ast_channel_alloc(1);
 485         tmp2 = ast_channel_alloc(1);
 486         if (!tmp || !tmp2) {
 487                 if (tmp)
 488                         ast_channel_free(tmp);
 489                 if (tmp2)
 490                         ast_channel_free(tmp2);
 491                 ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
 492                 return NULL;
 493         }
 494
 495         tmp2->tech = tmp->tech = &local_tech;
 496         tmp->nativeformats = p->reqformat;
 497         tmp2->nativeformats = p->reqformat;
 498         ast_string_field_build(tmp, name, "Local/%s@%s-%04x,1", p->exten, p->context, randnum);
 499         ast_string_field_build(tmp2, name, "Local/%s@%s-%04x,2", p->exten, p->context, randnum);
 500         ast_setstate(tmp, state);
 501         ast_setstate(tmp2, AST_STATE_RING);
 502         tmp->writeformat = p->reqformat;
 503         tmp2->writeformat = p->reqformat;
 504         tmp->rawwriteformat = p->reqformat;
 505         tmp2->rawwriteformat = p->reqformat;
 506         tmp->readformat = p->reqformat;
 507         tmp2->readformat = p->reqformat;
 508         tmp->rawreadformat = p->reqformat;
 509         tmp2->rawreadformat = p->reqformat;
 510         tmp->tech_pvt = p;
 511         tmp2->tech_pvt = p;
 512         p->owner = tmp;
 513         p->chan = tmp2;
 514         ast_mutex_lock(&usecnt_lock);
 515         usecnt++;
 516         usecnt++;
 517         ast_mutex_unlock(&usecnt_lock);
 518         ast_update_use_count();
 519         ast_copy_string(tmp->context, p->context, sizeof(tmp->context));
 520         ast_copy_string(tmp2->context, p->context, sizeof(tmp2->context));
 521         ast_copy_string(tmp2->exten, p->exten, sizeof(tmp->exten));
 522         tmp->priority = 1;
 523         tmp2->priority = 1;
 524
 525         return tmp;
 526 }
 527
 528
 529 /*! \brief Part of PBX interface */
 530 static struct ast_channel *local_request(const char *type, int format, void *data, int *cause)
 531 {
 532         struct local_pvt *p;
 533         struct ast_channel *chan = NULL;
 534
 535         p = local_alloc(data, format);
 536         if (p)
 537                 chan = local_new(p, AST_STATE_DOWN);
 538         return chan;
 539 }
 540
 541 /*! \brief CLI command "local show channels" */
 542 static int locals_show(int fd, int argc, char **argv)
 543 {
 544         struct local_pvt *p;
 545
 546         if (argc != 3)
 547                 return RESULT_SHOWUSAGE;
 548         if (AST_LIST_EMPTY(&locals))
 549                 ast_cli(fd, "No local channels in use\n");
 550         AST_LIST_LOCK(&locals);
 551         AST_LIST_TRAVERSE(&locals, p, list) {
 552                 ast_mutex_lock(&p->lock);
 553                 ast_cli(fd, "%s -- %s@%s\n", p->owner ? p->owner->name : "<unowned>", p->exten, p->context);
 554                 ast_mutex_unlock(&p->lock);
 555         }
 556         AST_LIST_UNLOCK(&locals);
 557         return RESULT_SUCCESS;
 558 }
 559
 560 static char show_locals_usage[] =
 561 "Usage: local show channels\n"
 562 "       Provides summary information on active local proxy channels.\n";
 563
 564 static struct ast_cli_entry cli_show_locals = {
 565         { "local", "show", "channels", NULL }, locals_show,
 566         "Show status of local channels", show_locals_usage, NULL };
 567
 568 /*! \brief Load module into PBX, register channel */
 569 int load_module()
 570 {
 571         /* Make sure we can register our channel type */
 572         if (ast_channel_register(&local_tech)) {
 573                 ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
 574                 return -1;
 575         }
 576         ast_cli_register(&cli_show_locals);
 577         return 0;
 578 }
 579
 580 /*! \brief Reload module */
 581 int reload()
 582 {
 583         return 0;
 584 }
 585
 586 /*! \brief Unload the local proxy channel from Asterisk */
 587 int unload_module()
 588 {
 589         struct local_pvt *p;
 590
 591         /* First, take us out of the channel loop */
 592         ast_cli_unregister(&cli_show_locals);
 593         ast_channel_unregister(&local_tech);
 594         if (!AST_LIST_LOCK(&locals)) {
 595                 /* Hangup all interfaces if they have an owner */
 596                 AST_LIST_TRAVERSE(&locals, p, list) {
 597                         if (p->owner)
 598                                 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
 599                 }
 600                 AST_LIST_UNLOCK(&locals);
 601                 AST_LIST_HEAD_DESTROY(&locals);
 602         } else {
 603                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
 604                 return -1;
 605         }
 606         return 0;
 607 }
 608
 609 int usecount()
 610 {
 611         return usecnt;
 612 }
 613
 614 char *key()
 615 {
 616         return ASTERISK_GPL_KEY;
 617 }
 618
 619 char *description()
 620 {
 621         return (char *) desc;
 622 }
 623