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