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 - 2005, Digium, Inc.
  11  *
  12  * Mark Spencer <markster@digium.com>
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License
  16  */
  17
  18 #include <asterisk/lock.h>
  19 #include <asterisk/frame.h>
  20 #include <asterisk/logger.h>
  21 #include <asterisk/channel.h>
  22 #include <asterisk/module.h>
  23 #include <asterisk/channel_pvt.h>
  24 #include <asterisk/options.h>
  25 #include <asterisk/pbx.h>
  26 #include <asterisk/config.h>
  27 #include <asterisk/cli.h>
  28 #include <asterisk/utils.h>
  29 #include <asterisk/causes.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <errno.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/time.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #ifdef __linux
  39 #include <linux/soundcard.h>
  40 #elif defined(__FreeBSD__)
  41 #include <sys/soundcard.h>
  42 #else
  43 #include <soundcard.h>
  44 #endif
  45 #include "busy.h"
  46 #include "ringtone.h"
  47 #include "ring10.h"
  48 #include "answer.h"
  49
  50 /* Which device to use */
  51 #if defined( __OpenBSD__ ) || defined( __NetBSD__ )
  52 #define DEV_DSP "/dev/audio"
  53 #else
  54 #define DEV_DSP "/dev/dsp"
  55 #endif
  56
  57 /* Lets use 160 sample frames, just like GSM.  */
  58 #define FRAME_SIZE 160
  59
  60 /* When you set the frame size, you have to come up with
  61    the right buffer format as well. */
  62 /* 5 64-byte frames = one frame */
  63 #define BUFFER_FMT ((buffersize * 10) << 16) | (0x0006);
  64
  65 /* Don't switch between read/write modes faster than every 300 ms */
  66 #define MIN_SWITCH_TIME 600
  67
  68 static struct timeval lasttime;
  69
  70 static int usecnt;
  71 static int silencesuppression = 0;
  72 static int silencethreshold = 1000;
  73
  74
  75 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
  76
  77 static char *type = "Console";
  78 static char *desc = "OSS Console Channel Driver";
  79 static char *tdesc = "OSS Console Channel Driver";
  80 static char *config = "oss.conf";
  81
  82 static char context[AST_MAX_EXTENSION] = "default";
  83 static char language[MAX_LANGUAGE] = "";
  84 static char exten[AST_MAX_EXTENSION] = "s";
  85
  86 static int hookstate=0;
  87
  88 static short silence[FRAME_SIZE] = {0, };
  89
  90 struct sound {
  91         int ind;
  92         short *data;
  93         int datalen;
  94         int samplen;
  95         int silencelen;
  96         int repeat;
  97 };
  98
  99 static struct sound sounds[] = {
 100         { AST_CONTROL_RINGING, ringtone, sizeof(ringtone)/2, 16000, 32000, 1 },
 101         { AST_CONTROL_BUSY, busy, sizeof(busy)/2, 4000, 4000, 1 },
 102         { AST_CONTROL_CONGESTION, busy, sizeof(busy)/2, 2000, 2000, 1 },
 103         { AST_CONTROL_RING, ring10, sizeof(ring10)/2, 16000, 32000, 1 },
 104         { AST_CONTROL_ANSWER, answer, sizeof(answer)/2, 2200, 0, 0 },
 105 };
 106
 107 /* Sound command pipe */
 108 static int sndcmd[2];
 109
 110 static struct chan_oss_pvt {
 111         /* We only have one OSS structure -- near sighted perhaps, but it
 112            keeps this driver as simple as possible -- as it should be. */
 113         struct ast_channel *owner;
 114         char exten[AST_MAX_EXTENSION];
 115         char context[AST_MAX_EXTENSION];
 116 } oss;
 117
 118 static int time_has_passed(void)
 119 {
 120         struct timeval tv;
 121         int ms;
 122         gettimeofday(&tv, NULL);
 123         ms = (tv.tv_sec - lasttime.tv_sec) * 1000 +
 124                         (tv.tv_usec - lasttime.tv_usec) / 1000;
 125         if (ms > MIN_SWITCH_TIME)
 126                 return -1;
 127         return 0;
 128 }
 129
 130 /* Number of buffers...  Each is FRAMESIZE/8 ms long.  For example
 131    with 160 sample frames, and a buffer size of 3, we have a 60ms buffer,
 132    usually plenty. */
 133
 134 static pthread_t sthread;
 135
 136 #define MAX_BUFFER_SIZE 100
 137 static int buffersize = 3;
 138
 139 static int full_duplex = 0;
 140
 141 /* Are we reading or writing (simulated full duplex) */
 142 static int readmode = 1;
 143
 144 /* File descriptor for sound device */
 145 static int sounddev = -1;
 146
 147 static int autoanswer = 1;
 148
 149 #if 0
 150 static int calc_loudness(short *frame)
 151 {
 152         int sum = 0;
 153         int x;
 154         for (x=0;x<FRAME_SIZE;x++) {
 155                 if (frame[x] < 0)
 156                         sum -= frame[x];
 157                 else
 158                         sum += frame[x];
 159         }
 160         sum = sum/FRAME_SIZE;
 161         return sum;
 162 }
 163 #endif
 164
 165 static int cursound = -1;
 166 static int sampsent = 0;
 167 static int silencelen=0;
 168 static int offset=0;
 169 static int nosound=0;
 170
 171 static int send_sound(void)
 172 {
 173         short myframe[FRAME_SIZE];
 174         int total = FRAME_SIZE;
 175         short *frame = NULL;
 176         int amt=0;
 177         int res;
 178         int myoff;
 179         audio_buf_info abi;
 180         if (cursound > -1) {
 181                 res = ioctl(sounddev, SNDCTL_DSP_GETOSPACE ,&abi);
 182                 if (res) {
 183                         ast_log(LOG_WARNING, "Unable to read output space\n");
 184                         return -1;
 185                 }
 186                 /* Calculate how many samples we can send, max */
 187                 if (total > (abi.fragments * abi.fragsize / 2))
 188                         total = abi.fragments * abi.fragsize / 2;
 189                 res = total;
 190                 if (sampsent < sounds[cursound].samplen) {
 191                         myoff=0;
 192                         while(total) {
 193                                 amt = total;
 194                                 if (amt > (sounds[cursound].datalen - offset))
 195                                         amt = sounds[cursound].datalen - offset;
 196                                 memcpy(myframe + myoff, sounds[cursound].data + offset, amt * 2);
 197                                 total -= amt;
 198                                 offset += amt;
 199                                 sampsent += amt;
 200                                 myoff += amt;
 201                                 if (offset >= sounds[cursound].datalen)
 202                                         offset = 0;
 203                         }
 204                         /* Set it up for silence */
 205                         if (sampsent >= sounds[cursound].samplen)
 206                                 silencelen = sounds[cursound].silencelen;
 207                         frame = myframe;
 208                 } else {
 209                         if (silencelen > 0) {
 210                                 frame = silence;
 211                                 silencelen -= res;
 212                         } else {
 213                                 if (sounds[cursound].repeat) {
 214                                         /* Start over */
 215                                         sampsent = 0;
 216                                         offset = 0;
 217                                 } else {
 218                                         cursound = -1;
 219                                         nosound = 0;
 220                                 }
 221                         }
 222                 }
 223                 if (frame)
 224                         res = write(sounddev, frame, res * 2);
 225                 if (res > 0)
 226                         return 0;
 227                 return res;
 228         }
 229         return 0;
 230 }
 231
 232 static void *sound_thread(void *unused)
 233 {
 234         fd_set rfds;
 235         fd_set wfds;
 236         int max;
 237         int res;
 238         char ign[4096];
 239         if (read(sounddev, ign, sizeof(sounddev)) < 0)
 240                 ast_log(LOG_WARNING, "Read error on sound device: %s\n", strerror(errno));
 241         for(;;) {
 242                 FD_ZERO(&rfds);
 243                 FD_ZERO(&wfds);
 244                 max = sndcmd[0];
 245                 FD_SET(sndcmd[0], &rfds);
 246                 if (!oss.owner) {
 247                         FD_SET(sounddev, &rfds);
 248                         if (sounddev > max)
 249                                 max = sounddev;
 250                 }
 251                 if (cursound > -1) {
 252                         FD_SET(sounddev, &wfds);
 253                         if (sounddev > max)
 254                                 max = sounddev;
 255                 }
 256                 res = ast_select(max + 1, &rfds, &wfds, NULL, NULL);
 257                 if (res < 1) {
 258                         ast_log(LOG_WARNING, "select failed: %s\n", strerror(errno));
 259                         continue;
 260                 }
 261                 if (FD_ISSET(sndcmd[0], &rfds)) {
 262                         read(sndcmd[0], &cursound, sizeof(cursound));
 263                         silencelen = 0;
 264                         offset = 0;
 265                         sampsent = 0;
 266                 }
 267                 if (FD_ISSET(sounddev, &rfds)) {
 268                         /* Ignore read */
 269                         if (read(sounddev, ign, sizeof(ign)) < 0)
 270                                 ast_log(LOG_WARNING, "Read error on sound device: %s\n", strerror(errno));
 271                 }
 272                 if (FD_ISSET(sounddev, &wfds))
 273                         if (send_sound())
 274                                 ast_log(LOG_WARNING, "Failed to write sound\n");
 275         }
 276         /* Never reached */
 277         return NULL;
 278 }
 279
 280 #if 0
 281 static int silence_suppress(short *buf)
 282 {
 283 #define SILBUF 3
 284         int loudness;
 285         static int silentframes = 0;
 286         static char silbuf[FRAME_SIZE * 2 * SILBUF];
 287         static int silbufcnt=0;
 288         if (!silencesuppression)
 289                 return 0;
 290         loudness = calc_loudness((short *)(buf));
 291         if (option_debug)
 292                 ast_log(LOG_DEBUG, "loudness is %d\n", loudness);
 293         if (loudness < silencethreshold) {
 294                 silentframes++;
 295                 silbufcnt++;
 296                 /* Keep track of the last few bits of silence so we can play
 297                    them as lead-in when the time is right */
 298                 if (silbufcnt >= SILBUF) {
 299                         /* Make way for more buffer */
 300                         memmove(silbuf, silbuf + FRAME_SIZE * 2, FRAME_SIZE * 2 * (SILBUF - 1));
 301                         silbufcnt--;
 302                 }
 303                 memcpy(silbuf + FRAME_SIZE * 2 * silbufcnt, buf, FRAME_SIZE * 2);
 304                 if (silentframes > 10) {
 305                         /* We've had plenty of silence, so compress it now */
 306                         return 1;
 307                 }
 308         } else {
 309                 silentframes=0;
 310                 /* Write any buffered silence we have, it may have something
 311                    important */
 312                 if (silbufcnt) {
 313                         write(sounddev, silbuf, silbufcnt * FRAME_SIZE);
 314                         silbufcnt = 0;
 315                 }
 316         }
 317         return 0;
 318 }
 319 #endif
 320
 321 static int setformat(void)
 322 {
 323         int fmt, desired, res, fd = sounddev;
 324         static int warnedalready = 0;
 325         static int warnedalready2 = 0;
 326         fmt = AFMT_S16_LE;
 327         res = ioctl(fd, SNDCTL_DSP_SETFMT, &fmt);
 328         if (res < 0) {
 329                 ast_log(LOG_WARNING, "Unable to set format to 16-bit signed\n");
 330                 return -1;
 331         }
 332         res = ioctl(fd, SNDCTL_DSP_SETDUPLEX, 0);
 333
 334         /* Check to see if duplex set (FreeBSD Bug)*/
 335         res = ioctl(fd, SNDCTL_DSP_GETCAPS, &fmt);
 336
 337         if ((fmt & DSP_CAP_DUPLEX) && !res) {
 338                 if (option_verbose > 1)
 339                         ast_verbose(VERBOSE_PREFIX_2 "Console is full duplex\n");
 340                 full_duplex = -1;
 341         }
 342         fmt = 0;
 343         res = ioctl(fd, SNDCTL_DSP_STEREO, &fmt);
 344         if (res < 0) {
 345                 ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
 346                 return -1;
 347         }
 348         /* 8000 Hz desired */
 349         desired = 8000;
 350         fmt = desired;
 351         res = ioctl(fd, SNDCTL_DSP_SPEED, &fmt);
 352         if (res < 0) {
 353                 ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
 354                 return -1;
 355         }
 356         if (fmt != desired) {
 357                 if (!warnedalready++)
 358                         ast_log(LOG_WARNING, "Requested %d Hz, got %d Hz -- sound may be choppy\n", desired, fmt);
 359         }
 360 #if 1
 361         fmt = BUFFER_FMT;
 362         res = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &fmt);
 363         if (res < 0) {
 364                 if (!warnedalready2++)
 365                         ast_log(LOG_WARNING, "Unable to set fragment size -- sound may be choppy\n");
 366         }
 367 #endif
 368         return 0;
 369 }
 370
 371 static int soundcard_setoutput(int force)
 372 {
 373         /* Make sure the soundcard is in output mode.  */
 374         int fd = sounddev;
 375         if (full_duplex || (!readmode && !force))
 376                 return 0;
 377         readmode = 0;
 378         if (force || time_has_passed()) {
 379                 ioctl(sounddev, SNDCTL_DSP_RESET, 0);
 380                 /* Keep the same fd reserved by closing the sound device and copying stdin at the same
 381                    time. */
 382                 /* dup2(0, sound); */
 383                 close(sounddev);
 384                 fd = open(DEV_DSP, O_WRONLY |O_NONBLOCK);
 385                 if (fd < 0) {
 386                         ast_log(LOG_WARNING, "Unable to re-open DSP device: %s\n", strerror(errno));
 387                         return -1;
 388                 }
 389                 /* dup2 will close the original and make fd be sound */
 390                 if (dup2(fd, sounddev) < 0) {
 391                         ast_log(LOG_WARNING, "dup2() failed: %s\n", strerror(errno));
 392                         return -1;
 393                 }
 394                 if (setformat()) {
 395                         return -1;
 396                 }
 397                 return 0;
 398         }
 399         return 1;
 400 }
 401
 402 static int soundcard_setinput(int force)
 403 {
 404         int fd = sounddev;
 405         if (full_duplex || (readmode && !force))
 406                 return 0;
 407         readmode = -1;
 408         if (force || time_has_passed()) {
 409                 ioctl(sounddev, SNDCTL_DSP_RESET, 0);
 410                 close(sounddev);
 411                 /* dup2(0, sound); */
 412                 fd = open(DEV_DSP, O_RDONLY | O_NONBLOCK);
 413                 if (fd < 0) {
 414                         ast_log(LOG_WARNING, "Unable to re-open DSP device: %s\n", strerror(errno));
 415                         return -1;
 416                 }
 417                 /* dup2 will close the original and make fd be sound */
 418                 if (dup2(fd, sounddev) < 0) {
 419                         ast_log(LOG_WARNING, "dup2() failed: %s\n", strerror(errno));
 420                         return -1;
 421                 }
 422                 if (setformat()) {
 423                         return -1;
 424                 }
 425                 return 0;
 426         }
 427         return 1;
 428 }
 429
 430 static int soundcard_init(void)
 431 {
 432         /* Assume it's full duplex for starters */
 433         int fd = open(DEV_DSP,  O_RDWR | O_NONBLOCK);
 434         if (fd < 0) {
 435                 ast_log(LOG_WARNING, "Unable to open %s: %s\n", DEV_DSP, strerror(errno));
 436                 return fd;
 437         }
 438         gettimeofday(&lasttime, NULL);
 439         sounddev = fd;
 440         setformat();
 441         if (!full_duplex)
 442                 soundcard_setinput(1);
 443         return sounddev;
 444 }
 445
 446 static int oss_digit(struct ast_channel *c, char digit)
 447 {
 448         ast_verbose( " << Console Received digit %c >> \n", digit);
 449         return 0;
 450 }
 451
 452 static int oss_text(struct ast_channel *c, char *text)
 453 {
 454         ast_verbose( " << Console Received text %s >> \n", text);
 455         return 0;
 456 }
 457
 458 static int oss_call(struct ast_channel *c, char *dest, int timeout)
 459 {
 460         int res = 3;
 461         struct ast_frame f = { 0, };
 462         ast_verbose( " << Call placed to '%s' on console >> \n", dest);
 463         if (autoanswer) {
 464                 ast_verbose( " << Auto-answered >> \n" );
 465                 f.frametype = AST_FRAME_CONTROL;
 466                 f.subclass = AST_CONTROL_ANSWER;
 467                 ast_queue_frame(c, &f);
 468         } else {
 469                 nosound = 1;
 470                 ast_verbose( " << Type 'answer' to answer, or use 'autoanswer' for future calls >> \n");
 471                 f.frametype = AST_FRAME_CONTROL;
 472                 f.subclass = AST_CONTROL_RINGING;
 473                 ast_queue_frame(c, &f);
 474                 write(sndcmd[1], &res, sizeof(res));
 475         }
 476         return 0;
 477 }
 478
 479 static void answer_sound(void)
 480 {
 481         int res;
 482         nosound = 1;
 483         res = 4;
 484         write(sndcmd[1], &res, sizeof(res));
 485
 486 }
 487
 488 static int oss_answer(struct ast_channel *c)
 489 {
 490         ast_verbose( " << Console call has been answered >> \n");
 491         answer_sound();
 492         ast_setstate(c, AST_STATE_UP);
 493         cursound = -1;
 494         nosound=0;
 495         return 0;
 496 }
 497
 498 static int oss_hangup(struct ast_channel *c)
 499 {
 500         int res = 0;
 501         cursound = -1;
 502         c->pvt->pvt = NULL;
 503         oss.owner = NULL;
 504         ast_verbose( " << Hangup on console >> \n");
 505         ast_mutex_lock(&usecnt_lock);
 506         usecnt--;
 507         ast_mutex_unlock(&usecnt_lock);
 508         if (hookstate) {
 509                 if (autoanswer) {
 510                         /* Assume auto-hangup too */
 511                         hookstate = 0;
 512                 } else {
 513                         /* Make congestion noise */
 514                         res = 2;
 515                         write(sndcmd[1], &res, sizeof(res));
 516                 }
 517         }
 518         return 0;
 519 }
 520
 521 static int soundcard_writeframe(short *data)
 522 {
 523         /* Write an exactly FRAME_SIZE sized of frame */
 524         static int bufcnt = 0;
 525         static short buffer[FRAME_SIZE * MAX_BUFFER_SIZE * 5];
 526         struct audio_buf_info info;
 527         int res;
 528         int fd = sounddev;
 529         static int warned=0;
 530         if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info)) {
 531                 if (!warned)
 532                         ast_log(LOG_WARNING, "Error reading output space\n");
 533                 bufcnt = buffersize;
 534                 warned++;
 535         }
 536         if ((info.fragments >= buffersize * 5) && (bufcnt == buffersize)) {
 537                 /* We've run out of stuff, buffer again */
 538                 bufcnt = 0;
 539         }
 540         if (bufcnt == buffersize) {
 541                 /* Write sample immediately */
 542                 res = write(fd, ((void *)data), FRAME_SIZE * 2);
 543         } else {
 544                 /* Copy the data into our buffer */
 545                 res = FRAME_SIZE * 2;
 546                 memcpy(buffer + (bufcnt * FRAME_SIZE), data, FRAME_SIZE * 2);
 547                 bufcnt++;
 548                 if (bufcnt == buffersize) {
 549                         res = write(fd, ((void *)buffer), FRAME_SIZE * 2 * buffersize);
 550                 }
 551         }
 552         return res;
 553 }
 554
 555
 556 static int oss_write(struct ast_channel *chan, struct ast_frame *f)
 557 {
 558         int res;
 559         static char sizbuf[8000];
 560         static int sizpos = 0;
 561         int len = sizpos;
 562         int pos;
 563         /* Immediately return if no sound is enabled */
 564         if (nosound)
 565                 return 0;
 566         /* Stop any currently playing sound */
 567         cursound = -1;
 568         if (!full_duplex) {
 569                 /* If we're half duplex, we have to switch to read mode
 570                    to honor immediate needs if necessary */
 571                 res = soundcard_setinput(1);
 572                 if (res < 0) {
 573                         ast_log(LOG_WARNING, "Unable to set device to input mode\n");
 574                         return -1;
 575                 }
 576                 return 0;
 577         }
 578         res = soundcard_setoutput(0);
 579         if (res < 0) {
 580                 ast_log(LOG_WARNING, "Unable to set output device\n");
 581                 return -1;
 582         } else if (res > 0) {
 583                 /* The device is still in read mode, and it's too soon to change it,
 584                    so just pretend we wrote it */
 585                 return 0;
 586         }
 587         /* We have to digest the frame in 160-byte portions */
 588         if (f->datalen > sizeof(sizbuf) - sizpos) {
 589                 ast_log(LOG_WARNING, "Frame too large\n");
 590                 return -1;
 591         }
 592         memcpy(sizbuf + sizpos, f->data, f->datalen);
 593         len += f->datalen;
 594         pos = 0;
 595         while(len - pos > FRAME_SIZE * 2) {
 596                 soundcard_writeframe((short *)(sizbuf + pos));
 597                 pos += FRAME_SIZE * 2;
 598         }
 599         if (len - pos)
 600                 memmove(sizbuf, sizbuf + pos, len - pos);
 601         sizpos = len - pos;
 602         return 0;
 603 }
 604
 605 static struct ast_frame *oss_read(struct ast_channel *chan)
 606 {
 607         static struct ast_frame f;
 608         static char buf[FRAME_SIZE * 2 + AST_FRIENDLY_OFFSET];
 609         static int readpos = 0;
 610         int res;
 611
 612 #if 0
 613         ast_log(LOG_DEBUG, "oss_read()\n");
 614 #endif
 615
 616         f.frametype = AST_FRAME_NULL;
 617         f.subclass = 0;
 618         f.samples = 0;
 619         f.datalen = 0;
 620         f.data = NULL;
 621         f.offset = 0;
 622         f.src = type;
 623         f.mallocd = 0;
 624         f.delivery.tv_sec = 0;
 625         f.delivery.tv_usec = 0;
 626
 627         res = soundcard_setinput(0);
 628         if (res < 0) {
 629                 ast_log(LOG_WARNING, "Unable to set input mode\n");
 630                 return NULL;
 631         }
 632         if (res > 0) {
 633                 /* Theoretically shouldn't happen, but anyway, return a NULL frame */
 634                 return &f;
 635         }
 636         res = read(sounddev, buf + AST_FRIENDLY_OFFSET + readpos, FRAME_SIZE * 2 - readpos);
 637         if (res < 0) {
 638                 ast_log(LOG_WARNING, "Error reading from sound device (If you're running 'artsd' then kill it): %s\n", strerror(errno));
 639 #if 0
 640                 CRASH;
 641 #endif
 642                 return NULL;
 643         }
 644         readpos += res;
 645
 646         if (readpos >= FRAME_SIZE * 2) {
 647                 /* A real frame */
 648                 readpos = 0;
 649                 if (chan->_state != AST_STATE_UP) {
 650                         /* Don't transmit unless it's up */
 651                         return &f;
 652                 }
 653                 f.frametype = AST_FRAME_VOICE;
 654                 f.subclass = AST_FORMAT_SLINEAR;
 655                 f.samples = FRAME_SIZE;
 656                 f.datalen = FRAME_SIZE * 2;
 657                 f.data = buf + AST_FRIENDLY_OFFSET;
 658                 f.offset = AST_FRIENDLY_OFFSET;
 659                 f.src = type;
 660                 f.mallocd = 0;
 661                 f.delivery.tv_sec = 0;
 662                 f.delivery.tv_usec = 0;
 663 #if 0
 664                 { static int fd = -1;
 665                   if (fd < 0)
 666                         fd = open("output.raw", O_RDWR | O_TRUNC | O_CREAT);
 667                   write(fd, f.data, f.datalen);
 668                 }
 669 #endif
 670         }
 671         return &f;
 672 }
 673
 674 static int oss_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
 675 {
 676         struct chan_oss_pvt *p = newchan->pvt->pvt;
 677         p->owner = newchan;
 678         return 0;
 679 }
 680
 681 static int oss_indicate(struct ast_channel *chan, int cond)
 682 {
 683         int res;
 684         switch(cond) {
 685         case AST_CONTROL_BUSY:
 686                 res = 1;
 687                 break;
 688         case AST_CONTROL_CONGESTION:
 689                 res = 2;
 690                 break;
 691         case AST_CONTROL_RINGING:
 692                 res = 0;
 693                 break;
 694         case -1:
 695                 cursound = -1;
 696                 return 0;
 697         default:
 698                 ast_log(LOG_WARNING, "Don't know how to display condition %d on %s\n", cond, chan->name);
 699                 return -1;
 700         }
 701         if (res > -1) {
 702                 write(sndcmd[1], &res, sizeof(res));
 703         }
 704         return 0;
 705 }
 706
 707 static struct ast_channel *oss_new(struct chan_oss_pvt *p, int state)
 708 {
 709         struct ast_channel *tmp;
 710         tmp = ast_channel_alloc(1);
 711         if (tmp) {
 712                 snprintf(tmp->name, sizeof(tmp->name), "OSS/%s", DEV_DSP + 5);
 713                 tmp->type = type;
 714                 tmp->fds[0] = sounddev;
 715                 tmp->nativeformats = AST_FORMAT_SLINEAR;
 716                 tmp->readformat = AST_FORMAT_SLINEAR;
 717                 tmp->writeformat = AST_FORMAT_SLINEAR;
 718                 tmp->pvt->pvt = p;
 719                 tmp->pvt->send_digit = oss_digit;
 720                 tmp->pvt->send_text = oss_text;
 721                 tmp->pvt->hangup = oss_hangup;
 722                 tmp->pvt->answer = oss_answer;
 723                 tmp->pvt->read = oss_read;
 724                 tmp->pvt->call = oss_call;
 725                 tmp->pvt->write = oss_write;
 726                 tmp->pvt->indicate = oss_indicate;
 727                 tmp->pvt->fixup = oss_fixup;
 728                 if (strlen(p->context))
 729                         strncpy(tmp->context, p->context, sizeof(tmp->context)-1);
 730                 if (strlen(p->exten))
 731                         strncpy(tmp->exten, p->exten, sizeof(tmp->exten)-1);
 732                 if (strlen(language))
 733                         strncpy(tmp->language, language, sizeof(tmp->language)-1);
 734                 p->owner = tmp;
 735                 ast_setstate(tmp, state);
 736                 ast_mutex_lock(&usecnt_lock);
 737                 usecnt++;
 738                 ast_mutex_unlock(&usecnt_lock);
 739                 ast_update_use_count();
 740                 if (state != AST_STATE_DOWN) {
 741                         if (ast_pbx_start(tmp)) {
 742                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
 743                                 ast_hangup(tmp);
 744                                 tmp = NULL;
 745                         }
 746                 }
 747         }
 748         return tmp;
 749 }
 750
 751 static struct ast_channel *oss_request(const char *type, int format, void *data, int *cause)
 752 {
 753         int oldformat = format;
 754         struct ast_channel *tmp;
 755         format &= AST_FORMAT_SLINEAR;
 756         if (!format) {
 757                 ast_log(LOG_NOTICE, "Asked to get a channel of format '%d'\n", oldformat);
 758                 return NULL;
 759         }
 760         if (oss.owner) {
 761                 ast_log(LOG_NOTICE, "Already have a call on the OSS channel\n");
 762                 *cause = AST_CAUSE_BUSY;
 763                 return NULL;
 764         }
 765         tmp= oss_new(&oss, AST_STATE_DOWN);
 766         if (!tmp) {
 767                 ast_log(LOG_WARNING, "Unable to create new OSS channel\n");
 768         }
 769         return tmp;
 770 }
 771
 772 static int console_autoanswer(int fd, int argc, char *argv[])
 773 {
 774         if ((argc != 1) && (argc != 2))
 775                 return RESULT_SHOWUSAGE;
 776         if (argc == 1) {
 777                 ast_cli(fd, "Auto answer is %s.\n", autoanswer ? "on" : "off");
 778                 return RESULT_SUCCESS;
 779         } else {
 780                 if (!strcasecmp(argv[1], "on"))
 781                         autoanswer = -1;
 782                 else if (!strcasecmp(argv[1], "off"))
 783                         autoanswer = 0;
 784                 else
 785                         return RESULT_SHOWUSAGE;
 786         }
 787         return RESULT_SUCCESS;
 788 }
 789
 790 static char *autoanswer_complete(char *line, char *word, int pos, int state)
 791 {
 792 #ifndef MIN
 793 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 794 #endif
 795         switch(state) {
 796         case 0:
 797                 if (strlen(word) && !strncasecmp(word, "on", MIN(strlen(word), 2)))
 798                         return strdup("on");
 799         case 1:
 800                 if (strlen(word) && !strncasecmp(word, "off", MIN(strlen(word), 3)))
 801                         return strdup("off");
 802         default:
 803                 return NULL;
 804         }
 805         return NULL;
 806 }
 807
 808 static char autoanswer_usage[] =
 809 "Usage: autoanswer [on|off]\n"
 810 "       Enables or disables autoanswer feature.  If used without\n"
 811 "       argument, displays the current on/off status of autoanswer.\n"
 812 "       The default value of autoanswer is in 'oss.conf'.\n";
 813
 814 static int console_answer(int fd, int argc, char *argv[])
 815 {
 816         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
 817         if (argc != 1)
 818                 return RESULT_SHOWUSAGE;
 819         if (!oss.owner) {
 820                 ast_cli(fd, "No one is calling us\n");
 821                 return RESULT_FAILURE;
 822         }
 823         hookstate = 1;
 824         cursound = -1;
 825         ast_queue_frame(oss.owner, &f);
 826         answer_sound();
 827         return RESULT_SUCCESS;
 828 }
 829
 830 static char sendtext_usage[] =
 831 "Usage: send text <message>\n"
 832 "       Sends a text message for display on the remote terminal.\n";
 833
 834 static int console_sendtext(int fd, int argc, char *argv[])
 835 {
 836         int tmparg = 2;
 837         char text2send[256] = "";
 838         struct ast_frame f = { 0, };
 839         if (argc < 2)
 840                 return RESULT_SHOWUSAGE;
 841         if (!oss.owner) {
 842                 ast_cli(fd, "No one is calling us\n");
 843                 return RESULT_FAILURE;
 844         }
 845         if (strlen(text2send))
 846                 ast_cli(fd, "Warning: message already waiting to be sent, overwriting\n");
 847         text2send[0] = '\0';
 848         while(tmparg < argc) {
 849                 strncat(text2send, argv[tmparg++], sizeof(text2send) - strlen(text2send) - 1);
 850                 strncat(text2send, " ", sizeof(text2send) - strlen(text2send) - 1);
 851         }
 852         if (strlen(text2send)) {
 853                 f.frametype = AST_FRAME_TEXT;
 854                 f.subclass = 0;
 855                 f.data = text2send;
 856                 f.datalen = strlen(text2send);
 857                 ast_queue_frame(oss.owner, &f);
 858         }
 859         return RESULT_SUCCESS;
 860 }
 861
 862 static char answer_usage[] =
 863 "Usage: answer\n"
 864 "       Answers an incoming call on the console (OSS) channel.\n";
 865
 866 static int console_hangup(int fd, int argc, char *argv[])
 867 {
 868         if (argc != 1)
 869                 return RESULT_SHOWUSAGE;
 870         cursound = -1;
 871         if (!oss.owner && !hookstate) {
 872                 ast_cli(fd, "No call to hangup up\n");
 873                 return RESULT_FAILURE;
 874         }
 875         hookstate = 0;
 876         if (oss.owner) {
 877                 ast_queue_hangup(oss.owner);
 878         }
 879         return RESULT_SUCCESS;
 880 }
 881
 882 static int console_flash(int fd, int argc, char *argv[])
 883 {
 884         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_FLASH };
 885         if (argc != 1)
 886                 return RESULT_SHOWUSAGE;
 887         cursound = -1;
 888         if (!oss.owner) {
 889                 ast_cli(fd, "No call to flash\n");
 890                 return RESULT_FAILURE;
 891         }
 892         hookstate = 0;
 893         if (oss.owner) {
 894                 ast_queue_frame(oss.owner, &f);
 895         }
 896         return RESULT_SUCCESS;
 897 }
 898
 899 static char hangup_usage[] =
 900 "Usage: hangup\n"
 901 "       Hangs up any call currently placed on the console.\n";
 902
 903
 904 static char flash_usage[] =
 905 "Usage: flash\n"
 906 "       Flashes the call currently placed on the console.\n";
 907
 908 static int console_dial(int fd, int argc, char *argv[])
 909 {
 910         char tmp[256], *tmp2;
 911         char *mye, *myc;
 912         int x;
 913         struct ast_frame f = { AST_FRAME_DTMF, 0 };
 914         if ((argc != 1) && (argc != 2))
 915                 return RESULT_SHOWUSAGE;
 916         if (oss.owner) {
 917                 if (argc == 2) {
 918                         for (x=0;x<strlen(argv[1]);x++) {
 919                                 f.subclass = argv[1][x];
 920                                 ast_queue_frame(oss.owner, &f);
 921                         }
 922                 } else {
 923                         ast_cli(fd, "You're already in a call.  You can use this only to dial digits until you hangup\n");
 924                         return RESULT_FAILURE;
 925                 }
 926                 return RESULT_SUCCESS;
 927         }
 928         mye = exten;
 929         myc = context;
 930         if (argc == 2) {
 931                 char *stringp=NULL;
 932                 strncpy(tmp, argv[1], sizeof(tmp)-1);
 933                 stringp=tmp;
 934                 strsep(&stringp, "@");
 935                 tmp2 = strsep(&stringp, "@");
 936                 if (strlen(tmp))
 937                         mye = tmp;
 938                 if (tmp2 && strlen(tmp2))
 939                         myc = tmp2;
 940         }
 941         if (ast_exists_extension(NULL, myc, mye, 1, NULL)) {
 942                 strncpy(oss.exten, mye, sizeof(oss.exten)-1);
 943                 strncpy(oss.context, myc, sizeof(oss.context)-1);
 944                 hookstate = 1;
 945                 oss_new(&oss, AST_STATE_RINGING);
 946         } else
 947                 ast_cli(fd, "No such extension '%s' in context '%s'\n", mye, myc);
 948         return RESULT_SUCCESS;
 949 }
 950
 951 static char dial_usage[] =
 952 "Usage: dial [extension[@context]]\n"
 953 "       Dials a given extensison (and context if specified)\n";
 954
 955 static int console_transfer(int fd, int argc, char *argv[])
 956 {
 957         char tmp[256];
 958         char *context;
 959         if (argc != 2)
 960                 return RESULT_SHOWUSAGE;
 961         if (oss.owner && ast_bridged_channel(oss.owner)) {
 962                 strncpy(tmp, argv[1], sizeof(tmp) - 1);
 963                 context = strchr(tmp, '@');
 964                 if (context) {
 965                         *context = '\0';
 966                         context++;
 967                 } else
 968                         context = oss.owner->context;
 969                 if (ast_exists_extension(ast_bridged_channel(oss.owner), context, tmp, 1, ast_bridged_channel(oss.owner)->cid.cid_num)) {
 970                         ast_cli(fd, "Whee, transferring %s to %s@%s.\n",
 971                                         ast_bridged_channel(oss.owner)->name, tmp, context);
 972                         if (ast_async_goto(ast_bridged_channel(oss.owner), context, tmp, 1))
 973                                 ast_cli(fd, "Failed to transfer :(\n");
 974                 } else {
 975                         ast_cli(fd, "No such extension exists\n");
 976                 }
 977         } else {
 978                 ast_cli(fd, "There is no call to transfer\n");
 979         }
 980         return RESULT_SUCCESS;
 981 }
 982
 983 static char transfer_usage[] =
 984 "Usage: transfer <extension>[@context]\n"
 985 "       Transfers the currently connected call to the given extension (and\n"
 986 "context if specified)\n";
 987
 988 static struct ast_cli_entry myclis[] = {
 989         { { "answer", NULL }, console_answer, "Answer an incoming console call", answer_usage },
 990         { { "hangup", NULL }, console_hangup, "Hangup a call on the console", hangup_usage },
 991         { { "flash", NULL }, console_flash, "Flash a call on the console", flash_usage },
 992         { { "dial", NULL }, console_dial, "Dial an extension on the console", dial_usage },
 993         { { "transfer", NULL }, console_transfer, "Transfer a call to a different extension", transfer_usage },
 994         { { "send", "text", NULL }, console_sendtext, "Send text to the remote device", sendtext_usage },
 995         { { "autoanswer", NULL }, console_autoanswer, "Sets/displays autoanswer", autoanswer_usage, autoanswer_complete }
 996 };
 997
 998 int load_module()
 999 {
1000         int res;
1001         int x;
1002         struct ast_config *cfg;
1003         struct ast_variable *v;
1004         res = pipe(sndcmd);
1005         if (res) {
1006                 ast_log(LOG_ERROR, "Unable to create pipe\n");
1007                 return -1;
1008         }
1009         res = soundcard_init();
1010         if (res < 0) {
1011                 if (option_verbose > 1) {
1012                         ast_verbose(VERBOSE_PREFIX_2 "No sound card detected -- console channel will be unavailable\n");
1013                         ast_verbose(VERBOSE_PREFIX_2 "Turn off OSS support by adding 'noload=chan_oss.so' in /etc/asterisk/modules.conf\n");
1014                 }
1015                 return 0;
1016         }
1017         if (!full_duplex)
1018                 ast_log(LOG_WARNING, "XXX I don't work right with non-full duplex sound cards XXX\n");
1019         res = ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR, oss_request);
1020         if (res < 0) {
1021                 ast_log(LOG_ERROR, "Unable to register channel class '%s'\n", type);
1022                 return -1;
1023         }
1024         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
1025                 ast_cli_register(myclis + x);
1026         if ((cfg = ast_load(config))) {
1027                 v = ast_variable_browse(cfg, "general");
1028                 while(v) {
1029                         if (!strcasecmp(v->name, "autoanswer"))
1030                                 autoanswer = ast_true(v->value);
1031                         else if (!strcasecmp(v->name, "silencesuppression"))
1032                                 silencesuppression = ast_true(v->value);
1033                         else if (!strcasecmp(v->name, "silencethreshold"))
1034                                 silencethreshold = atoi(v->value);
1035                         else if (!strcasecmp(v->name, "context"))
1036                                 strncpy(context, v->value, sizeof(context)-1);
1037                         else if (!strcasecmp(v->name, "language"))
1038                                 strncpy(language, v->value, sizeof(language)-1);
1039                         else if (!strcasecmp(v->name, "extension"))
1040                                 strncpy(exten, v->value, sizeof(exten)-1);
1041                         v=v->next;
1042                 }
1043                 ast_destroy(cfg);
1044         }
1045         ast_pthread_create(&sthread, NULL, sound_thread, NULL);
1046         return 0;
1047 }
1048
1049
1050
1051 int unload_module()
1052 {
1053         int x;
1054         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
1055                 ast_cli_unregister(myclis + x);
1056         close(sounddev);
1057         if (sndcmd[0] > 0) {
1058                 close(sndcmd[0]);
1059                 close(sndcmd[1]);
1060         }
1061         if (oss.owner)
1062                 ast_softhangup(oss.owner, AST_SOFTHANGUP_APPUNLOAD);
1063         if (oss.owner)
1064                 return -1;
1065         return 0;
1066 }
1067
1068 char *description()
1069 {
1070         return desc;
1071 }
1072
1073 int usecount()
1074 {
1075         int res;
1076         ast_mutex_lock(&usecnt_lock);
1077         res = usecnt;
1078         ast_mutex_unlock(&usecnt_lock);
1079         return res;
1080 }
1081
1082 char *key()
1083 {
1084         return ASTERISK_GPL_KEY;
1085 }