make using PRINT_DIR a little easier
[asterisk/asterisk.git] / channels / chan_oss.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2007, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * FreeBSD changes and multiple device support by Luigi Rizzo, 2005.05.25
9  * note-this code best seen with ts=8 (8-spaces tabs) in the editor
10  *
11  * See http://www.asterisk.org for more information about
12  * the Asterisk project. Please do not directly contact
13  * any of the maintainers of this project for assistance;
14  * the project provides a web site, mailing lists and IRC
15  * channels for your use.
16  *
17  * This program is free software, distributed under the terms of
18  * the GNU General Public License Version 2. See the LICENSE file
19  * at the top of the source tree.
20  */
21
22 // #define HAVE_VIDEO_CONSOLE   // uncomment to enable video
23 /*! \file
24  *
25  * \brief Channel driver for OSS sound cards
26  *
27  * \author Mark Spencer <markster@digium.com>
28  * \author Luigi Rizzo
29  *
30  * \par See also
31  * \arg \ref Config_oss
32  *
33  * \ingroup channel_drivers
34  */
35
36 /*** MODULEINFO
37         <depend>ossaudio</depend>
38  ***/
39
40 #include "asterisk.h"
41
42 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
43
44 #include <ctype.h>              /* isalnum() used here */
45 #include <math.h>
46 #include <sys/ioctl.h>          
47
48 #ifdef __linux
49 #include <linux/soundcard.h>
50 #elif defined(__FreeBSD__)
51 #include <sys/soundcard.h>
52 #else
53 #include <soundcard.h>
54 #endif
55
56 #include "asterisk/channel.h"
57 #include "asterisk/file.h"
58 #include "asterisk/callerid.h"
59 #include "asterisk/module.h"
60 #include "asterisk/pbx.h"
61 #include "asterisk/cli.h"
62 #include "asterisk/causes.h"
63 #include "asterisk/musiconhold.h"
64 #include "asterisk/app.h"
65
66 /* ringtones we use */
67 #include "busy.h"
68 #include "ringtone.h"
69 #include "ring10.h"
70 #include "answer.h"
71
72 /*! Global jitterbuffer configuration - by default, jb is disabled */
73 static struct ast_jb_conf default_jbconf =
74 {
75         .flags = 0,
76         .max_size = -1,
77         .resync_threshold = -1,
78         .impl = "",
79 };
80 static struct ast_jb_conf global_jbconf;
81
82 /*
83  * Basic mode of operation:
84  *
85  * we have one keyboard (which receives commands from the keyboard)
86  * and multiple headset's connected to audio cards.
87  * Cards/Headsets are named as the sections of oss.conf.
88  * The section called [general] contains the default parameters.
89  *
90  * At any time, the keyboard is attached to one card, and you
91  * can switch among them using the command 'console foo'
92  * where 'foo' is the name of the card you want.
93  *
94  * oss.conf parameters are
95 START_CONFIG
96
97 [general]
98     ; General config options, with default values shown.
99     ; You should use one section per device, with [general] being used
100     ; for the first device and also as a template for other devices.
101     ;
102     ; All but 'debug' can go also in the device-specific sections.
103     ;
104     ; debug = 0x0               ; misc debug flags, default is 0
105
106     ; Set the device to use for I/O
107     ; device = /dev/dsp
108
109     ; Optional mixer command to run upon startup (e.g. to set
110     ; volume levels, mutes, etc.
111     ; mixer =
112
113     ; Software mic volume booster (or attenuator), useful for sound
114     ; cards or microphones with poor sensitivity. The volume level
115     ; is in dB, ranging from -20.0 to +20.0
116     ; boost = n                 ; mic volume boost in dB
117
118     ; Set the callerid for outgoing calls
119     ; callerid = John Doe <555-1234>
120
121     ; autoanswer = no           ; no autoanswer on call
122     ; autohangup = yes          ; hangup when other party closes
123     ; extension = s             ; default extension to call
124     ; context = default         ; default context for outgoing calls
125     ; language = ""             ; default language
126
127     ; Default Music on Hold class to use when this channel is placed on hold in
128     ; the case that the music class is not set on the channel with
129     ; Set(CHANNEL(musicclass)=whatever) in the dialplan and the peer channel
130     ; putting this one on hold did not suggest a class to use.
131     ;
132     ; mohinterpret=default
133
134     ; If you set overridecontext to 'yes', then the whole dial string
135     ; will be interpreted as an extension, which is extremely useful
136     ; to dial SIP, IAX and other extensions which use the '@' character.
137     ; The default is 'no' just for backward compatibility, but the
138     ; suggestion is to change it.
139     ; overridecontext = no      ; if 'no', the last @ will start the context
140                                 ; if 'yes' the whole string is an extension.
141
142     ; low level device parameters in case you have problems with the
143     ; device driver on your operating system. You should not touch these
144     ; unless you know what you are doing.
145     ; queuesize = 10            ; frames in device driver
146     ; frags = 8                 ; argument to SETFRAGMENT
147
148     ;------------------------------ JITTER BUFFER CONFIGURATION --------------------------
149     ; jbenable = yes              ; Enables the use of a jitterbuffer on the receiving side of an
150                                   ; OSS channel. Defaults to "no". An enabled jitterbuffer will
151                                   ; be used only if the sending side can create and the receiving
152                                   ; side can not accept jitter. The OSS channel can't accept jitter,
153                                   ; thus an enabled jitterbuffer on the receive OSS side will always
154                                   ; be used if the sending side can create jitter.
155
156     ; jbmaxsize = 200             ; Max length of the jitterbuffer in milliseconds.
157
158     ; jbresyncthreshold = 1000    ; Jump in the frame timestamps over which the jitterbuffer is
159                                   ; resynchronized. Useful to improve the quality of the voice, with
160                                   ; big jumps in/broken timestamps, usualy sent from exotic devices
161                                   ; and programs. Defaults to 1000.
162
163     ; jbimpl = fixed              ; Jitterbuffer implementation, used on the receiving side of an OSS
164                                   ; channel. Two implementations are currenlty available - "fixed"
165                                   ; (with size always equals to jbmax-size) and "adaptive" (with
166                                   ; variable size, actually the new jb of IAX2). Defaults to fixed.
167
168     ; jblog = no                  ; Enables jitterbuffer frame logging. Defaults to "no".
169     ;-----------------------------------------------------------------------------------
170
171 [card1]
172     ; device = /dev/dsp1        ; alternate device
173
174 END_CONFIG
175
176 .. and so on for the other cards.
177
178  */
179
180 /*
181  * Helper macros to parse config arguments. They will go in a common
182  * header file if their usage is globally accepted. In the meantime,
183  * we define them here. Typical usage is as below.
184  * Remember to open a block right before M_START (as it declares
185  * some variables) and use the M_* macros WITHOUT A SEMICOLON:
186  *
187  *      {
188  *              M_START(v->name, v->value) 
189  *
190  *              M_BOOL("dothis", x->flag1)
191  *              M_STR("name", x->somestring)
192  *              M_F("bar", some_c_code)
193  *              M_END(some_final_statement)
194  *              ... other code in the block
195  *      }
196  *
197  * XXX NOTE these macros should NOT be replicated in other parts of asterisk. 
198  * Likely we will come up with a better way of doing config file parsing.
199  */
200 #define M_START(var, val) \
201         const char *__s = var; const char *__val = val;
202 #define M_END(x)   x;
203 #define M_F(tag, f)                     if (!strcasecmp((__s), tag)) { f; } else
204 #define M_BOOL(tag, dst)        M_F(tag, (dst) = ast_true(__val) )
205 #define M_UINT(tag, dst)        M_F(tag, (dst) = strtoul(__val, NULL, 0) )
206 #define M_STR(tag, dst)         M_F(tag, ast_copy_string(dst, __val, sizeof(dst)))
207
208 /*
209  * The following parameters are used in the driver:
210  *
211  *  FRAME_SIZE  the size of an audio frame, in samples.
212  *              160 is used almost universally, so you should not change it.
213  *
214  *  FRAGS       the argument for the SETFRAGMENT ioctl.
215  *              Overridden by the 'frags' parameter in oss.conf
216  *
217  *              Bits 0-7 are the base-2 log of the device's block size,
218  *              bits 16-31 are the number of blocks in the driver's queue.
219  *              There are a lot of differences in the way this parameter
220  *              is supported by different drivers, so you may need to
221  *              experiment a bit with the value.
222  *              A good default for linux is 30 blocks of 64 bytes, which
223  *              results in 6 frames of 320 bytes (160 samples).
224  *              FreeBSD works decently with blocks of 256 or 512 bytes,
225  *              leaving the number unspecified.
226  *              Note that this only refers to the device buffer size,
227  *              this module will then try to keep the lenght of audio
228  *              buffered within small constraints.
229  *
230  *  QUEUE_SIZE  The max number of blocks actually allowed in the device
231  *              driver's buffer, irrespective of the available number.
232  *              Overridden by the 'queuesize' parameter in oss.conf
233  *
234  *              Should be >=2, and at most as large as the hw queue above
235  *              (otherwise it will never be full).
236  */
237
238 #define FRAME_SIZE      160
239 #define QUEUE_SIZE      10
240
241 #if defined(__FreeBSD__)
242 #define FRAGS   0x8
243 #else
244 #define FRAGS   ( ( (6 * 5) << 16 ) | 0x6 )
245 #endif
246
247 /*
248  * XXX text message sizes are probably 256 chars, but i am
249  * not sure if there is a suitable definition anywhere.
250  */
251 #define TEXT_SIZE       256
252
253 #if 0
254 #define TRYOPEN 1                               /* try to open on startup */
255 #endif
256 #define O_CLOSE 0x444                   /* special 'close' mode for device */
257 /* Which device to use */
258 #if defined( __OpenBSD__ ) || defined( __NetBSD__ )
259 #define DEV_DSP "/dev/audio"
260 #else
261 #define DEV_DSP "/dev/dsp"
262 #endif
263
264 #ifndef MIN
265 #define MIN(a,b) ((a) < (b) ? (a) : (b))
266 #endif
267 #ifndef MAX
268 #define MAX(a,b) ((a) > (b) ? (a) : (b))
269 #endif
270
271 static char *config = "oss.conf";       /* default config file */
272
273 static int oss_debug;
274
275 /*!
276  * Each sound is made of 'datalen' samples of sound, repeated as needed to
277  * generate 'samplen' samples of data, then followed by 'silencelen' samples
278  * of silence. The loop is repeated if 'repeat' is set.
279  */
280 struct sound {
281         int ind;
282         char *desc;
283         short *data;
284         int datalen;
285         int samplen;
286         int silencelen;
287         int repeat;
288 };
289
290 static struct sound sounds[] = {
291         { AST_CONTROL_RINGING, "RINGING", ringtone, sizeof(ringtone)/2, 16000, 32000, 1 },
292         { AST_CONTROL_BUSY, "BUSY", busy, sizeof(busy)/2, 4000, 4000, 1 },
293         { AST_CONTROL_CONGESTION, "CONGESTION", busy, sizeof(busy)/2, 2000, 2000, 1 },
294         { AST_CONTROL_RING, "RING10", ring10, sizeof(ring10)/2, 16000, 32000, 1 },
295         { AST_CONTROL_ANSWER, "ANSWER", answer, sizeof(answer)/2, 2200, 0, 0 },
296         { -1, NULL, 0, 0, 0, 0 },       /* end marker */
297 };
298
299 struct video_desc;              /* opaque type for video support */
300
301 /*!
302  * \brief descriptor for one of our channels.
303  *
304  * There is one used for 'default' values (from the [general] entry in
305  * the configuration file), and then one instance for each device
306  * (the default is cloned from [general], others are only created
307  * if the relevant section exists).
308  */
309 struct chan_oss_pvt {
310         struct chan_oss_pvt *next;
311
312         char *name;
313         /*!
314          * cursound indicates which in struct sound we play. -1 means nothing,
315          * any other value is a valid sound, in which case sampsent indicates
316          * the next sample to send in [0..samplen + silencelen]
317          * nosound is set to disable the audio data from the channel
318          * (so we can play the tones etc.).
319          */
320         int sndcmd[2];                          /*!< Sound command pipe */
321         int cursound;                           /*!< index of sound to send */
322         int sampsent;                           /*!< # of sound samples sent  */
323         int nosound;                            /*!< set to block audio from the PBX */
324
325         int total_blocks;                       /*!< total blocks in the output device */
326         int sounddev;
327         enum { M_UNSET, M_FULL, M_READ, M_WRITE } duplex;
328         int autoanswer;
329         int autohangup;
330         int hookstate;
331         char *mixer_cmd;                        /*!< initial command to issue to the mixer */
332         unsigned int queuesize;         /*!< max fragments in queue */
333         unsigned int frags;                     /*!< parameter for SETFRAGMENT */
334
335         int warned;                                     /*!< various flags used for warnings */
336 #define WARN_used_blocks        1
337 #define WARN_speed              2
338 #define WARN_frag               4
339         int w_errors;                           /*!< overfull in the write path */
340         struct timeval lastopen;
341
342         int overridecontext;
343         int mute;
344
345         /*! boost support. BOOST_SCALE * 10 ^(BOOST_MAX/20) must
346          *  be representable in 16 bits to avoid overflows.
347          */
348 #define BOOST_SCALE     (1<<9)
349 #define BOOST_MAX       40                      /*!< slightly less than 7 bits */
350         int boost;                                      /*!< input boost, scaled by BOOST_SCALE */
351         char device[64];                        /*!< device to open */
352
353         pthread_t sthread;
354
355         struct ast_channel *owner;
356
357         struct video_desc *env;                 /*!< parameters for video support */
358
359         char ext[AST_MAX_EXTENSION];
360         char ctx[AST_MAX_CONTEXT];
361         char language[MAX_LANGUAGE];
362         char cid_name[256];                     /*XXX */
363         char cid_num[256];                      /*XXX */
364         char mohinterpret[MAX_MUSICCLASS];
365
366         /*! buffers used in oss_write */
367         char oss_write_buf[FRAME_SIZE * 2];
368         int oss_write_dst;
369         /*! buffers used in oss_read - AST_FRIENDLY_OFFSET space for headers
370          *  plus enough room for a full frame
371          */
372         char oss_read_buf[FRAME_SIZE * 2 + AST_FRIENDLY_OFFSET];
373         int readpos;                            /*!< read position above */
374         struct ast_frame read_f;        /*!< returned by oss_read */
375 };
376
377 /*! forward declaration */
378 static struct chan_oss_pvt *find_desc(char *dev);
379
380 /*! \brief return the pointer to the video descriptor */
381 static attribute_unused struct video_desc *get_video_desc(struct ast_channel *c)
382 {
383         struct chan_oss_pvt *o = c->tech_pvt;
384         return o ? o->env : NULL;
385 }
386 static struct chan_oss_pvt oss_default = {
387         .cursound = -1,
388         .sounddev = -1,
389         .duplex = M_UNSET,                      /* XXX check this */
390         .autoanswer = 1,
391         .autohangup = 1,
392         .queuesize = QUEUE_SIZE,
393         .frags = FRAGS,
394         .ext = "s",
395         .ctx = "default",
396         .readpos = AST_FRIENDLY_OFFSET, /* start here on reads */
397         .lastopen = { 0, 0 },
398         .boost = BOOST_SCALE,
399 };
400
401 static char *oss_active;         /*!< the active device */
402
403 static int setformat(struct chan_oss_pvt *o, int mode);
404
405 static struct ast_channel *oss_request(const char *type, int format, void *data
406 , int *cause);
407 static int oss_digit_begin(struct ast_channel *c, char digit);
408 static int oss_digit_end(struct ast_channel *c, char digit, unsigned int duration);
409 static int oss_text(struct ast_channel *c, const char *text);
410 static int oss_hangup(struct ast_channel *c);
411 static int oss_answer(struct ast_channel *c);
412 static struct ast_frame *oss_read(struct ast_channel *chan);
413 static int oss_call(struct ast_channel *c, char *dest, int timeout);
414 static int oss_write(struct ast_channel *chan, struct ast_frame *f);
415 static int oss_indicate(struct ast_channel *chan, int cond, const void *data, size_t datalen);
416 static int oss_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
417 static char tdesc[] = "OSS Console Channel Driver";
418
419 #ifdef HAVE_VIDEO_CONSOLE
420 #include "console_video.c"
421 #else
422 #define CONSOLE_VIDEO_CMDS                                      \
423                 "console {device}"
424 /* provide replacements for some symbols used */
425 #define console_write_video             NULL
426 #define console_video_start(x, y)       {}
427 #define console_video_uninit(x)         {}
428 #define console_video_config(x, y, z)   1       /* pretend nothing recognised */
429 #define console_video_cli(x, y, z)      0       /* pretend nothing recognised */
430 #define CONSOLE_FORMAT_VIDEO            0
431 #endif
432
433 static const struct ast_channel_tech oss_tech = {
434         .type = "Console",
435         .description = tdesc,
436         .capabilities = AST_FORMAT_SLINEAR | CONSOLE_FORMAT_VIDEO,
437         .requester = oss_request,
438         .send_digit_begin = oss_digit_begin,
439         .send_digit_end = oss_digit_end,
440         .send_text = oss_text,
441         .hangup = oss_hangup,
442         .answer = oss_answer,
443         .read = oss_read,
444         .call = oss_call,
445         .write = oss_write,
446         .write_video = console_write_video,
447         .indicate = oss_indicate,
448         .fixup = oss_fixup,
449 };
450
451 /*!
452  * \brief returns a pointer to the descriptor with the given name
453  */
454 static struct chan_oss_pvt *find_desc(char *dev)
455 {
456         struct chan_oss_pvt *o = NULL;
457
458         if (!dev)
459                 ast_log(LOG_WARNING, "null dev\n");
460
461         for (o = oss_default.next; o && o->name && dev && strcmp(o->name, dev) != 0; o = o->next);
462
463         if (!o)
464                 ast_log(LOG_WARNING, "could not find <%s>\n", dev ? dev : "--no-device--");
465
466         return o;
467 }
468
469 /* !
470  * \brief split a string in extension-context, returns pointers to malloc'ed
471  *        strings.
472  *
473  * If we do not have 'overridecontext' then the last @ is considered as
474  * a context separator, and the context is overridden.
475  * This is usually not very necessary as you can play with the dialplan,
476  * and it is nice not to need it because you have '@' in SIP addresses.
477  *
478  * \return the buffer address.
479  */
480 static char *ast_ext_ctx(const char *src, char **ext, char **ctx)
481 {
482         struct chan_oss_pvt *o = find_desc(oss_active);
483
484         if (ext == NULL || ctx == NULL)
485                 return NULL;                    /* error */
486
487         *ext = *ctx = NULL;
488
489         if (src && *src != '\0')
490                 *ext = ast_strdup(src);
491
492         if (*ext == NULL)
493                 return NULL;
494
495         if (!o->overridecontext) {
496                 /* parse from the right */
497                 *ctx = strrchr(*ext, '@');
498                 if (*ctx)
499                         *(*ctx)++ = '\0';
500         }
501
502         return *ext;
503 }
504
505 /*!
506  * \brief Returns the number of blocks used in the audio output channel
507  */
508 static int used_blocks(struct chan_oss_pvt *o)
509 {
510         struct audio_buf_info info;
511
512         if (ioctl(o->sounddev, SNDCTL_DSP_GETOSPACE, &info)) {
513                 if (!(o->warned & WARN_used_blocks)) {
514                         ast_log(LOG_WARNING, "Error reading output space\n");
515                         o->warned |= WARN_used_blocks;
516                 }
517                 return 1;
518         }
519
520         if (o->total_blocks == 0) {
521                 if (0)                                  /* debugging */
522                         ast_log(LOG_WARNING, "fragtotal %d size %d avail %d\n", info.fragstotal, info.fragsize, info.fragments);
523                 o->total_blocks = info.fragments;
524         }
525
526         return o->total_blocks - info.fragments;
527 }
528
529 /*! Write an exactly FRAME_SIZE sized frame */
530 static int soundcard_writeframe(struct chan_oss_pvt *o, short *data)
531 {
532         int res;
533
534         if (o->sounddev < 0)
535                 setformat(o, O_RDWR);
536         if (o->sounddev < 0)
537                 return 0;                               /* not fatal */
538         /*
539          * Nothing complex to manage the audio device queue.
540          * If the buffer is full just drop the extra, otherwise write.
541          * XXX in some cases it might be useful to write anyways after
542          * a number of failures, to restart the output chain.
543          */
544         res = used_blocks(o);
545         if (res > o->queuesize) {       /* no room to write a block */
546                 if (o->w_errors++ == 0 && (oss_debug & 0x4))
547                         ast_log(LOG_WARNING, "write: used %d blocks (%d)\n", res, o->w_errors);
548                 return 0;
549         }
550         o->w_errors = 0;
551         return write(o->sounddev, (void *)data, FRAME_SIZE * 2);
552 }
553
554 /*!
555  * \brief Handler for 'sound writable' events from the sound thread.
556  *
557  * Builds a frame from the high level description of the sounds,
558  * and passes it to the audio device.
559  * The actual sound is made of 1 or more sequences of sound samples
560  * (s->datalen, repeated to make s->samplen samples) followed by
561  * s->silencelen samples of silence. The position in the sequence is stored
562  * in o->sampsent, which goes between 0 .. s->samplen+s->silencelen.
563  * In case we fail to write a frame, don't update o->sampsent.
564  */
565 static void send_sound(struct chan_oss_pvt *o)
566 {
567         short myframe[FRAME_SIZE];
568         int ofs, l, start;
569         int l_sampsent = o->sampsent;
570         struct sound *s;
571
572         if (o->cursound < 0)            /* no sound to send */
573                 return;
574
575         s = &sounds[o->cursound];
576
577         for (ofs = 0; ofs < FRAME_SIZE; ofs += l) {
578                 l = s->samplen - l_sampsent;    /* # of available samples */
579                 if (l > 0) {
580                         start = l_sampsent % s->datalen;        /* source offset */
581                         l = MIN(l, FRAME_SIZE - ofs);   /* don't overflow the frame */
582                         l = MIN(l, s->datalen - start); /* don't overflow the source */
583                         bcopy(s->data + start, myframe + ofs, l * 2);
584                         if (0)
585                                 ast_log(LOG_WARNING, "send_sound sound %d/%d of %d into %d\n", l_sampsent, l, s->samplen, ofs);
586                         l_sampsent += l;
587                 } else {                                /* end of samples, maybe some silence */
588                         static const short silence[FRAME_SIZE] = { 0, };
589
590                         l += s->silencelen;
591                         if (l > 0) {
592                                 l = MIN(l, FRAME_SIZE - ofs);
593                                 bcopy(silence, myframe + ofs, l * 2);
594                                 l_sampsent += l;
595                         } else {                        /* silence is over, restart sound if loop */
596                                 if (s->repeat == 0) {   /* last block */
597                                         o->cursound = -1;
598                                         o->nosound = 0; /* allow audio data */
599                                         if (ofs < FRAME_SIZE)   /* pad with silence */
600                                                 bcopy(silence, myframe + ofs, (FRAME_SIZE - ofs) * 2);
601                                 }
602                                 l_sampsent = 0;
603                         }
604                 }
605         }
606         l = soundcard_writeframe(o, myframe);
607         if (l > 0)
608                 o->sampsent = l_sampsent;       /* update status */
609 }
610
611 static void *sound_thread(void *arg)
612 {
613         char ign[4096];
614         struct chan_oss_pvt *o = (struct chan_oss_pvt *) arg;
615
616         /*
617          * Just in case, kick the driver by trying to read from it.
618          * Ignore errors - this read is almost guaranteed to fail.
619          */
620         read(o->sounddev, ign, sizeof(ign));
621         for (;;) {
622                 fd_set rfds, wfds;
623                 int maxfd, res;
624                 struct timeval *to = NULL, t;
625
626                 FD_ZERO(&rfds);
627                 FD_ZERO(&wfds);
628                 FD_SET(o->sndcmd[0], &rfds);
629                 maxfd = o->sndcmd[0];   /* pipe from the main process */
630                 if (o->cursound > -1 && o->sounddev < 0)
631                         setformat(o, O_RDWR);   /* need the channel, try to reopen */
632                 else if (o->cursound == -1 && o->owner == NULL)
633                         setformat(o, O_CLOSE);  /* can close */
634                 if (o->sounddev > -1) {
635                         if (!o->owner) {        /* no one owns the audio, so we must drain it */
636                                 FD_SET(o->sounddev, &rfds);
637                                 maxfd = MAX(o->sounddev, maxfd);
638                         }
639                         if (o->cursound > -1) {
640                                 /*
641                                  * We would like to use select here, but the device
642                                  * is always writable, so this would become busy wait.
643                                  * So we rather set a timeout to 1/2 of the frame size.
644                                  */
645                                 t.tv_sec = 0;
646                                 t.tv_usec = (1000000 * FRAME_SIZE) / (5 * DEFAULT_SAMPLE_RATE);
647                                 to = &t;
648                         }
649                 }
650                 /* ast_select emulates linux behaviour in terms of timeout handling */
651                 res = ast_select(maxfd + 1, &rfds, &wfds, NULL, to);
652                 if (res < 0) {
653                         ast_log(LOG_WARNING, "select failed: %s\n", strerror(errno));
654                         sleep(1);
655                         continue;
656                 }
657                 if (FD_ISSET(o->sndcmd[0], &rfds)) {
658                         /* read which sound to play from the pipe */
659                         int i, what = -1;
660
661                         read(o->sndcmd[0], &what, sizeof(what));
662                         for (i = 0; sounds[i].ind != -1; i++) {
663                                 if (sounds[i].ind == what) {
664                                         o->cursound = i;
665                                         o->sampsent = 0;
666                                         o->nosound = 1; /* block audio from pbx */
667                                         break;
668                                 }
669                         }
670                         if (sounds[i].ind == -1)
671                                 ast_log(LOG_WARNING, "invalid sound index: %d\n", what);
672                 }
673                 if (o->sounddev > -1) {
674                         if (FD_ISSET(o->sounddev, &rfds))       /* read and ignore errors */
675                                 read(o->sounddev, ign, sizeof(ign));
676                         if (to != NULL)                 /* maybe it is possible to write */
677                                 send_sound(o);
678                 }
679         }
680         return NULL;                            /* Never reached */
681 }
682
683 /*!
684  * reset and close the device if opened,
685  * then open and initialize it in the desired mode,
686  * trigger reads and writes so we can start using it.
687  */
688 static int setformat(struct chan_oss_pvt *o, int mode)
689 {
690         int fmt, desired, res, fd;
691
692         if (o->sounddev >= 0) {
693                 ioctl(o->sounddev, SNDCTL_DSP_RESET, 0);
694                 close(o->sounddev);
695                 o->duplex = M_UNSET;
696                 o->sounddev = -1;
697         }
698         if (mode == O_CLOSE)            /* we are done */
699                 return 0;
700         if (ast_tvdiff_ms(ast_tvnow(), o->lastopen) < 1000)
701                 return -1;                              /* don't open too often */
702         o->lastopen = ast_tvnow();
703         fd = o->sounddev = open(o->device, mode | O_NONBLOCK);
704         if (fd < 0) {
705                 ast_log(LOG_WARNING, "Unable to re-open DSP device %s: %s\n", o->device, strerror(errno));
706                 return -1;
707         }
708         if (o->owner)
709                 ast_channel_set_fd(o->owner, 0, fd);
710
711 #if __BYTE_ORDER == __LITTLE_ENDIAN
712         fmt = AFMT_S16_LE;
713 #else
714         fmt = AFMT_S16_BE;
715 #endif
716         res = ioctl(fd, SNDCTL_DSP_SETFMT, &fmt);
717         if (res < 0) {
718                 ast_log(LOG_WARNING, "Unable to set format to 16-bit signed\n");
719                 return -1;
720         }
721         switch (mode) {
722         case O_RDWR:
723                 res = ioctl(fd, SNDCTL_DSP_SETDUPLEX, 0);
724                 /* Check to see if duplex set (FreeBSD Bug) */
725                 res = ioctl(fd, SNDCTL_DSP_GETCAPS, &fmt);
726                 if (res == 0 && (fmt & DSP_CAP_DUPLEX)) {
727                         ast_verb(2, "Console is full duplex\n");
728                         o->duplex = M_FULL;
729                 };
730                 break;
731
732         case O_WRONLY:
733                 o->duplex = M_WRITE;
734                 break;
735
736         case O_RDONLY:
737                 o->duplex = M_READ;
738                 break;
739         }
740
741         fmt = 0;
742         res = ioctl(fd, SNDCTL_DSP_STEREO, &fmt);
743         if (res < 0) {
744                 ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
745                 return -1;
746         }
747         fmt = desired = DEFAULT_SAMPLE_RATE;    /* 8000 Hz desired */
748         res = ioctl(fd, SNDCTL_DSP_SPEED, &fmt);
749
750         if (res < 0) {
751                 ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
752                 return -1;
753         }
754         if (fmt != desired) {
755                 if (!(o->warned & WARN_speed)) {
756                         ast_log(LOG_WARNING,
757                             "Requested %d Hz, got %d Hz -- sound may be choppy\n",
758                             desired, fmt);
759                         o->warned |= WARN_speed;
760                 }
761         }
762         /*
763          * on Freebsd, SETFRAGMENT does not work very well on some cards.
764          * Default to use 256 bytes, let the user override
765          */
766         if (o->frags) {
767                 fmt = o->frags;
768                 res = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &fmt);
769                 if (res < 0) {
770                         if (!(o->warned & WARN_frag)) {
771                                 ast_log(LOG_WARNING,
772                                         "Unable to set fragment size -- sound may be choppy\n");
773                                 o->warned |= WARN_frag;
774                         }
775                 }
776         }
777         /* on some cards, we need SNDCTL_DSP_SETTRIGGER to start outputting */
778         res = PCM_ENABLE_INPUT | PCM_ENABLE_OUTPUT;
779         res = ioctl(fd, SNDCTL_DSP_SETTRIGGER, &res);
780         /* it may fail if we are in half duplex, never mind */
781         return 0;
782 }
783
784 /*
785  * some of the standard methods supported by channels.
786  */
787 static int oss_digit_begin(struct ast_channel *c, char digit)
788 {
789         return 0;
790 }
791
792 static int oss_digit_end(struct ast_channel *c, char digit, unsigned int duration)
793 {
794         /* no better use for received digits than print them */
795         ast_verbose(" << Console Received digit %c of duration %u ms >> \n", 
796                 digit, duration);
797         return 0;
798 }
799
800 static int oss_text(struct ast_channel *c, const char *text)
801 {
802         /* print received messages */
803         ast_verbose(" << Console Received text %s >> \n", text);
804         return 0;
805 }
806
807 /*! \brief Play ringtone 'x' on device 'o' */
808 static void ring(struct chan_oss_pvt *o, int x)
809 {
810         write(o->sndcmd[1], &x, sizeof(x));
811 }
812
813
814 /*!
815  * \brief handler for incoming calls. Either autoanswer, or start ringing
816  */
817 static int oss_call(struct ast_channel *c, char *dest, int timeout)
818 {
819         struct chan_oss_pvt *o = c->tech_pvt;
820         struct ast_frame f = { 0, };
821         AST_DECLARE_APP_ARGS(args,
822                 AST_APP_ARG(name);
823                 AST_APP_ARG(flags);
824         );
825         char *parse = ast_strdupa(dest);
826
827         AST_NONSTANDARD_APP_ARGS(args, parse, '/');
828
829         ast_verbose(" << Call to device '%s' dnid '%s' rdnis '%s' on console from '%s' <%s> >>\n", dest, c->cid.cid_dnid, c->cid.cid_rdnis, c->cid.cid_name, c->cid.cid_num);
830         if (!ast_strlen_zero(args.flags) && strcasecmp(args.flags, "answer") == 0) {
831                 f.frametype = AST_FRAME_CONTROL;
832                 f.subclass = AST_CONTROL_ANSWER;
833                 ast_queue_frame(c, &f);
834         } else if (!ast_strlen_zero(args.flags) && strcasecmp(args.flags, "noanswer") == 0) {
835                 f.frametype = AST_FRAME_CONTROL;
836                 f.subclass = AST_CONTROL_RINGING;
837                 ast_queue_frame(c, &f);
838                 ring(o, AST_CONTROL_RING);
839         } else if (o->autoanswer) {
840                 ast_verbose(" << Auto-answered >> \n");
841                 f.frametype = AST_FRAME_CONTROL;
842                 f.subclass = AST_CONTROL_ANSWER;
843                 ast_queue_frame(c, &f);
844         } else {
845                 ast_verbose("<< Type 'answer' to answer, or use 'autoanswer' for future calls >> \n");
846                 f.frametype = AST_FRAME_CONTROL;
847                 f.subclass = AST_CONTROL_RINGING;
848                 ast_queue_frame(c, &f);
849                 ring(o, AST_CONTROL_RING);
850         }
851         return 0;
852 }
853
854 /*!
855  * \brief remote side answered the phone
856  */
857 static int oss_answer(struct ast_channel *c)
858 {
859         struct chan_oss_pvt *o = c->tech_pvt;
860
861         ast_verbose(" << Console call has been answered >> \n");
862 #if 0
863         /* play an answer tone (XXX do we really need it ?) */
864         ring(o, AST_CONTROL_ANSWER);
865 #endif
866         ast_setstate(c, AST_STATE_UP);
867         o->cursound = -1;
868         o->nosound = 0;
869         return 0;
870 }
871
872 static int oss_hangup(struct ast_channel *c)
873 {
874         struct chan_oss_pvt *o = c->tech_pvt;
875
876         o->cursound = -1;
877         o->nosound = 0;
878         c->tech_pvt = NULL;
879         o->owner = NULL;
880         ast_verbose(" << Hangup on console >> \n");
881         console_video_uninit(o->env);
882         ast_module_unref(ast_module_info->self);
883         if (o->hookstate) {
884                 if (o->autoanswer || o->autohangup) {
885                         /* Assume auto-hangup too */
886                         o->hookstate = 0;
887                         setformat(o, O_CLOSE);
888                 } else {
889                         /* Make congestion noise */
890                         ring(o, AST_CONTROL_CONGESTION);
891                 }
892         }
893         return 0;
894 }
895
896 /*! \brief used for data coming from the network */
897 static int oss_write(struct ast_channel *c, struct ast_frame *f)
898 {
899         int src;
900         struct chan_oss_pvt *o = c->tech_pvt;
901
902         /* Immediately return if no sound is enabled */
903         if (o->nosound)
904                 return 0;
905         /* Stop any currently playing sound */
906         o->cursound = -1;
907         /*
908          * we could receive a block which is not a multiple of our
909          * FRAME_SIZE, so buffer it locally and write to the device
910          * in FRAME_SIZE chunks.
911          * Keep the residue stored for future use.
912          */
913         src = 0;                                        /* read position into f->data */
914         while (src < f->datalen) {
915                 /* Compute spare room in the buffer */
916                 int l = sizeof(o->oss_write_buf) - o->oss_write_dst;
917
918                 if (f->datalen - src >= l) {    /* enough to fill a frame */
919                         memcpy(o->oss_write_buf + o->oss_write_dst, f->data + src, l);
920                         soundcard_writeframe(o, (short *) o->oss_write_buf);
921                         src += l;
922                         o->oss_write_dst = 0;
923                 } else {                                /* copy residue */
924                         l = f->datalen - src;
925                         memcpy(o->oss_write_buf + o->oss_write_dst, f->data + src, l);
926                         src += l;                       /* but really, we are done */
927                         o->oss_write_dst += l;
928                 }
929         }
930         return 0;
931 }
932
933 static struct ast_frame *oss_read(struct ast_channel *c)
934 {
935         int res;
936         struct chan_oss_pvt *o = c->tech_pvt;
937         struct ast_frame *f = &o->read_f;
938
939         /* XXX can be simplified returning &ast_null_frame */
940         /* prepare a NULL frame in case we don't have enough data to return */
941         bzero(f, sizeof(struct ast_frame));
942         f->frametype = AST_FRAME_NULL;
943         f->src = oss_tech.type;
944
945         res = read(o->sounddev, o->oss_read_buf + o->readpos, sizeof(o->oss_read_buf) - o->readpos);
946         if (res < 0)                            /* audio data not ready, return a NULL frame */
947                 return f;
948
949         o->readpos += res;
950         if (o->readpos < sizeof(o->oss_read_buf))       /* not enough samples */
951                 return f;
952
953         if (o->mute)
954                 return f;
955
956         o->readpos = AST_FRIENDLY_OFFSET;       /* reset read pointer for next frame */
957         if (c->_state != AST_STATE_UP)  /* drop data if frame is not up */
958                 return f;
959         /* ok we can build and deliver the frame to the caller */
960         f->frametype = AST_FRAME_VOICE;
961         f->subclass = AST_FORMAT_SLINEAR;
962         f->samples = FRAME_SIZE;
963         f->datalen = FRAME_SIZE * 2;
964         f->data = o->oss_read_buf + AST_FRIENDLY_OFFSET;
965         if (o->boost != BOOST_SCALE) {  /* scale and clip values */
966                 int i, x;
967                 int16_t *p = (int16_t *) f->data;
968                 for (i = 0; i < f->samples; i++) {
969                         x = (p[i] * o->boost) / BOOST_SCALE;
970                         if (x > 32767)
971                                 x = 32767;
972                         else if (x < -32768)
973                                 x = -32768;
974                         p[i] = x;
975                 }
976         }
977
978         f->offset = AST_FRIENDLY_OFFSET;
979         return f;
980 }
981
982 static int oss_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
983 {
984         struct chan_oss_pvt *o = newchan->tech_pvt;
985         o->owner = newchan;
986         return 0;
987 }
988
989 static int oss_indicate(struct ast_channel *c, int cond, const void *data, size_t datalen)
990 {
991         struct chan_oss_pvt *o = c->tech_pvt;
992         int res = -1;
993
994         switch (cond) {
995         case AST_CONTROL_BUSY:
996         case AST_CONTROL_CONGESTION:
997         case AST_CONTROL_RINGING:
998                 res = cond;
999                 break;
1000
1001         case -1:
1002                 o->cursound = -1;
1003                 o->nosound = 0;         /* when cursound is -1 nosound must be 0 */
1004                 return 0;
1005
1006         case AST_CONTROL_VIDUPDATE:
1007                 res = -1;
1008                 break;
1009
1010         case AST_CONTROL_HOLD:
1011                 ast_verbose(" << Console Has Been Placed on Hold >> \n");
1012                 ast_moh_start(c, data, o->mohinterpret);
1013                 break;
1014
1015         case AST_CONTROL_UNHOLD:
1016                 ast_verbose(" << Console Has Been Retrieved from Hold >> \n");
1017                 ast_moh_stop(c);
1018                 break;
1019
1020         default:
1021                 ast_log(LOG_WARNING, "Don't know how to display condition %d on %s\n", cond, c->name);
1022                 return -1;
1023         }
1024
1025         if (res > -1)
1026                 ring(o, res);
1027
1028         return 0;
1029 }
1030
1031 /*!
1032  * \brief allocate a new channel.
1033  */
1034 static struct ast_channel *oss_new(struct chan_oss_pvt *o, char *ext, char *ctx, int state)
1035 {
1036         struct ast_channel *c;
1037
1038         c = ast_channel_alloc(1, state, o->cid_num, o->cid_name, "", ext, ctx, 0, "OSS/%s", o->device + 5);
1039         if (c == NULL)
1040                 return NULL;
1041         c->tech = &oss_tech;
1042         if (o->sounddev < 0)
1043                 setformat(o, O_RDWR);
1044         ast_channel_set_fd(c, 0, o->sounddev); /* -1 if device closed, override later */
1045         c->nativeformats = AST_FORMAT_SLINEAR;
1046         /* if the console makes the call, add video to the offer */
1047         if (state == AST_STATE_RINGING)
1048                 c->nativeformats |= CONSOLE_FORMAT_VIDEO;
1049
1050         c->readformat = AST_FORMAT_SLINEAR;
1051         c->writeformat = AST_FORMAT_SLINEAR;
1052         c->tech_pvt = o;
1053
1054         if (!ast_strlen_zero(o->language))
1055                 ast_string_field_set(c, language, o->language);
1056         /* Don't use ast_set_callerid() here because it will
1057          * generate a needless NewCallerID event */
1058         c->cid.cid_ani = ast_strdup(o->cid_num);
1059         if (!ast_strlen_zero(ext))
1060                 c->cid.cid_dnid = ast_strdup(ext);
1061
1062         o->owner = c;
1063         ast_module_ref(ast_module_info->self);
1064         ast_jb_configure(c, &global_jbconf);
1065         if (state != AST_STATE_DOWN) {
1066                 if (ast_pbx_start(c)) {
1067                         ast_log(LOG_WARNING, "Unable to start PBX on %s\n", c->name);
1068                         ast_hangup(c);
1069                         o->owner = c = NULL;
1070                         /* XXX what about the channel itself ? */
1071                 }
1072         }
1073         console_video_start(get_video_desc(c), c); /* XXX cleanup */
1074
1075         return c;
1076 }
1077
1078 static struct ast_channel *oss_request(const char *type, int format, void *data, int *cause)
1079 {
1080         struct ast_channel *c;
1081         struct chan_oss_pvt *o;
1082         AST_DECLARE_APP_ARGS(args,
1083                 AST_APP_ARG(name);
1084                 AST_APP_ARG(flags);
1085         );
1086         char *parse = ast_strdupa(data);
1087
1088         AST_NONSTANDARD_APP_ARGS(args, parse, '/');
1089         o = find_desc(args.name);
1090
1091         ast_log(LOG_WARNING, "oss_request ty <%s> data 0x%p <%s>\n", type, data, (char *) data);
1092         if (o == NULL) {
1093                 ast_log(LOG_NOTICE, "Device %s not found\n", args.name);
1094                 /* XXX we could default to 'dsp' perhaps ? */
1095                 return NULL;
1096         }
1097         if ((format & AST_FORMAT_SLINEAR) == 0) {
1098                 ast_log(LOG_NOTICE, "Format 0x%x unsupported\n", format);
1099                 return NULL;
1100         }
1101         if (o->owner) {
1102                 ast_log(LOG_NOTICE, "Already have a call (chan %p) on the OSS channel\n", o->owner);
1103                 *cause = AST_CAUSE_BUSY;
1104                 return NULL;
1105         }
1106         c = oss_new(o, NULL, NULL, AST_STATE_DOWN);
1107         if (c == NULL) {
1108                 ast_log(LOG_WARNING, "Unable to create new OSS channel\n");
1109                 return NULL;
1110         }
1111         return c;
1112 }
1113
1114 static void store_config_core(struct chan_oss_pvt *o, const char *var, const char *value);
1115
1116 /*! Generic console command handler. Basically a wrapper for a subset
1117  *  of config file options which are also available from the CLI
1118  */
1119 static char *console_cmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1120 {
1121         struct chan_oss_pvt *o = find_desc(oss_active);
1122         const char *var, *value;
1123         switch (cmd) {
1124         case CLI_INIT:
1125                 e->command = CONSOLE_VIDEO_CMDS;
1126                 e->usage = "Usage: " CONSOLE_VIDEO_CMDS "...\n"
1127                 "       Generic handler for console commands.\n";
1128                 return NULL;
1129
1130         case CLI_GENERATE:
1131                 return NULL;
1132         }
1133
1134         if (a->argc < e->args)
1135                 return CLI_SHOWUSAGE;
1136         if (o == NULL) {
1137                 ast_log(LOG_WARNING, "Cannot find device %s (should not happen!)\n",
1138                         oss_active);
1139                 return CLI_FAILURE;
1140         }
1141         var = a->argv[e->args-1];
1142         value = a->argc > e->args ? a->argv[e->args] : NULL;
1143         if (value)      /* handle setting */
1144                 store_config_core(o, var, value);
1145         if (console_video_cli(o->env, var, a->fd))      /* print video-related values */
1146                 return CLI_SUCCESS;
1147         /* handle other values */
1148         if (!strcasecmp(var, "device")) {
1149                 ast_cli(a->fd, "device is [%s]\n", o->device);
1150         }
1151         return CLI_SUCCESS;
1152 }
1153
1154 static char *console_autoanswer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1155 {
1156         struct chan_oss_pvt *o = find_desc(oss_active);
1157
1158         switch (cmd) {
1159         case CLI_INIT:
1160                 e->command = "console autoanswer [on|off]";
1161                 e->usage =
1162                         "Usage: console autoanswer [on|off]\n"
1163                         "       Enables or disables autoanswer feature.  If used without\n"
1164                         "       argument, displays the current on/off status of autoanswer.\n"
1165                         "       The default value of autoanswer is in 'oss.conf'.\n";
1166                 return NULL;
1167
1168         case CLI_GENERATE:
1169                 return NULL;
1170         }
1171
1172         if (a->argc == e->args - 1) {
1173                 ast_cli(a->fd, "Auto answer is %s.\n", o->autoanswer ? "on" : "off");
1174                 return CLI_SUCCESS;
1175         }
1176         if (a->argc != e->args)
1177                 return CLI_SHOWUSAGE;
1178         if (o == NULL) {
1179                 ast_log(LOG_WARNING, "Cannot find device %s (should not happen!)\n",
1180                     oss_active);
1181                 return CLI_FAILURE;
1182         }
1183         if (!strcasecmp(a->argv[e->args-1], "on"))
1184                 o->autoanswer = 1;
1185         else if (!strcasecmp(a->argv[e->args - 1], "off"))
1186                 o->autoanswer = 0;
1187         else
1188                 return CLI_SHOWUSAGE;
1189         return CLI_SUCCESS;
1190 }
1191
1192 /*!
1193  * \brief answer command from the console
1194  */
1195 static char *console_answer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1196 {
1197         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
1198         struct chan_oss_pvt *o = find_desc(oss_active);
1199
1200         switch (cmd) {
1201         case CLI_INIT:
1202                 e->command = "console answer";
1203                 e->usage =
1204                         "Usage: console answer\n"
1205                         "       Answers an incoming call on the console (OSS) channel.\n";
1206                 return NULL;
1207
1208         case CLI_GENERATE:
1209                 return NULL;    /* no completion */
1210         }
1211         if (a->argc != e->args)
1212                 return CLI_SHOWUSAGE;
1213         if (!o->owner) {
1214                 ast_cli(a->fd, "No one is calling us\n");
1215                 return CLI_FAILURE;
1216         }
1217         o->hookstate = 1;
1218         o->cursound = -1;
1219         o->nosound = 0;
1220         ast_queue_frame(o->owner, &f);
1221         return CLI_SUCCESS;
1222 }
1223
1224 /*!
1225  * \brief Console send text CLI command
1226  *
1227  * \note concatenate all arguments into a single string. argv is NULL-terminated
1228  * so we can use it right away
1229  */
1230 static char *console_sendtext(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1231 {
1232         struct chan_oss_pvt *o = find_desc(oss_active);
1233         char buf[TEXT_SIZE];
1234
1235         if (cmd == CLI_INIT) {
1236                 e->command = "console send text";
1237                 e->usage =
1238                         "Usage: console send text <message>\n"
1239                         "       Sends a text message for display on the remote terminal.\n";
1240                 return NULL;
1241         } else if (cmd == CLI_GENERATE)
1242                 return NULL;
1243
1244         if (a->argc < e->args + 1)
1245                 return CLI_SHOWUSAGE;
1246         if (!o->owner) {
1247                 ast_cli(a->fd, "Not in a call\n");
1248                 return CLI_FAILURE;
1249         }
1250         ast_join(buf, sizeof(buf) - 1, a->argv + e->args);
1251         if (!ast_strlen_zero(buf)) {
1252                 struct ast_frame f = { 0, };
1253                 int i = strlen(buf);
1254                 buf[i] = '\n';
1255                 f.frametype = AST_FRAME_TEXT;
1256                 f.subclass = 0;
1257                 f.data = buf;
1258                 f.datalen = i + 1;
1259                 ast_queue_frame(o->owner, &f);
1260         }
1261         return CLI_SUCCESS;
1262 }
1263
1264 static char *console_hangup(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1265 {
1266         struct chan_oss_pvt *o = find_desc(oss_active);
1267
1268         if (cmd == CLI_INIT) {
1269                 e->command = "console hangup";
1270                 e->usage =
1271                         "Usage: console hangup\n"
1272                         "       Hangs up any call currently placed on the console.\n";
1273                 return NULL;
1274         } else if (cmd == CLI_GENERATE)
1275                 return NULL;
1276
1277         if (a->argc != e->args)
1278                 return CLI_SHOWUSAGE;
1279         o->cursound = -1;
1280         o->nosound = 0;
1281         if (!o->owner && !o->hookstate) { /* XXX maybe only one ? */
1282                 ast_cli(a->fd, "No call to hang up\n");
1283                 return CLI_FAILURE;
1284         }
1285         o->hookstate = 0;
1286         if (o->owner)
1287                 ast_queue_hangup(o->owner);
1288         setformat(o, O_CLOSE);
1289         return CLI_SUCCESS;
1290 }
1291
1292 static char *console_flash(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1293 {
1294         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_FLASH };
1295         struct chan_oss_pvt *o = find_desc(oss_active);
1296
1297         if (cmd == CLI_INIT) {
1298                 e->command = "console flash";
1299                 e->usage =
1300                         "Usage: console flash\n"
1301                         "       Flashes the call currently placed on the console.\n";
1302                 return NULL;
1303         } else if (cmd == CLI_GENERATE)
1304                 return NULL;
1305
1306         if (a->argc != e->args)
1307                 return CLI_SHOWUSAGE;
1308         o->cursound = -1;
1309         o->nosound = 0;                         /* when cursound is -1 nosound must be 0 */
1310         if (!o->owner) {                        /* XXX maybe !o->hookstate too ? */
1311                 ast_cli(a->fd, "No call to flash\n");
1312                 return CLI_FAILURE;
1313         }
1314         o->hookstate = 0;
1315         if (o->owner)                           /* XXX must be true, right ? */
1316                 ast_queue_frame(o->owner, &f);
1317         return CLI_SUCCESS;
1318 }
1319
1320 static char *console_dial(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1321 {
1322         char *s = NULL, *mye = NULL, *myc = NULL;
1323         struct chan_oss_pvt *o = find_desc(oss_active);
1324
1325         if (cmd == CLI_INIT) {
1326                 e->command = "console dial";
1327                 e->usage =
1328                         "Usage: console dial [extension[@context]]\n"
1329                         "       Dials a given extension (and context if specified)\n";
1330                 return NULL;
1331         } else if (cmd == CLI_GENERATE)
1332                 return NULL;
1333
1334         if (a->argc > e->args + 1)
1335                 return CLI_SHOWUSAGE;
1336         if (o->owner) { /* already in a call */
1337                 int i;
1338                 struct ast_frame f = { AST_FRAME_DTMF, 0 };
1339
1340                 if (a->argc == e->args) {       /* argument is mandatory here */
1341                         ast_cli(a->fd, "Already in a call. You can only dial digits until you hangup.\n");
1342                         return CLI_FAILURE;
1343                 }
1344                 s = a->argv[e->args];
1345                 /* send the string one char at a time */
1346                 for (i = 0; i < strlen(s); i++) {
1347                         f.subclass = s[i];
1348                         ast_queue_frame(o->owner, &f);
1349                 }
1350                 return CLI_SUCCESS;
1351         }
1352         /* if we have an argument split it into extension and context */
1353         if (a->argc == e->args + 1)
1354                 s = ast_ext_ctx(a->argv[e->args], &mye, &myc);
1355         /* supply default values if needed */
1356         if (mye == NULL)
1357                 mye = o->ext;
1358         if (myc == NULL)
1359                 myc = o->ctx;
1360         if (ast_exists_extension(NULL, myc, mye, 1, NULL)) {
1361                 o->hookstate = 1;
1362                 oss_new(o, mye, myc, AST_STATE_RINGING);
1363         } else
1364                 ast_cli(a->fd, "No such extension '%s' in context '%s'\n", mye, myc);
1365         if (s)
1366                 ast_free(s);
1367         return CLI_SUCCESS;
1368 }
1369
1370 static char *console_mute(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1371 {
1372         struct chan_oss_pvt *o = find_desc(oss_active);
1373         char *s;
1374         
1375         if (cmd == CLI_INIT) {
1376                 e->command = "console {mute|unmute}";
1377                 e->usage =
1378                         "Usage: console {mute|unmute}\n"
1379                         "       Mute/unmute the microphone.\n";
1380                 return NULL;
1381         } else if (cmd == CLI_GENERATE)
1382                 return NULL;
1383
1384         if (a->argc != e->args)
1385                 return CLI_SHOWUSAGE;
1386         s = a->argv[e->args-1];
1387         if (!strcasecmp(s, "mute"))
1388                 o->mute = 1;
1389         else if (!strcasecmp(s, "unmute"))
1390                 o->mute = 0;
1391         else
1392                 return CLI_SHOWUSAGE;
1393         return CLI_SUCCESS;
1394 }
1395
1396 static char *console_transfer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1397 {
1398         struct chan_oss_pvt *o = find_desc(oss_active);
1399         struct ast_channel *b = NULL;
1400         char *tmp, *ext, *ctx;
1401
1402         switch (cmd) {
1403         case CLI_INIT:
1404                 e->command = "console transfer";
1405                 e->usage =
1406                         "Usage: console transfer <extension>[@context]\n"
1407                         "       Transfers the currently connected call to the given extension (and\n"
1408                         "       context if specified)\n";
1409                 return NULL;
1410         case CLI_GENERATE:
1411                 return NULL;
1412         }
1413
1414         if (a->argc != 3)
1415                 return CLI_SHOWUSAGE;
1416         if (o == NULL)
1417                 return CLI_FAILURE;
1418         if (o->owner == NULL || (b = ast_bridged_channel(o->owner)) == NULL) {
1419                 ast_cli(a->fd, "There is no call to transfer\n");
1420                 return CLI_SUCCESS;
1421         }
1422
1423         tmp = ast_ext_ctx(a->argv[2], &ext, &ctx);
1424         if (ctx == NULL)                        /* supply default context if needed */
1425                 ctx = o->owner->context;
1426         if (!ast_exists_extension(b, ctx, ext, 1, b->cid.cid_num))
1427                 ast_cli(a->fd, "No such extension exists\n");
1428         else {
1429                 ast_cli(a->fd, "Whee, transferring %s to %s@%s.\n", b->name, ext, ctx);
1430                 if (ast_async_goto(b, ctx, ext, 1))
1431                         ast_cli(a->fd, "Failed to transfer :(\n");
1432         }
1433         if (tmp)
1434                 ast_free(tmp);
1435         return CLI_SUCCESS;
1436 }
1437
1438 static char *console_active(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1439 {
1440         switch (cmd) {
1441         case CLI_INIT:
1442                 e->command = "console active";
1443                 e->usage =
1444                         "Usage: console active [device]\n"
1445                         "       If used without a parameter, displays which device is the current\n"
1446                         "       console.  If a device is specified, the console sound device is changed to\n"
1447                         "       the device specified.\n";
1448                 return NULL;
1449         case CLI_GENERATE:
1450                 return NULL;
1451         }
1452
1453         if (a->argc == 2)
1454                 ast_cli(a->fd, "active console is [%s]\n", oss_active);
1455         else if (a->argc != 3)
1456                 return CLI_SHOWUSAGE;
1457         else {
1458                 struct chan_oss_pvt *o;
1459                 if (strcmp(a->argv[2], "show") == 0) {
1460                         for (o = oss_default.next; o; o = o->next)
1461                                 ast_cli(a->fd, "device [%s] exists\n", o->name);
1462                         return CLI_SUCCESS;
1463                 }
1464                 o = find_desc(a->argv[2]);
1465                 if (o == NULL)
1466                         ast_cli(a->fd, "No device [%s] exists\n", a->argv[2]);
1467                 else
1468                         oss_active = o->name;
1469         }
1470         return CLI_SUCCESS;
1471 }
1472
1473 /*!
1474  * \brief store the boost factor
1475  */
1476 static void store_boost(struct chan_oss_pvt *o, const char *s)
1477 {
1478         double boost = 0;
1479         if (sscanf(s, "%lf", &boost) != 1) {
1480                 ast_log(LOG_WARNING, "invalid boost <%s>\n", s);
1481                 return;
1482         }
1483         if (boost < -BOOST_MAX) {
1484                 ast_log(LOG_WARNING, "boost %s too small, using %d\n", s, -BOOST_MAX);
1485                 boost = -BOOST_MAX;
1486         } else if (boost > BOOST_MAX) {
1487                 ast_log(LOG_WARNING, "boost %s too large, using %d\n", s, BOOST_MAX);
1488                 boost = BOOST_MAX;
1489         }
1490         boost = exp(log(10) * boost / 20) * BOOST_SCALE;
1491         o->boost = boost;
1492         ast_log(LOG_WARNING, "setting boost %s to %d\n", s, o->boost);
1493 }
1494
1495 static char *console_boost(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1496 {
1497         struct chan_oss_pvt *o = find_desc(oss_active);
1498
1499         switch (cmd) {
1500         case CLI_INIT:
1501                 e->command = "console boost";
1502                 e->usage =
1503                         "Usage: console boost [boost in dB]\n"
1504                         "       Sets or display mic boost in dB\n";
1505                 return NULL;
1506         case CLI_GENERATE:
1507                 return NULL;
1508         }
1509
1510         if (a->argc == 2)
1511                 ast_cli(a->fd, "boost currently %5.1f\n", 20 * log10(((double) o->boost / (double) BOOST_SCALE)));
1512         else if (a->argc == 3)
1513                 store_boost(o, a->argv[2]);
1514         return CLI_SUCCESS;
1515 }
1516
1517 static struct ast_cli_entry cli_oss[] = {
1518         AST_CLI_DEFINE(console_answer, "Answer an incoming console call"),
1519         AST_CLI_DEFINE(console_hangup, "Hangup a call on the console"),
1520         AST_CLI_DEFINE(console_flash, "Flash a call on the console"),
1521         AST_CLI_DEFINE(console_dial, "Dial an extension on the console"),
1522         AST_CLI_DEFINE(console_mute, "Disable/Enable mic input"),
1523         AST_CLI_DEFINE(console_transfer, "Transfer a call to a different extension"),   
1524         AST_CLI_DEFINE(console_cmd, "Generic console command"),
1525         AST_CLI_DEFINE(console_sendtext, "Send text to the remote device"),
1526         AST_CLI_DEFINE(console_autoanswer, "Sets/displays autoanswer"),
1527         AST_CLI_DEFINE(console_boost, "Sets/displays mic boost in dB"),
1528         AST_CLI_DEFINE(console_active, "Sets/displays active console"),
1529 };
1530
1531 /*!
1532  * store the mixer argument from the config file, filtering possibly
1533  * invalid or dangerous values (the string is used as argument for
1534  * system("mixer %s")
1535  */
1536 static void store_mixer(struct chan_oss_pvt *o, const char *s)
1537 {
1538         int i;
1539
1540         for (i = 0; i < strlen(s); i++) {
1541                 if (!isalnum(s[i]) && index(" \t-/", s[i]) == NULL) {
1542                         ast_log(LOG_WARNING, "Suspect char %c in mixer cmd, ignoring:\n\t%s\n", s[i], s);
1543                         return;
1544                 }
1545         }
1546         if (o->mixer_cmd)
1547                 ast_free(o->mixer_cmd);
1548         o->mixer_cmd = ast_strdup(s);
1549         ast_log(LOG_WARNING, "setting mixer %s\n", s);
1550 }
1551
1552 /*!
1553  * store the callerid components
1554  */
1555 static void store_callerid(struct chan_oss_pvt *o, const char *s)
1556 {
1557         ast_callerid_split(s, o->cid_name, sizeof(o->cid_name), o->cid_num, sizeof(o->cid_num));
1558 }
1559
1560 static void store_config_core(struct chan_oss_pvt *o, const char *var, const char *value)
1561 {
1562         M_START(var, value);
1563
1564         /* handle jb conf */
1565         if (!ast_jb_read_conf(&global_jbconf, (char *)var,(char *) value))
1566                 return;
1567
1568         if (!console_video_config(&o->env, var, value))
1569                 return;
1570         M_BOOL("autoanswer", o->autoanswer)
1571         M_BOOL("autohangup", o->autohangup)
1572         M_BOOL("overridecontext", o->overridecontext)
1573         M_STR("device", o->device)
1574         M_UINT("frags", o->frags)
1575         M_UINT("debug", oss_debug)
1576         M_UINT("queuesize", o->queuesize)
1577         M_STR("context", o->ctx)
1578         M_STR("language", o->language)
1579         M_STR("mohinterpret", o->mohinterpret)
1580         M_STR("extension", o->ext)
1581         M_F("mixer", store_mixer(o, value))
1582         M_F("callerid", store_callerid(o, value))  
1583         M_F("boost", store_boost(o, value))
1584
1585         M_END(/* */);
1586 }
1587
1588 /*!
1589  * grab fields from the config file, init the descriptor and open the device.
1590  */
1591 static struct chan_oss_pvt *store_config(struct ast_config *cfg, char *ctg)
1592 {
1593         struct ast_variable *v;
1594         struct chan_oss_pvt *o;
1595
1596         if (ctg == NULL) {
1597                 o = &oss_default;
1598                 ctg = "general";
1599         } else {
1600                 if (!(o = ast_calloc(1, sizeof(*o))))
1601                         return NULL;
1602                 *o = oss_default;
1603                 /* "general" is also the default thing */
1604                 if (strcmp(ctg, "general") == 0) {
1605                         o->name = ast_strdup("dsp");
1606                         oss_active = o->name;
1607                         goto openit;
1608                 }
1609                 o->name = ast_strdup(ctg);
1610         }
1611
1612         strcpy(o->mohinterpret, "default");
1613
1614         o->lastopen = ast_tvnow();      /* don't leave it 0 or tvdiff may wrap */
1615         /* fill other fields from configuration */
1616         for (v = ast_variable_browse(cfg, ctg); v; v = v->next) {
1617                 store_config_core(o, v->name, v->value);
1618         }
1619         if (ast_strlen_zero(o->device))
1620                 ast_copy_string(o->device, DEV_DSP, sizeof(o->device));
1621         if (o->mixer_cmd) {
1622                 char *cmd;
1623
1624                 asprintf(&cmd, "mixer %s", o->mixer_cmd);
1625                 ast_log(LOG_WARNING, "running [%s]\n", cmd);
1626                 system(cmd);
1627                 ast_free(cmd);
1628         }
1629         if (o == &oss_default)          /* we are done with the default */
1630                 return NULL;
1631
1632   openit:
1633 #ifdef TRYOPEN
1634         if (setformat(o, O_RDWR) < 0) { /* open device */
1635                 ast_verb(1, "Device %s not detected\n", ctg);
1636                 ast_verb(1, "Turn off OSS support by adding " "'noload=chan_oss.so' in /etc/asterisk/modules.conf\n");
1637                 goto error;
1638         }
1639         if (o->duplex != M_FULL)
1640                 ast_log(LOG_WARNING, "XXX I don't work right with non " "full-duplex sound cards XXX\n");
1641 #endif /* TRYOPEN */
1642         if (pipe(o->sndcmd) != 0) {
1643                 ast_log(LOG_ERROR, "Unable to create pipe\n");
1644                 goto error;
1645         }
1646         ast_pthread_create_background(&o->sthread, NULL, sound_thread, o);
1647         /* link into list of devices */
1648         if (o != &oss_default) {
1649                 o->next = oss_default.next;
1650                 oss_default.next = o;
1651         }
1652         return o;
1653
1654   error:
1655         if (o != &oss_default)
1656                 ast_free(o);
1657         return NULL;
1658 }
1659
1660 static int load_module(void)
1661 {
1662         struct ast_config *cfg = NULL;
1663         char *ctg = NULL;
1664         struct ast_flags config_flags = { 0 };
1665
1666         /* Copy the default jb config over global_jbconf */
1667         memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
1668
1669         /* load config file */
1670         if (!(cfg = ast_config_load(config, config_flags))) {
1671                 ast_log(LOG_NOTICE, "Unable to load config %s\n", config);
1672                 return AST_MODULE_LOAD_DECLINE;
1673         }
1674
1675         do {
1676                 store_config(cfg, ctg);
1677         } while ( (ctg = ast_category_browse(cfg, ctg)) != NULL);
1678
1679         ast_config_destroy(cfg);
1680
1681         if (find_desc(oss_active) == NULL) {
1682                 ast_log(LOG_NOTICE, "Device %s not found\n", oss_active);
1683                 /* XXX we could default to 'dsp' perhaps ? */
1684                 /* XXX should cleanup allocated memory etc. */
1685                 return AST_MODULE_LOAD_FAILURE;
1686         }
1687
1688         if (ast_channel_register(&oss_tech)) {
1689                 ast_log(LOG_ERROR, "Unable to register channel type 'OSS'\n");
1690                 return AST_MODULE_LOAD_FAILURE;
1691         }
1692
1693         ast_cli_register_multiple(cli_oss, sizeof(cli_oss) / sizeof(struct ast_cli_entry));
1694
1695         return AST_MODULE_LOAD_SUCCESS;
1696 }
1697
1698
1699 static int unload_module(void)
1700 {
1701         struct chan_oss_pvt *o;
1702
1703         ast_channel_unregister(&oss_tech);
1704         ast_cli_unregister_multiple(cli_oss, sizeof(cli_oss) / sizeof(struct ast_cli_entry));
1705
1706         for (o = oss_default.next; o; o = o->next) {
1707                 close(o->sounddev);
1708                 if (o->sndcmd[0] > 0) {
1709                         close(o->sndcmd[0]);
1710                         close(o->sndcmd[1]);
1711                 }
1712                 if (o->owner)
1713                         ast_softhangup(o->owner, AST_SOFTHANGUP_APPUNLOAD);
1714                 if (o->owner)                   /* XXX how ??? */
1715                         return -1;
1716                 /* XXX what about the thread ? */
1717                 /* XXX what about the memory allocated ? */
1718         }
1719         return 0;
1720 }
1721
1722 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "OSS Console Channel Driver");