channels/chan_oss.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Use /dev/dsp as a channel, and the console to command it :).
   5  *
   6  * The full-duplex "simulation" is pretty weak.  This is generally a
   7  * VERY BADLY WRITTEN DRIVER so please don't use it as a model for
   8  * writing a driver.
   9  *
  10  * Copyright (C) 1999, Mark Spencer
  11  *
  12  * Mark Spencer <markster@linux-support.net>
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License
  16  */
  17
  18 #include <asterisk/frame.h>
  19 #include <asterisk/logger.h>
  20 #include <asterisk/channel.h>
  21 #include <asterisk/module.h>
  22 #include <asterisk/channel_pvt.h>
  23 #include <asterisk/options.h>
  24 #include <asterisk/pbx.h>
  25 #include <asterisk/config.h>
  26 #include <asterisk/cli.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <errno.h>
  30 #include <sys/ioctl.h>
  31 #include <sys/time.h>
  32 #include <string.h>
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <linux/soundcard.h>
  36
  37 /* Which device to use */
  38 #define DEV_DSP "/dev/dsp"
  39
  40 /* Lets use 160 sample frames, just like GSM.  */
  41 #define FRAME_SIZE 160
  42
  43 /* When you set the frame size, you have to come up with
  44    the right buffer format as well. */
  45 /* 5 64-byte frames = one frame */
  46 #define BUFFER_FMT ((buffersize * 5) << 16) | (0x0006);
  47
  48 /* Don't switch between read/write modes faster than every 300 ms */
  49 #define MIN_SWITCH_TIME 600
  50
  51 static struct timeval lasttime;
  52
  53 static int usecnt;
  54 static int needanswer = 0;
  55 static int needhangup = 0;
  56 static int silencesuppression = 0;
  57 static int silencethreshold = 1000;
  58
  59 static char digits[80] = "";
  60
  61 static pthread_mutex_t usecnt_lock = PTHREAD_MUTEX_INITIALIZER;
  62
  63 static char *type = "Console";
  64 static char *desc = "OSS Console Channel Driver";
  65 static char *tdesc = "OSS Console Channel Driver";
  66 static char *config = "oss.conf";
  67
  68 static char context[AST_MAX_EXTENSION] = "default";
  69 static char exten[AST_MAX_EXTENSION] = "s";
  70
  71 /* Some pipes to prevent overflow */
  72 static int funnel[2];
  73 static pthread_mutex_t sound_lock = PTHREAD_MUTEX_INITIALIZER;
  74 static pthread_t silly;
  75
  76 static struct chan_oss_pvt {
  77         /* We only have one OSS structure -- near sighted perhaps, but it
  78            keeps this driver as simple as possible -- as it should be. */
  79         struct ast_channel *owner;
  80         char exten[AST_MAX_EXTENSION];
  81         char context[AST_MAX_EXTENSION];
  82 } oss;
  83
  84 static int time_has_passed()
  85 {
  86         struct timeval tv;
  87         int ms;
  88         gettimeofday(&tv, NULL);
  89         ms = (tv.tv_sec - lasttime.tv_sec) * 1000 +
  90                         (tv.tv_usec - lasttime.tv_usec) / 1000;
  91         if (ms > MIN_SWITCH_TIME)
  92                 return -1;
  93         return 0;
  94 }
  95
  96 /* Number of buffers...  Each is FRAMESIZE/8 ms long.  For example
  97    with 160 sample frames, and a buffer size of 3, we have a 60ms buffer,
  98    usually plenty. */
  99
 100
 101 #define MAX_BUFFER_SIZE 100
 102 static int buffersize = 3;
 103
 104 static int full_duplex = 0;
 105
 106 /* Are we reading or writing (simulated full duplex) */
 107 static int readmode = 1;
 108
 109 /* File descriptor for sound device */
 110 static int sounddev = -1;
 111
 112 static int autoanswer = 1;
 113
 114 static int calc_loudness(short *frame)
 115 {
 116         int sum = 0;
 117         int x;
 118         for (x=0;x<FRAME_SIZE;x++) {
 119                 if (frame[x] < 0)
 120                         sum -= frame[x];
 121                 else
 122                         sum += frame[x];
 123         }
 124         sum = sum/FRAME_SIZE;
 125         return sum;
 126 }
 127
 128 static int silence_suppress(short *buf)
 129 {
 130 #define SILBUF 3
 131         int loudness;
 132         static int silentframes = 0;
 133         static char silbuf[FRAME_SIZE * 2 * SILBUF];
 134         static int silbufcnt=0;
 135         if (!silencesuppression)
 136                 return 0;
 137         loudness = calc_loudness((short *)(buf));
 138         if (option_debug)
 139                 ast_log(LOG_DEBUG, "loudness is %d\n", loudness);
 140         if (loudness < silencethreshold) {
 141                 silentframes++;
 142                 silbufcnt++;
 143                 /* Keep track of the last few bits of silence so we can play
 144                    them as lead-in when the time is right */
 145                 if (silbufcnt >= SILBUF) {
 146                         /* Make way for more buffer */
 147                         memmove(silbuf, silbuf + FRAME_SIZE * 2, FRAME_SIZE * 2 * (SILBUF - 1));
 148                         silbufcnt--;
 149                 }
 150                 memcpy(silbuf + FRAME_SIZE * 2 * silbufcnt, buf, FRAME_SIZE * 2);
 151                 if (silentframes > 10) {
 152                         /* We've had plenty of silence, so compress it now */
 153                         return 1;
 154                 }
 155         } else {
 156                 silentframes=0;
 157                 /* Write any buffered silence we have, it may have something
 158                    important */
 159                 if (silbufcnt) {
 160                         write(funnel[1], silbuf, silbufcnt * FRAME_SIZE);
 161                         silbufcnt = 0;
 162                 }
 163         }
 164         return 0;
 165 }
 166
 167 static void *silly_thread(void *ignore)
 168 {
 169         char buf[FRAME_SIZE * 2];
 170         int pos=0;
 171         int res=0;
 172         /* Read from the sound device, and write to the pipe. */
 173         for (;;) {
 174                 /* Give the writer a better shot at the lock */
 175 #if 0
 176                 usleep(1000);
 177 #endif
 178                 pthread_testcancel();
 179                 pthread_mutex_lock(&sound_lock);
 180                 res = read(sounddev, buf + pos, FRAME_SIZE * 2 - pos);
 181                 pthread_mutex_unlock(&sound_lock);
 182                 if (res > 0) {
 183                         pos += res;
 184                         if (pos == FRAME_SIZE * 2) {
 185                                 if (needhangup || needanswer || strlen(digits) ||
 186                                     !silence_suppress((short *)buf)) {
 187                                         res = write(funnel[1], buf, sizeof(buf));
 188                                 }
 189                                 pos = 0;
 190                         }
 191                 } else {
 192                         close(funnel[1]);
 193                         break;
 194                 }
 195                 pthread_testcancel();
 196         }
 197         return NULL;
 198 }
 199
 200 static int setformat(void)
 201 {
 202         int fmt, desired, res, fd = sounddev;
 203         static int warnedalready = 0;
 204         static int warnedalready2 = 0;
 205         pthread_mutex_lock(&sound_lock);
 206         fmt = AFMT_S16_LE;
 207         res = ioctl(fd, SNDCTL_DSP_SETFMT, &fmt);
 208         if (res < 0) {
 209                 ast_log(LOG_WARNING, "Unable to set format to 16-bit signed\n");
 210                 pthread_mutex_unlock(&sound_lock);
 211                 return -1;
 212         }
 213         res = ioctl(fd, SNDCTL_DSP_SETDUPLEX, 0);
 214         if (res >= 0) {
 215                 if (option_verbose > 1)
 216                         ast_verbose(VERBOSE_PREFIX_2 "Console is full duplex\n");
 217                 full_duplex = -1;
 218         }
 219         fmt = 0;
 220         res = ioctl(fd, SNDCTL_DSP_STEREO, &fmt);
 221         if (res < 0) {
 222                 ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
 223                 pthread_mutex_unlock(&sound_lock);
 224                 return -1;
 225         }
 226         /* 8000 Hz desired */
 227         desired = 8000;
 228         fmt = desired;
 229         res = ioctl(fd, SNDCTL_DSP_SPEED, &fmt);
 230         if (res < 0) {
 231                 ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
 232                 pthread_mutex_unlock(&sound_lock);
 233                 return -1;
 234         }
 235         if (fmt != desired) {
 236                 if (!warnedalready++)
 237                         ast_log(LOG_WARNING, "Requested %d Hz, got %d Hz -- sound may be choppy\n", desired, fmt);
 238         }
 239 #if 1
 240         fmt = BUFFER_FMT;
 241         res = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &fmt);
 242         if (res < 0) {
 243                 if (!warnedalready2++)
 244                         ast_log(LOG_WARNING, "Unable to set fragment size -- sound may be choppy\n");
 245         }
 246 #endif
 247         pthread_mutex_unlock(&sound_lock);
 248         return 0;
 249 }
 250
 251 static int soundcard_setoutput(int force)
 252 {
 253         /* Make sure the soundcard is in output mode.  */
 254         int fd = sounddev;
 255         if (full_duplex || (!readmode && !force))
 256                 return 0;
 257         pthread_mutex_lock(&sound_lock);
 258         readmode = 0;
 259         if (force || time_has_passed()) {
 260                 ioctl(sounddev, SNDCTL_DSP_RESET);
 261                 /* Keep the same fd reserved by closing the sound device and copying stdin at the same
 262                    time. */
 263                 /* dup2(0, sound); */
 264                 close(sounddev);
 265                 fd = open(DEV_DSP, O_WRONLY);
 266                 if (fd < 0) {
 267                         ast_log(LOG_WARNING, "Unable to re-open DSP device: %s\n", strerror(errno));
 268                         pthread_mutex_unlock(&sound_lock);
 269                         return -1;
 270                 }
 271                 /* dup2 will close the original and make fd be sound */
 272                 if (dup2(fd, sounddev) < 0) {
 273                         ast_log(LOG_WARNING, "dup2() failed: %s\n", strerror(errno));
 274                         pthread_mutex_unlock(&sound_lock);
 275                         return -1;
 276                 }
 277                 if (setformat()) {
 278                         pthread_mutex_unlock(&sound_lock);
 279                         return -1;
 280                 }
 281                 pthread_mutex_unlock(&sound_lock);
 282                 return 0;
 283         }
 284         pthread_mutex_unlock(&sound_lock);
 285         return 1;
 286 }
 287
 288 static int soundcard_setinput(int force)
 289 {
 290         int fd = sounddev;
 291         if (full_duplex || (readmode && !force))
 292                 return 0;
 293         pthread_mutex_lock(&sound_lock);
 294         readmode = -1;
 295         if (force || time_has_passed()) {
 296                 ioctl(sounddev, SNDCTL_DSP_RESET);
 297                 close(sounddev);
 298                 /* dup2(0, sound); */
 299                 fd = open(DEV_DSP, O_RDONLY);
 300                 if (fd < 0) {
 301                         ast_log(LOG_WARNING, "Unable to re-open DSP device: %s\n", strerror(errno));
 302                         pthread_mutex_unlock(&sound_lock);
 303                         return -1;
 304                 }
 305                 /* dup2 will close the original and make fd be sound */
 306                 if (dup2(fd, sounddev) < 0) {
 307                         ast_log(LOG_WARNING, "dup2() failed: %s\n", strerror(errno));
 308                         pthread_mutex_unlock(&sound_lock);
 309                         return -1;
 310                 }
 311                 if (setformat()) {
 312                         pthread_mutex_unlock(&sound_lock);
 313                         return -1;
 314                 }
 315                 pthread_mutex_unlock(&sound_lock);
 316                 return 0;
 317         }
 318         pthread_mutex_unlock(&sound_lock);
 319         return 1;
 320 }
 321
 322 static int soundcard_init()
 323 {
 324         /* Assume it's full duplex for starters */
 325         int fd = open(DEV_DSP,  O_RDWR);
 326         if (fd < 0) {
 327                 ast_log(LOG_ERROR, "Unable to open %s: %s\n", DEV_DSP, strerror(errno));
 328                 return fd;
 329         }
 330         gettimeofday(&lasttime, NULL);
 331         sounddev = fd;
 332         setformat();
 333         if (!full_duplex)
 334                 soundcard_setinput(1);
 335         return sounddev;
 336 }
 337
 338 static int oss_digit(struct ast_channel *c, char digit)
 339 {
 340         ast_verbose( " << Console Received digit %c >> \n", digit);
 341         return 0;
 342 }
 343
 344 static int oss_call(struct ast_channel *c, char *dest, int timeout)
 345 {
 346         ast_verbose( " << Call placed to '%s' on console >> \n", dest);
 347         if (autoanswer) {
 348                 ast_verbose( " << Auto-answered >> \n" );
 349                 needanswer = 1;
 350         } else {
 351                 ast_verbose( " << Type 'answer' to answer, or use 'autoanswer' for future calls >> \n");
 352         }
 353         return 0;
 354 }
 355
 356 static int oss_answer(struct ast_channel *c)
 357 {
 358         ast_verbose( " << Console call has been answered >> \n");
 359         c->state = AST_STATE_UP;
 360         return 0;
 361 }
 362
 363 static int oss_hangup(struct ast_channel *c)
 364 {
 365         c->pvt->pvt = NULL;
 366         oss.owner = NULL;
 367         ast_verbose( " << Hangup on console >> \n");
 368         pthread_mutex_lock(&usecnt_lock);
 369         usecnt--;
 370         pthread_mutex_unlock(&usecnt_lock);
 371         needhangup = 0;
 372         needanswer = 0;
 373         return 0;
 374 }
 375
 376 static int soundcard_writeframe(short *data)
 377 {
 378         /* Write an exactly FRAME_SIZE sized of frame */
 379         static int bufcnt = 0;
 380         static char buffer[FRAME_SIZE * 2 * MAX_BUFFER_SIZE * 5];
 381         struct audio_buf_info info;
 382         int res;
 383         int fd = sounddev;
 384         static int warned=0;
 385         pthread_mutex_lock(&sound_lock);
 386         if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info)) {
 387                 if (!warned)
 388                         ast_log(LOG_WARNING, "Error reading output space\n");
 389                 bufcnt = buffersize;
 390                 warned++;
 391         }
 392         if ((info.fragments >= buffersize * 5) && (bufcnt == buffersize)) {
 393                 /* We've run out of stuff, buffer again */
 394                 bufcnt = 0;
 395         }
 396         if (bufcnt == buffersize) {
 397                 /* Write sample immediately */
 398                 res = write(fd, ((void *)data), FRAME_SIZE * 2);
 399         } else {
 400                 /* Copy the data into our buffer */
 401                 res = FRAME_SIZE * 2;
 402                 memcpy(buffer + (bufcnt * FRAME_SIZE * 2), data, FRAME_SIZE * 2);
 403                 bufcnt++;
 404                 if (bufcnt == buffersize) {
 405                         res = write(fd, ((void *)buffer), FRAME_SIZE * 2 * buffersize);
 406                 }
 407         }
 408         pthread_mutex_unlock(&sound_lock);
 409         return res;
 410 }
 411
 412
 413 static int oss_write(struct ast_channel *chan, struct ast_frame *f)
 414 {
 415         int res;
 416         static char sizbuf[8000];
 417         static int sizpos = 0;
 418         int len = sizpos;
 419         int pos;
 420         if (!full_duplex && (strlen(digits) || needhangup || needanswer)) {
 421                 /* If we're half duplex, we have to switch to read mode
 422                    to honor immediate needs if necessary */
 423                 res = soundcard_setinput(1);
 424                 if (res < 0) {
 425                         ast_log(LOG_WARNING, "Unable to set device to input mode\n");
 426                         return -1;
 427                 }
 428                 return 0;
 429         }
 430         res = soundcard_setoutput(0);
 431         if (res < 0) {
 432                 ast_log(LOG_WARNING, "Unable to set output device\n");
 433                 return -1;
 434         } else if (res > 0) {
 435                 /* The device is still in read mode, and it's too soon to change it,
 436                    so just pretend we wrote it */
 437                 return 0;
 438         }
 439         /* We have to digest the frame in 160-byte portions */
 440         if (f->datalen > sizeof(sizbuf) - sizpos) {
 441                 ast_log(LOG_WARNING, "Frame too large\n");
 442                 return -1;
 443         }
 444         memcpy(sizbuf + sizpos, f->data, f->datalen);
 445         len += f->datalen;
 446         pos = 0;
 447         while(len - pos > FRAME_SIZE * 2) {
 448                 soundcard_writeframe((short *)(sizbuf + pos));
 449                 pos += FRAME_SIZE * 2;
 450         }
 451         if (len - pos)
 452                 memmove(sizbuf, sizbuf + pos, len - pos);
 453         sizpos = len - pos;
 454         return 0;
 455 }
 456
 457 static struct ast_frame *oss_read(struct ast_channel *chan)
 458 {
 459         static struct ast_frame f;
 460         static char buf[FRAME_SIZE * 2 + AST_FRIENDLY_OFFSET];
 461         static int readpos = 0;
 462         int res;
 463
 464 #if 0
 465         ast_log(LOG_DEBUG, "oss_read()\n");
 466 #endif
 467
 468         f.frametype = AST_FRAME_NULL;
 469         f.subclass = 0;
 470         f.timelen = 0;
 471         f.datalen = 0;
 472         f.data = NULL;
 473         f.offset = 0;
 474         f.src = type;
 475         f.mallocd = 0;
 476
 477         if (needhangup) {
 478                 return NULL;
 479         }
 480         if (strlen(digits)) {
 481                 f.frametype = AST_FRAME_DTMF;
 482                 f.subclass = digits[0];
 483                 for (res=0;res<strlen(digits);res++)
 484                         digits[res] = digits[res + 1];
 485                 return &f;
 486         }
 487
 488         if (needanswer) {
 489                 needanswer = 0;
 490                 f.frametype = AST_FRAME_CONTROL;
 491                 f.subclass = AST_CONTROL_ANSWER;
 492                 chan->state = AST_STATE_UP;
 493                 return &f;
 494         }
 495
 496         res = soundcard_setinput(0);
 497         if (res < 0) {
 498                 ast_log(LOG_WARNING, "Unable to set input mode\n");
 499                 return NULL;
 500         }
 501         if (res > 0) {
 502                 /* Theoretically shouldn't happen, but anyway, return a NULL frame */
 503                 return &f;
 504         }
 505         res = read(funnel[0], buf + AST_FRIENDLY_OFFSET + readpos, FRAME_SIZE * 2 - readpos);
 506         if (res < 0) {
 507                 ast_log(LOG_WARNING, "Error reading from sound device: %s\n", strerror(errno));
 508                 return NULL;
 509         }
 510         readpos += res;
 511
 512         if (readpos == FRAME_SIZE * 2) {
 513                 /* A real frame */
 514                 readpos = 0;
 515                 f.frametype = AST_FRAME_VOICE;
 516                 f.subclass = AST_FORMAT_SLINEAR;
 517                 f.timelen = FRAME_SIZE / 8;
 518                 f.datalen = FRAME_SIZE * 2;
 519                 f.data = buf + AST_FRIENDLY_OFFSET;
 520                 f.offset = AST_FRIENDLY_OFFSET;
 521                 f.src = type;
 522                 f.mallocd = 0;
 523         }
 524         return &f;
 525 }
 526
 527 static struct ast_channel *oss_new(struct chan_oss_pvt *p, int state)
 528 {
 529         struct ast_channel *tmp;
 530         tmp = ast_channel_alloc();
 531         if (tmp) {
 532                 snprintf(tmp->name, sizeof(tmp->name), "OSS/%s", DEV_DSP + 5);
 533                 tmp->type = type;
 534                 tmp->fd = funnel[0];
 535                 tmp->format = AST_FORMAT_SLINEAR;
 536                 tmp->pvt->pvt = p;
 537                 tmp->pvt->send_digit = oss_digit;
 538                 tmp->pvt->hangup = oss_hangup;
 539                 tmp->pvt->answer = oss_answer;
 540                 tmp->pvt->read = oss_read;
 541                 tmp->pvt->write = oss_write;
 542                 if (strlen(p->context))
 543                         strncpy(tmp->context, p->context, sizeof(tmp->context));
 544                 if (strlen(p->exten))
 545                         strncpy(tmp->exten, p->exten, sizeof(tmp->exten));
 546                 p->owner = tmp;
 547                 tmp->state = state;
 548                 pthread_mutex_lock(&usecnt_lock);
 549                 usecnt++;
 550                 pthread_mutex_unlock(&usecnt_lock);
 551                 ast_update_use_count();
 552                 if (state != AST_STATE_DOWN) {
 553                         if (ast_pbx_start(tmp)) {
 554                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
 555                                 ast_hangup(tmp);
 556                                 tmp = NULL;
 557                         }
 558                 }
 559         }
 560         return tmp;
 561 }
 562
 563 static struct ast_channel *oss_request(char *type, int format, void *data)
 564 {
 565         int oldformat = format;
 566         format &= AST_FORMAT_SLINEAR;
 567         if (!format) {
 568                 ast_log(LOG_NOTICE, "Asked to get a channel of format '%d'\n", oldformat);
 569                 return NULL;
 570         }
 571         if (oss.owner) {
 572                 ast_log(LOG_NOTICE, "Already have a call on the OSS channel\n");
 573                 return NULL;
 574         }
 575         return oss_new(&oss, AST_STATE_DOWN);
 576 }
 577
 578 static int console_autoanswer(int fd, int argc, char *argv[])
 579 {
 580         if ((argc != 1) && (argc != 2))
 581                 return RESULT_SHOWUSAGE;
 582         if (argc == 1) {
 583                 ast_cli(fd, "Auto answer is %s.\n", autoanswer ? "on" : "off");
 584                 return RESULT_SUCCESS;
 585         } else {
 586                 if (!strcasecmp(argv[1], "on"))
 587                         autoanswer = -1;
 588                 else if (!strcasecmp(argv[1], "off"))
 589                         autoanswer = 0;
 590                 else
 591                         return RESULT_SHOWUSAGE;
 592         }
 593         return RESULT_SUCCESS;
 594 }
 595
 596 static char *autoanswer_complete(char *line, char *word, int pos, int state)
 597 {
 598 #ifndef MIN
 599 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 600 #endif
 601         switch(state) {
 602         case 0:
 603                 if (strlen(word) && !strncasecmp(word, "on", MIN(strlen(word), 2)))
 604                         return strdup("on");
 605         case 1:
 606                 if (strlen(word) && !strncasecmp(word, "off", MIN(strlen(word), 3)))
 607                         return strdup("off");
 608         default:
 609                 return NULL;
 610         }
 611         return NULL;
 612 }
 613
 614 static char autoanswer_usage[] =
 615 "Usage: autoanswer [on|off]\n"
 616 "       Enables or disables autoanswer feature.  If used without\n"
 617 "       argument, displays the current on/off status of autoanswer.\n"
 618 "       The default value of autoanswer is in 'oss.conf'.\n";
 619
 620 static int console_answer(int fd, int argc, char *argv[])
 621 {
 622         if (argc != 1)
 623                 return RESULT_SHOWUSAGE;
 624         if (!oss.owner) {
 625                 ast_cli(fd, "No one is calling us\n");
 626                 return RESULT_FAILURE;
 627         }
 628         needanswer++;
 629         return RESULT_SUCCESS;
 630 }
 631
 632 static char answer_usage[] =
 633 "Usage: answer\n"
 634 "       Answers an incoming call on the console (OSS) channel.\n";
 635
 636 static int console_hangup(int fd, int argc, char *argv[])
 637 {
 638         if (argc != 1)
 639                 return RESULT_SHOWUSAGE;
 640         if (!oss.owner) {
 641                 ast_cli(fd, "No call to hangup up\n");
 642                 return RESULT_FAILURE;
 643         }
 644         needhangup++;
 645         return RESULT_SUCCESS;
 646 }
 647
 648 static char hangup_usage[] =
 649 "Usage: hangup\n"
 650 "       Hangs up any call currently placed on the console.\n";
 651
 652
 653 static int console_dial(int fd, int argc, char *argv[])
 654 {
 655         char tmp[256], *tmp2;
 656         char *mye, *myc;
 657         if ((argc != 1) && (argc != 2))
 658                 return RESULT_SHOWUSAGE;
 659         if (oss.owner) {
 660                 if (argc == 2)
 661                         strncat(digits, argv[1], sizeof(digits) - strlen(digits));
 662                 else {
 663                         ast_cli(fd, "You're already in a call.  You can use this only to dial digits until you hangup\n");
 664                         return RESULT_FAILURE;
 665                 }
 666                 return RESULT_SUCCESS;
 667         }
 668         mye = exten;
 669         myc = context;
 670         if (argc == 2) {
 671                 strncpy(tmp, argv[1], sizeof(tmp));
 672                 strtok(tmp, "@");
 673                 tmp2 = strtok(NULL, "@");
 674                 if (strlen(tmp))
 675                         mye = tmp;
 676                 if (tmp2 && strlen(tmp2))
 677                         myc = tmp2;
 678         }
 679         if (ast_exists_extension(NULL, myc, mye, 1)) {
 680                 strncpy(oss.exten, mye, sizeof(oss.exten));
 681                 strncpy(oss.context, myc, sizeof(oss.context));
 682                 oss_new(&oss, AST_STATE_UP);
 683         } else
 684                 ast_cli(fd, "No such extension '%s' in context '%s'\n", mye, myc);
 685         return RESULT_SUCCESS;
 686 }
 687
 688 static char dial_usage[] =
 689 "Usage: dial [extension[@context]]\n"
 690 "       Dials a given extensison (";
 691
 692
 693 static struct ast_cli_entry myclis[] = {
 694         { { "answer", NULL }, console_answer, "Answer an incoming console call", answer_usage },
 695         { { "hangup", NULL }, console_hangup, "Hangup a call on the console", hangup_usage },
 696         { { "dial", NULL }, console_dial, "Dial an extension on the console", dial_usage },
 697         { { "autoanswer", NULL }, console_autoanswer, "Sets/displays autoanswer", autoanswer_usage, autoanswer_complete }
 698 };
 699
 700 int load_module()
 701 {
 702         int res;
 703         int x;
 704         int flags;
 705         struct ast_config *cfg = ast_load(config);
 706         struct ast_variable *v;
 707         res = pipe(funnel);
 708         if (res) {
 709                 ast_log(LOG_ERROR, "Unable to create pipe\n");
 710                 return -1;
 711         }
 712         /* We make the funnel so that writes to the funnel don't block...
 713            Our "silly" thread can read to its heart content, preventing
 714            recording overruns */
 715         flags = fcntl(funnel[1], F_GETFL);
 716 #if 0
 717         fcntl(funnel[0], F_SETFL, flags | O_NONBLOCK);
 718 #endif
 719         fcntl(funnel[1], F_SETFL, flags | O_NONBLOCK);
 720         res = soundcard_init();
 721         if (res < 0) {
 722                 close(funnel[1]);
 723                 close(funnel[0]);
 724                 return -1;
 725         }
 726         if (!full_duplex)
 727                 ast_log(LOG_WARNING, "XXX I don't work right with non-full duplex sound cards XXX\n");
 728         pthread_create(&silly, NULL, silly_thread, NULL);
 729         res = ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR, oss_request);
 730         if (res < 0) {
 731                 ast_log(LOG_ERROR, "Unable to register channel class '%s'\n", type);
 732                 return -1;
 733         }
 734         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
 735                 ast_cli_register(myclis + x);
 736         if (cfg) {
 737                 v = ast_variable_browse(cfg, "general");
 738                 while(v) {
 739                         if (!strcasecmp(v->name, "autoanswer"))
 740                                 autoanswer = ast_true(v->value);
 741                         else if (!strcasecmp(v->name, "silencesuppression"))
 742                                 silencesuppression = ast_true(v->value);
 743                         else if (!strcasecmp(v->name, "silencethreshold"))
 744                                 silencethreshold = atoi(v->value);
 745                         else if (!strcasecmp(v->name, "context"))
 746                                 strncpy(context, v->value, sizeof(context));
 747                         else if (!strcasecmp(v->name, "extension"))
 748                                 strncpy(exten, v->value, sizeof(exten));
 749                         v=v->next;
 750                 }
 751                 ast_destroy(cfg);
 752         }
 753         return 0;
 754 }
 755
 756
 757
 758 int unload_module()
 759 {
 760         int x;
 761         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
 762                 ast_cli_unregister(myclis + x);
 763         close(sounddev);
 764         if (funnel[0] > 0) {
 765                 close(funnel[0]);
 766                 close(funnel[1]);
 767         }
 768         if (silly) {
 769                 pthread_cancel(silly);
 770                 pthread_join(silly, NULL);
 771         }
 772         if (oss.owner)
 773                 ast_softhangup(oss.owner);
 774         if (oss.owner)
 775                 return -1;
 776         return 0;
 777 }
 778
 779 char *description()
 780 {
 781         return desc;
 782 }
 783
 784 int usecount()
 785 {
 786         int res;
 787         pthread_mutex_lock(&usecnt_lock);
 788         res = usecnt;
 789         pthread_mutex_unlock(&usecnt_lock);
 790         return res;
 791 }