diff -uNr asterisk/Makefile /home/mahmut/asterisk/Makefile --- asterisk/Makefile Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/Makefile Wed Mar 12 12:08:07 2003 @@ -183,6 +183,7 @@ install include/asterisk/*.h $(ASTHEADERDIR) rm -f $(ASTVARLIBDIR)/sounds/vm mkdir -p $(ASTSPOOLDIR)/vm + mkdir -p $(ASTSPOOLDIR)/monitor rm -f $(ASTMODULESDIR)/chan_ixj.so rm -f $(ASTMODULESDIR)/chan_tor.so mkdir -p $(ASTVARLIBDIR)/sounds diff -uNr asterisk/apps/app_queue.c /home/mahmut/asterisk/apps/app_queue.c --- asterisk/apps/app_queue.c Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/apps/app_queue.c Wed Feb 19 15:59:33 2003 @@ -156,7 +156,8 @@ q->count++; res = 0; manager_event(EVENT_FLAG_CALL, "Join", - "Queue: %s\r\nPosition: %d\r\n", q->name, qe->pos ); + "Channel: %s\r\nQueue: %s\r\nPosition: %d\r\n", + qe->chan->name, q->name, qe->pos ); } ast_pthread_mutex_unlock(&q->lock); @@ -212,7 +213,8 @@ ast_pthread_mutex_lock(&q->lock); /* Take us out of the queue */ manager_event(EVENT_FLAG_CALL, "Leave", - "Queue: %s\r\n", q->name ); + "Channel: %s\r\nQueue: %s\r\n", + qe->chan->name, q->name ); prev = NULL; cur = q->head; while(cur) { diff -uNr asterisk/channel.c /home/mahmut/asterisk/channel.c --- asterisk/channel.c Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/channel.c Wed Mar 12 12:45:40 2003 @@ -33,6 +33,7 @@ #include #include #include +#include static int shutting_down = 0; @@ -368,6 +369,9 @@ ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n", chan->name, f->frametype, f->subclass, qlen, strerror(errno)); } + if (qlen > 128) { + ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name); + } if (lock) ast_pthread_mutex_unlock(&chan->lock); return 0; @@ -487,6 +491,10 @@ ast_log(LOG_WARNING, "Unable to find channel in list\n"); if (chan->pvt->pvt) ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name); + /* Stop monitoring */ + if (chan->monitor) { + chan->monitor->stop( chan, 0 ); + } /* Free translatosr */ if (chan->pvt->readtrans) ast_translator_free_path(chan->pvt->readtrans); @@ -1026,6 +1034,10 @@ /* Answer the CDR */ ast_setstate(chan, AST_STATE_UP); ast_cdr_answer(chan->cdr); + } else if( ( f->frametype == AST_FRAME_VOICE ) && chan->monitor && chan->monitor->read_stream ) { + if( ast_writestream( chan->monitor->read_stream, f ) < 0 ) { + ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n"); + } } pthread_mutex_unlock(&chan->lock); @@ -1217,7 +1229,16 @@ } else f = fr; if (f) + { res = chan->pvt->write(chan, f); + if( chan->monitor && + chan->monitor->write_stream && + f && ( f->frametype == AST_FRAME_VOICE ) ) { + if( ast_writestream( chan->monitor->write_stream, f ) < 0 ) { + ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n"); + } + } + } else res = 0; } @@ -1843,7 +1864,7 @@ break; } if (c0->pvt->bridge && - (c0->pvt->bridge == c1->pvt->bridge) && !nativefailed) { + (c0->pvt->bridge == c1->pvt->bridge) && !nativefailed && !c0->monitor && !c1->monitor) { /* Looks like they share a bridge code */ if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Attempting native bridge of %s and %s\n", c0->name, c1->name); @@ -2105,3 +2126,5 @@ } return 0; } + + diff -uNr asterisk/channels/chan_agent.c /home/mahmut/asterisk/channels/chan_agent.c --- asterisk/channels/chan_agent.c Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/channels/chan_agent.c Wed Mar 12 12:45:40 2003 @@ -223,21 +223,36 @@ struct agent_pvt *p = ast->pvt->pvt; int res = -1; ast_pthread_mutex_lock(&p->lock); + ast_verbose( VERBOSE_PREFIX_3 "agent_call, call to agent '%s' call on '%s'\n", p->agent, p->chan->name); + ast_log( LOG_DEBUG, "Playing beep, lang '%s'\n", p->chan->language); res = ast_streamfile(p->chan, "beep", p->chan->language); - if (!res) + ast_log( LOG_DEBUG, "Played beep, result '%d'\n", res); + if (!res) { res = ast_waitstream(p->chan, ""); + ast_log( LOG_DEBUG, "Waited for stream, result '%d'\n", res); + } if (!res) { res = ast_set_read_format(p->chan, ast_best_codec(p->chan->nativeformats)); + ast_log( LOG_DEBUG, "Set read format, result '%d'\n", res); if (res) ast_log(LOG_WARNING, "Unable to set read format to %d\n", ast_best_codec(p->chan->nativeformats)); } + else { + // Agent hung-up + p->chan = NULL; + } + if (!res) { ast_set_write_format(p->chan, ast_best_codec(p->chan->nativeformats)); + ast_log( LOG_DEBUG, "Set write format, result '%d'\n", res); if (res) ast_log(LOG_WARNING, "Unable to set write format to %d\n", ast_best_codec(p->chan->nativeformats)); } - /* Call is immediately up */ - ast_setstate(ast, AST_STATE_UP); + if( !res ) + { + /* Call is immediately up */ + ast_setstate(ast, AST_STATE_UP); + } CLEANUP(ast,p); ast_pthread_mutex_unlock(&p->lock); return res; @@ -250,9 +265,6 @@ p->owner = NULL; ast->pvt->pvt = NULL; p->app_sleep_cond = 1; - ast_pthread_mutex_unlock(&p->lock); - /* Release ownership of the agent to other threads (presumably running the login app). */ - ast_pthread_mutex_unlock(&p->app_lock); if (p->chan) { /* If they're dead, go ahead and hang up on the agent now */ ast_pthread_mutex_lock(&p->chan->lock); @@ -260,9 +272,20 @@ ast_softhangup(p->chan, AST_SOFTHANGUP_EXPLICIT); ast_moh_start(p->chan, p->moh); ast_pthread_mutex_unlock(&p->chan->lock); - } else if (p->dead) + ast_pthread_mutex_unlock(&p->lock); + /* Release ownership of the agent to other threads (presumably running the login app). */ + ast_pthread_mutex_unlock(&p->app_lock); + } else if (p->dead) { /* Go ahead and lose it */ + ast_pthread_mutex_unlock(&p->lock); + /* Release ownership of the agent to other threads (presumably running the login app). */ + ast_pthread_mutex_unlock(&p->app_lock); free(p); + } else { + ast_pthread_mutex_unlock(&p->lock); + /* Release ownership of the agent to other threads (presumably running the login app). */ + ast_pthread_mutex_unlock(&p->app_lock); + } return 0; } @@ -333,6 +356,15 @@ ast_pthread_mutex_unlock(&p->lock); /* For other thread to read the condition. */ ast_pthread_mutex_lock(&p->app_lock); ast_pthread_mutex_lock(&p->lock); + if( !p->chan ) + { + ast_log(LOG_WARNING, "Agent disconnected while we were connecting the call\n"); + p->owner = NULL; + tmp->pvt->pvt = NULL; + p->app_sleep_cond = 1; + ast_channel_free( tmp ); + return NULL; + } } p->owning_app = pthread_self(); /* After the above step, there should not be any blockers. */ @@ -486,9 +518,6 @@ char *opt_user = NULL; char *options = NULL; int play_announcement; - struct timespec required; - struct timespec remaining; - int delay; LOCAL_USER_ADD(u); @@ -577,21 +606,12 @@ ast_pthread_mutex_unlock(&p->lock); ast_pthread_mutex_unlock(&agentlock); while (res >= 0) { - /* If we are not the owner, delay here for a while - * so other interested threads can kick in. */ - delay = 0; ast_pthread_mutex_lock(&p->lock); if (p->chan != chan) res = -1; - if (p->owner) - delay = 1; ast_pthread_mutex_unlock(&p->lock); - if (delay) { - sched_yield(); - required.tv_sec = 0; - required.tv_nsec = 20 * 1000 * 1000; - nanosleep( &required, &remaining ); - } + /* Yield here so other interested threads can kick in. */ + sched_yield(); if (res) break; @@ -603,12 +623,15 @@ res = ast_safe_sleep_conditional( chan, 1000, agent_cont_sleep, p ); pthread_mutex_unlock( &p->app_lock ); + sched_yield(); } + ast_pthread_mutex_lock(&p->lock); if (res && p->owner) ast_log(LOG_WARNING, "Huh? We broke out when there was still an owner?\n"); /* Log us off if appropriate */ if (p->chan == chan) p->chan = NULL; + ast_pthread_mutex_unlock(&p->lock); if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Agent '%s' logged out\n", p->agent); manager_event(EVENT_FLAG_AGENT, "Agentlogoff", diff -uNr asterisk/channels/chan_sip.c /home/mahmut/asterisk/channels/chan_sip.c --- asterisk/channels/chan_sip.c Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/channels/chan_sip.c Wed Mar 12 12:08:07 2003 @@ -77,6 +77,8 @@ static char language[MAX_LANGUAGE] = ""; +static char callerid[AST_MAX_EXTENSION] = "asterisk"; + static int usecnt =0; static pthread_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER; @@ -1957,17 +1959,17 @@ char to[256]; char tmp[80]; char cid[256]; - char *l = "asterisk", *n=NULL; + char *l = callerid, *n=NULL; if (p->owner && p->owner->callerid) { strcpy(cid, p->owner->callerid); ast_callerid_parse(cid, &n, &l); if (l) ast_shrink_phone_number(l); if (!l || !ast_isphonenumber(l)) - l = "asterisk"; + l = callerid; } if (!n) - n = l; + n = callerid; snprintf(from, sizeof(from), "\"%s\" ;tag=%08x", n, l, inet_ntoa(p->ourip), p->tag); if (strlen(p->username)) { if (ntohs(p->sa.sin_port) != DEFAULT_SIP_PORT) { @@ -4185,6 +4187,8 @@ } } else if (!strcasecmp(v->name, "language")) { strncpy(language, v->value, sizeof(language)-1); + } else if (!strcasecmp(v->name, "callerid")) { + strncpy(callerid, v->value, sizeof(callerid)-1); } else if (!strcasecmp(v->name, "nat")) { globalnat = ast_true(v->value); } else if (!strcasecmp(v->name, "maxexpirey")) { diff -uNr asterisk/formats/Makefile /home/mahmut/asterisk/formats/Makefile --- asterisk/formats/Makefile Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/formats/Makefile Wed Feb 19 15:59:33 2003 @@ -11,7 +11,8 @@ # the GNU General Public License # -FORMAT_LIBS=format_g723.so format_wav.so format_mp3.so format_wav_gsm.so format_gsm.so format_vox.so format_pcm.so format_g729.so +FORMAT_LIBS=format_g723.so format_wav.so format_mp3.so format_wav_gsm.so \ + format_gsm.so format_vox.so format_pcm.so format_g729.so format_pcm_alaw.so FORMAT_LIBS+=format_jpeg.so GSMLIB=../codecs/gsm/lib/libgsm.a diff -uNr asterisk/formats/format_pcm_alaw.c /home/mahmut/asterisk/formats/format_pcm_alaw.c --- asterisk/formats/format_pcm_alaw.c Thu Jan 1 10:00:00 1970 +++ /home/mahmut/asterisk/formats/format_pcm_alaw.c Wed Feb 19 15:59:33 2003 @@ -0,0 +1,406 @@ +/* + * Asterisk -- A telephony toolkit for Linux. + * + * Flat, binary, alaw PCM file format. + * + * Copyright (C) 1999, Mark Spencer + * + * Mark Spencer + * + * This program is free software, distributed under the terms of + * the GNU General Public License + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BUF_SIZE 160 /* 160 samples */ + +struct ast_filestream { + void *reserved[AST_RESERVED_POINTERS]; + /* Believe it or not, we must decode/recode to account for the + weird MS format */ + /* This is what a filestream means to us */ + int fd; /* Descriptor */ + struct ast_channel *owner; + struct ast_frame fr; /* Frame information */ + char waste[AST_FRIENDLY_OFFSET]; /* Buffer for sending frames, etc */ + char empty; /* Empty character */ + unsigned char buf[BUF_SIZE]; /* Output Buffer */ + int lasttimeout; + struct timeval last; + unsigned long start_time; + int adj; + struct ast_filestream *next; +}; + + +static struct ast_filestream *glist = NULL; +static pthread_mutex_t pcm_lock = AST_MUTEX_INITIALIZER; +static int glistcnt = 0; + +static char *name = "alaw"; +static char *desc = "Raw aLaw 8khz PCM Audio support"; +static char *exts = "alaw|al"; + + +/* Returns time in msec since system boot. */ +static unsigned long get_time() +{ + struct tms buf; + clock_t cur; + + cur = times( &buf ); + if( cur < 0 ) + { + ast_log( LOG_WARNING, "Cannot get current time\n" ); + return 0; + } + return cur * 1000 / sysconf( _SC_CLK_TCK ); +} + +static struct ast_filestream *pcm_open(int fd) +{ + /* We don't have any header to read or anything really, but + if we did, it would go here. We also might want to check + and be sure it's a valid file. */ + struct ast_filestream *tmp; + if ((tmp = malloc(sizeof(struct ast_filestream)))) { + memset(tmp, 0, sizeof(struct ast_filestream)); + if (pthread_mutex_lock(&pcm_lock)) { + ast_log(LOG_WARNING, "Unable to lock pcm list\n"); + free(tmp); + return NULL; + } + tmp->next = glist; + glist = tmp; + tmp->fd = fd; + tmp->owner = NULL; + tmp->fr.data = tmp->buf; + tmp->fr.frametype = AST_FRAME_VOICE; + tmp->fr.subclass = AST_FORMAT_ALAW; + /* datalen will vary for each frame */ + tmp->fr.src = name; + tmp->fr.mallocd = 0; + tmp->lasttimeout = -1; + tmp->start_time = get_time(); + glistcnt++; + pthread_mutex_unlock(&pcm_lock); + ast_update_use_count(); + } + return tmp; +} + +static struct ast_filestream *pcm_rewrite(int fd, char *comment) +{ + /* We don't have any header to read or anything really, but + if we did, it would go here. We also might want to check + and be sure it's a valid file. */ + struct ast_filestream *tmp; + if ((tmp = malloc(sizeof(struct ast_filestream)))) { + memset(tmp, 0, sizeof(struct ast_filestream)); + if (pthread_mutex_lock(&pcm_lock)) { + ast_log(LOG_WARNING, "Unable to lock pcm list\n"); + free(tmp); + return NULL; + } + tmp->next = glist; + glist = tmp; + tmp->fd = fd; + tmp->owner = NULL; + tmp->lasttimeout = -1; + tmp->start_time = get_time(); + glistcnt++; + pthread_mutex_unlock(&pcm_lock); + ast_update_use_count(); + } else + ast_log(LOG_WARNING, "Out of memory\n"); + return tmp; +} + +static struct ast_frame *pcm_read(struct ast_filestream *s) +{ + return NULL; +} + +static void pcm_close(struct ast_filestream *s) +{ + struct ast_filestream *tmp, *tmpl = NULL; + if (pthread_mutex_lock(&pcm_lock)) { + ast_log(LOG_WARNING, "Unable to lock pcm list\n"); + return; + } + tmp = glist; + while(tmp) { + if (tmp == s) { + if (tmpl) + tmpl->next = tmp->next; + else + glist = tmp->next; + break; + } + tmpl = tmp; + tmp = tmp->next; + } + glistcnt--; + if (s->owner) { + s->owner->stream = NULL; + if (s->owner->streamid > -1) + ast_sched_del(s->owner->sched, s->owner->streamid); + s->owner->streamid = -1; + } + pthread_mutex_unlock(&pcm_lock); + ast_update_use_count(); + if (!tmp) + ast_log(LOG_WARNING, "Freeing a filestream we don't seem to own\n"); + close(s->fd); + free(s); + s = NULL; +} + +static int ast_read_callback(void *data) +{ + int retval = 0; + int res; + int delay; + struct ast_filestream *s = data; + struct timeval tv; + /* Send a frame from the file to the appropriate channel */ + + s->fr.frametype = AST_FRAME_VOICE; + s->fr.subclass = AST_FORMAT_ALAW; + s->fr.offset = AST_FRIENDLY_OFFSET; + s->fr.mallocd = 0; + s->fr.data = s->buf; + if ((res = read(s->fd, s->buf, BUF_SIZE)) < 1) { + if (res) + ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno)); + s->owner->streamid = -1; + return 0; + } + s->fr.samples = res; + s->fr.datalen = res; + delay = s->fr.samples/8; + /* Lastly, process the frame */ + if (ast_write(s->owner, &s->fr)) { + ast_log(LOG_WARNING, "Failed to write frame\n"); + s->owner->streamid = -1; + return 0; + } + if (s->last.tv_usec || s->last.tv_usec) { + int ms; + gettimeofday(&tv, NULL); + ms = 1000 * (tv.tv_sec - s->last.tv_sec) + + (tv.tv_usec - s->last.tv_usec) / 1000; + s->last.tv_sec = tv.tv_sec; + s->last.tv_usec = tv.tv_usec; + if ((ms - delay) * (ms - delay) > 4) { + /* Compensate if we're more than 2 ms off */ + s->adj -= (ms - delay); + } +#if 0 + fprintf(stdout, "Delay is %d, adjustment is %d, last was %d\n", delay, s->adj, ms); +#endif + delay += s->adj; + if (delay < 1) + delay = 1; + } else + gettimeofday(&s->last, NULL); + if (s->lasttimeout != delay) { + /* We'll install the next timeout now. */ + s->owner->streamid = ast_sched_add(s->owner->sched, + delay, ast_read_callback, s); + s->lasttimeout = delay; + } else { + /* Just come back again at the same time */ + retval = -1; + } + return retval; +} + +static int pcm_apply(struct ast_channel *c, struct ast_filestream *s) +{ + /* Select our owner for this stream, and get the ball rolling. */ + s->owner = c; + return 0; +} + +static int pcm_play(struct ast_filestream *s) +{ + ast_read_callback(s); + return 0; +} + +static int pcm_write(struct ast_filestream *fs, struct ast_frame *f) +{ + int res; + unsigned long cur_time; + unsigned long fpos; + struct stat stat_buf; + + if (f->frametype != AST_FRAME_VOICE) { + ast_log(LOG_WARNING, "Asked to write non-voice frame!\n"); + return -1; + } + if (f->subclass != AST_FORMAT_ALAW) { + ast_log(LOG_WARNING, "Asked to write non-alaw frame (%d)!\n", f->subclass); + return -1; + } + + cur_time = get_time(); + fpos = ( cur_time - fs->start_time ) * 8; // 8 bytes per msec + // Check if we have written to this position yet. If we have, then increment pos by one frame + // for some degree of protection against receiving packets in the same clock tick. + fstat( fs->fd, &stat_buf ); + if( stat_buf.st_size > fpos ) + { + fpos += f->datalen; // Incrementing with the size of this current frame + } + + if( stat_buf.st_size < fpos ) + { + // fill the gap with 0x55 rather than 0. + char buf[ 512 ]; + unsigned long cur, to_write; + + cur = stat_buf.st_size; + if( lseek( fs->fd, cur, SEEK_SET ) < 0 ) + { + ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) ); + return -1; + } + memset( buf, 0x55, 512 ); + while( cur < fpos ) + { + to_write = fpos - cur; + if( to_write > 512 ) + { + to_write = 512; + } + write( fs->fd, buf, to_write ); + cur += to_write; + } + } + + + if( lseek( fs->fd, fpos, SEEK_SET ) < 0 ) + { + ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) ); + return -1; + } + + if ((res = write(fs->fd, f->data, f->datalen)) != f->datalen) { + ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno)); + return -1; + } + return 0; +} + +static int pcm_seek(struct ast_filestream *fs, long sample_offset, int whence) +{ + off_t offset,min,cur,max; + + min = 0; + cur = lseek(fs->fd, 0, SEEK_CUR); + max = lseek(fs->fd, 0, SEEK_END); + if(whence == SEEK_SET) + offset = sample_offset; + if(whence == SEEK_CUR) + offset = sample_offset + cur; + if(whence == SEEK_END) + offset = max - sample_offset; + offset = (offset > max)?max:offset; + offset = (offset < min)?min:offset; + return lseek(fs->fd, offset, SEEK_SET); +} + +static int pcm_trunc(struct ast_filestream *fs) +{ + return ftruncate(fs->fd, lseek(fs->fd,0,SEEK_CUR)); +} + +static long pcm_tell(struct ast_filestream *fs) +{ + off_t offset; + offset = lseek(fs->fd, 0, SEEK_CUR); + return offset; +} + + +static char *pcm_getcomment(struct ast_filestream *s) +{ + return NULL; +} + +int load_module() +{ + return ast_format_register(name, exts, AST_FORMAT_ALAW, + pcm_open, + pcm_rewrite, + pcm_apply, + pcm_play, + pcm_write, + pcm_seek, + pcm_trunc, + pcm_tell, + pcm_read, + pcm_close, + pcm_getcomment); +} + +int unload_module() +{ + struct ast_filestream *tmp, *tmpl; + if (pthread_mutex_lock(&pcm_lock)) { + ast_log(LOG_WARNING, "Unable to lock pcm list\n"); + return -1; + } + tmp = glist; + while(tmp) { + if (tmp->owner) + ast_softhangup(tmp->owner, AST_SOFTHANGUP_APPUNLOAD); + tmpl = tmp; + tmp = tmp->next; + free(tmpl); + } + pthread_mutex_unlock(&pcm_lock); + return ast_format_unregister(name); +} + +int usecount() +{ + int res; + if (pthread_mutex_lock(&pcm_lock)) { + ast_log(LOG_WARNING, "Unable to lock pcm list\n"); + return -1; + } + res = glistcnt; + pthread_mutex_unlock(&pcm_lock); + return res; +} + +char *description() +{ + return desc; +} + + +char *key() +{ + return ASTERISK_GPL_KEY; +} diff -uNr asterisk/include/asterisk/channel.h /home/mahmut/asterisk/include/asterisk/channel.h --- asterisk/include/asterisk/channel.h Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/include/asterisk/channel.h Wed Mar 12 12:08:07 2003 @@ -30,6 +30,7 @@ #define AST_MAX_EXTENSION 80 #include +#include #define AST_CHANNEL_NAME 80 @@ -174,6 +175,9 @@ /*! Tone zone */ struct tone_zone *zone; + + /* Channel monitoring */ + struct ast_channel_monitor *monitor; /* Frames in/out counters */ unsigned int fin; diff -uNr asterisk/include/asterisk/monitor.h /home/mahmut/asterisk/include/asterisk/monitor.h --- asterisk/include/asterisk/monitor.h Thu Jan 1 10:00:00 1970 +++ /home/mahmut/asterisk/include/asterisk/monitor.h Wed Feb 19 15:59:33 2003 @@ -0,0 +1,30 @@ +#ifndef _MONITOR_H +#define _MONITOR_H + +#include + +#include + +struct ast_channel; + +//! Responsible for channel monitoring data +struct ast_channel_monitor +{ + struct ast_filestream *read_stream; + struct ast_filestream *write_stream; + char read_filename[ FILENAME_MAX ]; + char write_filename[ FILENAME_MAX ]; + char filename_base[ FILENAME_MAX ]; + int (*stop)( struct ast_channel *chan, int need_lock); +}; + +/* Start monitoring a channel */ +int ast_monitor_start( struct ast_channel *chan, int need_lock ); + +/* Stop monitoring a channel */ +int ast_monitor_stop( struct ast_channel *chan, int need_lock); + +/* Change monitoring filename of a channel */ +int ast_monitor_change_fname( struct ast_channel *chan, const char *fname_base, int need_lock ); + +#endif /* _MONITOR_H */ diff -uNr asterisk/manager.c /home/mahmut/asterisk/manager.c --- asterisk/manager.c Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/manager.c Wed Mar 12 12:45:40 2003 @@ -16,8 +16,11 @@ #include #include #include +#include +#include #include #include +#include #include #include #include @@ -432,6 +435,7 @@ struct manager_action *tmp = first_action; strncpy(action, get_header(m, "Action"), sizeof(action)); + ast_log( LOG_DEBUG, "Manager received command '%s'\n", action ); if (!strlen(action)) { send_error(s, "Missing action in request"); @@ -569,10 +573,13 @@ struct sockaddr_in sin; int sinlen; struct mansession *s; + struct protoent *p; + int arg = 1; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + for (;;) { sinlen = sizeof(sin); as = accept(asock, &sin, &sinlen); @@ -580,6 +587,12 @@ ast_log(LOG_NOTICE, "Accept returned -1: %s\n", strerror(errno)); continue; } + p = getprotobyname("tcp"); + if( p ) { + if( setsockopt(as, p->p_proto, TCP_NODELAY, (char *)&arg, sizeof(arg) ) < 0 ) { + perror( "setsockopt(TCP_NODELAY)" ); + } + } s = malloc(sizeof(struct mansession)); if (!s) { ast_log(LOG_WARNING, "Failed to allocate management session: %s\n", strerror(errno)); @@ -624,6 +637,7 @@ s = s->next; } ast_pthread_mutex_unlock(&sessionlock); + ast_log(LOG_DEBUG, "Manager sent event '%s'\n", event ); return 0; } diff -uNr asterisk/pbx.c /home/mahmut/asterisk/pbx.c --- asterisk/pbx.c Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/pbx.c Wed Mar 12 12:08:07 2003 @@ -1299,6 +1299,10 @@ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (pthread_create(&t, &attr, pbx_thread, c)) { ast_log(LOG_WARNING, "Failed to create new channel thread\n"); +#ifndef EXPERIMENTAL + ast_cli_command( STDERR_FILENO, "stop now" ); + CRASH; // if above command returns. +#endif return -1; } return 0; @@ -3193,6 +3197,10 @@ ast_log(LOG_WARNING, "Failed to start async wait\n"); free(as); ast_hangup(chan); +#ifndef EXPERIMENTAL + ast_cli_command( STDERR_FILENO, "stop now" ); + CRASH; // if above command returns. +#endif return -1; } res = 0; @@ -3283,6 +3291,10 @@ ast_log(LOG_WARNING, "Failed to start async wait\n"); free(as); ast_hangup(chan); +#ifndef EXPERIMENTAL + ast_cli_command( STDERR_FILENO, "stop now" ); + CRASH; // if above command returns. +#endif return -1; } res = 0; diff -uNr asterisk/res/Makefile /home/mahmut/asterisk/res/Makefile --- asterisk/res/Makefile Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/res/Makefile Wed Mar 12 13:05:09 2003 @@ -11,7 +11,7 @@ # the GNU General Public License # -MODS=res_adsi.so res_parking.so res_crypto.so res_musiconhold.so res_indications.so +MODS=res_adsi.so res_parking.so res_crypto.so res_musiconhold.so res_indications.so res_monitor.so CRYPTO_LIBS=-lssl -lcrypto diff -uNr asterisk/res/res_monitor.c /home/mahmut/asterisk/res/res_monitor.c --- asterisk/res/res_monitor.c Thu Jan 1 10:00:00 1970 +++ /home/mahmut/asterisk/res/res_monitor.c Wed Feb 19 15:59:33 2003 @@ -0,0 +1,409 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define AST_MONITOR_DIR INSTALL_PREFIX "/var/spool/asterisk/monitor" + +static pthread_mutex_t monitorlock = AST_MUTEX_INITIALIZER; + +static unsigned long seq = 0; + +static char *monitor_synopsis = "Monitor a channel"; + +static char *monitor_descrip = "Monitor\n" + "Used to start monitoring a channel. The channel's input and output\n" + "voice packets are logged to files until the channel hangs up or\n" + "monitoring is stopped by the StopMonitor application.\n"; + +static char *stopmonitor_synopsis = "Stop monitoring a channel"; + +static char *stopmonitor_descrip = "StopMonitor\n" + "Stops monitoring a channel. Has no effect if the channel is not monitored\n"; + +static char *changemonitor_synopsis = "Change monitoring filename of a channel"; + +static char *changemonitor_descrip = "ChangeMonitor\n" + "Changes monitoring filename of a channel. Has no effect if the channel is not monitored\n"; + +/* Start monitoring a channel */ +int ast_monitor_start( struct ast_channel *chan, int need_lock ) +{ + if( need_lock ) + { + if (ast_pthread_mutex_lock(&chan->lock)) + { + ast_log(LOG_WARNING, "Unable to lock channel\n"); + return -1; + } + } + + if( !(chan->monitor) ) + { + struct ast_channel_monitor *monitor; + char *channel_name, *p; + + /* Create monitoring directory if needed */ + if( mkdir( AST_MONITOR_DIR, 0770 ) < 0 ) + { + if( errno != EEXIST ) + { + ast_log(LOG_WARNING, "Unable to create audio monitor directory: %s\n", + strerror( errno ) ); + } + } + + monitor = malloc( sizeof( struct ast_channel_monitor ) ); + memset( monitor, 0, sizeof( struct ast_channel_monitor ) ); + + /* Determine file names */ + ast_pthread_mutex_lock( &monitorlock ); + snprintf( monitor->read_filename, FILENAME_MAX, "%s/audio-in-%ld", + AST_MONITOR_DIR, seq ); + snprintf( monitor->write_filename, FILENAME_MAX, "%s/audio-out-%ld", + AST_MONITOR_DIR, seq ); + seq++; + ast_pthread_mutex_unlock( &monitorlock ); + + channel_name = strdup( chan->name ); + while( ( p = strchr( channel_name, '/' ) ) ) + { + *p = '-'; + } + snprintf( monitor->filename_base, FILENAME_MAX, "%s/%s", AST_MONITOR_DIR, channel_name ); + free( channel_name ); + + monitor->stop = ast_monitor_stop; + + // open files + if( ast_fileexists( monitor->read_filename, NULL, NULL ) > 0 ) + { + ast_filedelete( monitor->read_filename, NULL ); + } + if( !(monitor->read_stream = ast_writefile( monitor->read_filename, "alaw", NULL, + O_CREAT|O_TRUNC|O_WRONLY, 0, 0644 ) ) ) + { + ast_log(LOG_WARNING, "Could not create file %s\n", monitor->read_filename ); + free( monitor ); + ast_pthread_mutex_unlock(&chan->lock); + return -1; + } + if( ast_fileexists( monitor->write_filename, NULL, NULL ) > 0 ) + { + ast_filedelete( monitor->write_filename, NULL ); + } + if( !(monitor->write_stream = ast_writefile( monitor->write_filename, "alaw", NULL, + O_CREAT|O_TRUNC|O_WRONLY, 0, 0644 ) ) ) + { + ast_log(LOG_WARNING, "Could not create file %s\n", monitor->write_filename ); + ast_closestream( monitor->read_stream ); + free( monitor ); + ast_pthread_mutex_unlock(&chan->lock); + return -1; + } + chan->monitor = monitor; + } + + if( need_lock ) + { + ast_pthread_mutex_unlock(&chan->lock); + } + return 0; +} + +/* Stop monitoring a channel */ +int ast_monitor_stop( struct ast_channel *chan, int need_lock ) +{ + if( need_lock ) + { + if (ast_pthread_mutex_lock(&chan->lock)) + { + ast_log(LOG_WARNING, "Unable to lock channel\n"); + return -1; + } + } + + if( chan->monitor ) + { + char filename[ FILENAME_MAX ]; + + if( chan->monitor->read_stream ) + { + ast_closestream( chan->monitor->read_stream ); + } + if( chan->monitor->write_stream ) + { + ast_closestream( chan->monitor->write_stream ); + } + + if( ast_fileexists( chan->monitor->read_filename, NULL, NULL ) > 0 ) + { + snprintf( filename, FILENAME_MAX, "%s-in", chan->monitor->filename_base ); + if( ast_fileexists( filename, NULL, NULL ) > 0 ) + { + ast_filedelete( filename, NULL ); + } + ast_filerename( chan->monitor->read_filename, filename, "alaw" ); + } + else + { + ast_log(LOG_WARNING, "File %s not found\n" ,chan->monitor->read_filename ); + } + + if( ast_fileexists( chan->monitor->write_filename, NULL, NULL ) > 0 ) + { + snprintf( filename, FILENAME_MAX, "%s-out", chan->monitor->filename_base ); + if( ast_fileexists( filename, NULL, NULL ) > 0 ) + { + ast_filedelete( filename, NULL ); + } + ast_filerename( chan->monitor->write_filename, filename, "alaw" ); + } + else + { + ast_log(LOG_WARNING, "File %s not found\n" ,chan->monitor->write_filename ); + } + + free( chan->monitor ); + chan->monitor = NULL; + } + + if( need_lock ) + { + ast_pthread_mutex_unlock(&chan->lock); + } + return 0; +} + +/* Change monitoring filename of a channel */ +int ast_monitor_change_fname( struct ast_channel *chan, const char *fname_base, int need_lock ) +{ + if( !fname_base ) + { + ast_log( LOG_WARNING, + "Cannot change monitor filename of channel %s to null", + chan->name ); + return -1; + } + + if( need_lock ) + { + if (ast_pthread_mutex_lock(&chan->lock)) + { + ast_log(LOG_WARNING, "Unable to lock channel\n"); + return -1; + } + } + + if( chan->monitor ) + { + snprintf( chan->monitor->filename_base, FILENAME_MAX, "%s/%s", + AST_MONITOR_DIR, fname_base ); + } + else + { + ast_log( LOG_WARNING, + "Cannot change monitor filename of channel %s to %s, monitoring not started", + chan->name, fname_base ); + + } + + if( need_lock ) + { + ast_pthread_mutex_unlock(&chan->lock); + } + return 0; +} + +static int start_monitor_exec(struct ast_channel *chan, void *data) +{ + return ast_monitor_start( chan, 1 ); +} + +static int stop_monitor_exec(struct ast_channel *chan, void *data) +{ + return ast_monitor_stop( chan, 1 ); +} + +static int change_monitor_exec(struct ast_channel *chan, void *data) +{ + return ast_monitor_change_fname( chan, (const char*)data, 1 ); +} + +static char *get_header(struct message *m, char *var) +{ + char cmp[80]; + int x; + snprintf(cmp, sizeof(cmp), "%s: ", var); + for (x=0;xhdrcount;x++) + if (!strncasecmp(cmp, m->headers[x], strlen(cmp))) + return m->headers[x] + strlen(cmp); + return ""; +} + +static void send_error(struct mansession *s, char *error) +{ + ast_pthread_mutex_lock(&s->lock); + ast_cli(s->fd, "Response: Error\r\n"); + ast_cli(s->fd, "Message: %s\r\n\r\n", error); + ast_pthread_mutex_unlock(&s->lock); +} + +static void send_response(struct mansession *s, char *resp, char *msg) +{ + ast_pthread_mutex_lock(&s->lock); + ast_cli(s->fd, "Response: %s\r\n", resp); + if (msg) + ast_cli(s->fd, "Message: %s\r\n\r\n", msg); + else + ast_cli(s->fd, "\r\n"); + ast_pthread_mutex_unlock(&s->lock); +} + +static void send_ack(struct mansession *s, char *msg) +{ + send_response(s, "Success", msg); +} + +static int start_monitor_action(struct mansession *s, struct message *m) +{ + struct ast_channel *c = NULL; + char *name = get_header(m, "Channel"); + char *fname = get_header(m, "File"); + if (!strlen(name)) { + send_error(s, "No channel specified"); + return 0; + } + c = ast_channel_walk(NULL); + while(c) { + if (!strcasecmp(c->name, name)) { + break; + } + c = ast_channel_walk(c); + } + if (!c) { + send_error(s, "No such channel"); + return 0; + } + if( ast_monitor_start( c, 1 ) ) { + send_error(s, "Could not start monitoring channel"); + return 0; + } + if (strlen(fname)) { + if( ast_monitor_change_fname( c, fname, 1 ) ) { + send_error(s, "Could not change monitored filename of channel"); + return 0; + } + } + send_ack(s, "Started monitoring channel"); + return 0; +} + +static int stop_monitor_action(struct mansession *s, struct message *m) +{ + struct ast_channel *c = NULL; + char *name = get_header(m, "Channel"); + if (!strlen(name)) { + send_error(s, "No channel specified"); + return 0; + } + c = ast_channel_walk(NULL); + while(c) { + if (!strcasecmp(c->name, name)) { + break; + } + c = ast_channel_walk(c); + } + if (!c) { + send_error(s, "No such channel"); + return 0; + } + if( ast_monitor_stop( c, 1 ) ) { + send_error(s, "Could not stop monitoring channel"); + return 0; + } + send_ack(s, "Stopped monitoring channel"); + return 0; +} + +static int change_monitor_action(struct mansession *s, struct message *m) +{ + struct ast_channel *c = NULL; + char *name = get_header(m, "Channel"); + char *fname = get_header(m, "File"); + if (!strlen(name)) { + send_error(s, "No channel specified"); + return 0; + } + if (!strlen(fname)) { + send_error(s, "No filename specified"); + return 0; + } + c = ast_channel_walk(NULL); + while(c) { + if (!strcasecmp(c->name, name)) { + break; + } + c = ast_channel_walk(c); + } + if (!c) { + send_error(s, "No such channel"); + return 0; + } + if( ast_monitor_change_fname( c, fname, 1 ) ) { + send_error(s, "Could not change monitored filename of channel"); + return 0; + } + send_ack(s, "Stopped monitoring channel"); + return 0; +} + +int load_module(void) +{ + ast_register_application( "Monitor", start_monitor_exec, monitor_synopsis, monitor_descrip ); + ast_register_application( "StopMonitor", stop_monitor_exec, stopmonitor_synopsis, stopmonitor_descrip ); + ast_register_application( "ChangeMonitor", change_monitor_exec, changemonitor_synopsis, changemonitor_descrip ); + ast_manager_register( "Monitor", EVENT_FLAG_CALL, start_monitor_action, monitor_synopsis ); + ast_manager_register( "StopMonitor", EVENT_FLAG_CALL, stop_monitor_action, stopmonitor_synopsis ); + ast_manager_register( "ChangeMonitor", EVENT_FLAG_CALL, change_monitor_action, changemonitor_synopsis ); + + return 0; +} + +int unload_module(void) +{ + ast_unregister_application( "Monitor" ); + ast_unregister_application( "StopMonitor" ); + return 0; +} + +char *description(void) +{ + return "Call Monitoring Resource"; +} + +int usecount(void) +{ + /* Never allow monitor to be unloaded because it will + unresolve needed symbols in the channel */ +#if 0 + int res; + STANDARD_USECOUNT(res); + return res; +#else + return 1; +#endif +} + +char *key() +{ + return ASTERISK_GPL_KEY; +} diff -uNr asterisk/res/res_musiconhold.c /home/mahmut/asterisk/res/res_musiconhold.c --- asterisk/res/res_musiconhold.c Wed Mar 12 12:54:04 2003 +++ /home/mahmut/asterisk/res/res_musiconhold.c Wed Mar 12 13:05:09 2003 @@ -66,6 +66,18 @@ "music on hold is activated, this class will be used to select which\n" "music is played.\n"; +#define MOH_BUFFER_SIZE 8000 /* 1 sec audio data */ +#define MOH_NUM_BUFFERS 2 + +// #define DEBUG_MOH + +struct mohbuffer { + unsigned long pos; + short buffer[ MOH_BUFFER_SIZE ]; + int data_valid; + unsigned long next; // next buffer +}; + struct mohclass { char class[80]; char dir[256]; @@ -79,13 +91,18 @@ int srcfd; /* FD for timing source */ int pseudofd; + /* Music on hold buffers */ + struct mohbuffer buffers[ MOH_NUM_BUFFERS ]; + pthread_mutex_t buffer_lock; + struct mohclass *next; }; struct mohdata { - int pipe[2]; +// int pipe[2]; int origrfmt; int origwfmt; + unsigned long pos; struct mohclass *parent; struct mohdata *next; }; @@ -170,6 +187,8 @@ } #endif if (!files) { + close(fds[0]); + close(fds[1]); ast_log(LOG_WARNING, "Found no files in '%s'\n", class->dir); return -1; } @@ -200,56 +219,180 @@ return fds[0]; } + +static int moh_fill_buffer( struct mohclass *class, unsigned int buf, unsigned long pos ) +{ + int res; + + if( ( res = read( class->srcfd, class->buffers[buf].buffer, MOH_BUFFER_SIZE * 2 ) ) + != MOH_BUFFER_SIZE * 2 ) + { + if (!res) { + close(class->srcfd); + class->srcfd = -1; + if (class->pid) { + kill(class->pid, SIGKILL); + class->pid = 0; + } + return -1; + } else { + ast_log( LOG_DEBUG, "Read %d bytes of audio while expecting %d\n", + res, MOH_BUFFER_SIZE * 2 ); + // Pad unread part with 0, this will be played out as silence. + memset( class->buffers[buf].buffer + res/2, 0, (MOH_BUFFER_SIZE - res/2)*2 ); + } + } + class->buffers[buf].pos = pos; +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, "Updated mohbuf %d to pos %ld\n", buf, class->buffers[buf].pos ); +#endif + return 0; +} + +static int moh_read_buffer( struct mohdata *moh, short *user_buf, int size ) +{ + int copied = 0; + struct mohclass *class = moh->parent; + int samples = size / 2; + if( !class ) { + return -1; + } + ast_pthread_mutex_lock( &class->buffer_lock ); + while( copied < samples ) { + int i; + int len; + int buf = -1; + short *p = NULL; + for( i = 0; i < MOH_NUM_BUFFERS; i++ ) { + if( ( class->buffers[ i ].data_valid ) + && ( moh->pos >= class->buffers[ i ].pos ) + && ( moh->pos < ( class->buffers[ i ].pos + MOH_BUFFER_SIZE ) ) ) { + buf = i; + break; + } + } +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, "moh member at pos %ld, buf %d selected\n", moh->pos, buf ); +#endif + if( buf == -1 ) { + if( copied > 0 ) { +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, + "No more data to read for moh member, copying partial audio\n" ); +#endif + break; + } else if( ( MOH_NUM_BUFFERS > 0 ) && ( class->buffers[0].data_valid ) ) { + moh->pos = class->buffers[0].pos; + buf = 0; +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, "moh member reset to pos %ld, buf %d selected\n", + moh->pos, buf ); +#endif + } else { +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, "moh buffers not initialized, not copying audio\n" ); +#endif + break; + } + } + p = class->buffers[ buf ].buffer + ( moh->pos - class->buffers[ buf ].pos ); + len = ( class->buffers[ buf ].pos + MOH_BUFFER_SIZE ) - moh->pos; + if( len > ( samples - copied ) ) { + len = ( samples - copied ); + } + memcpy( user_buf + copied, p, len * 2 ); + copied += len; + } + moh->pos += copied; +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, "moh member moved from pos %ld to %ld\n", moh->pos - copied,moh->pos ); +#endif + ast_pthread_mutex_unlock( &class->buffer_lock ); + return copied * 2; +} + static void *monmp3thread(void *data) { struct mohclass *class = data; - struct mohdata *moh; - char buf[8192]; - short sbuf[8192]; - int res, res2; + int i; signal(SIGCHLD, child_handler); for(;/* ever */;) { /* Spawn mp3 player if it's not there */ if (class->srcfd < 0) { - if ((class->srcfd = spawn_mp3(class)) < 0) { + while ((class->srcfd = spawn_mp3(class)) < 0) { ast_log(LOG_WARNING, "unable to spawn mp3player\n"); /* Try again later */ sleep(500); } } - if (class->pseudofd > -1) { - /* Pause some amount of time */ - res = read(class->pseudofd, buf, sizeof(buf)); - } else { - /* otherwise just sleep (unreliable) */ - usleep(250000); - res = 2000; - } - if (!class->members) - continue; - /* Read mp3 audio */ - if ((res2 = read(class->srcfd, sbuf, res * 2)) != res * 2) { - if (!res2) { - close(class->srcfd); - class->srcfd = -1; - if (class->pid) { - kill(class->pid, SIGKILL); - class->pid = 0; + /* Initially load the buffers. */ + for( i = 0; i < MOH_NUM_BUFFERS; i++ ) { + if( !class->buffers[i].data_valid ) { + ast_pthread_mutex_lock( &class->buffer_lock ); + if( !moh_fill_buffer( class, i, i * MOH_BUFFER_SIZE ) ) { + class->buffers[i].data_valid = 1; } - } else - ast_log(LOG_DEBUG, "Read %d bytes of audio while expecting %d\n", res2, res * 2); + ast_pthread_mutex_unlock( &class->buffer_lock ); + } + } + if (!class->members) { + // Check back again later. + usleep(250000); continue; } + // If at least one class member is in the upper half of a buffer, prepare next buffer. + // The preparation involves reading in the data for the next buffer and setting all + // members to its next buffer. + ast_pthread_mutex_lock( &class->buffer_lock ); ast_pthread_mutex_lock(&moh_lock); - moh = class->members; - while(moh) { - /* Write data */ - if ((res = write(moh->pipe[1], sbuf, res2)) != res2) - if (option_debug) - ast_log(LOG_DEBUG, "Only wrote %d of %d bytes to pipe\n", res, res2); - moh = moh->next; + for( i = 0; i < MOH_NUM_BUFFERS; i++ ) { + struct mohdata *moh = class->members; + int relocated = 0; + while(moh) { + if( ( moh->pos >= ( class->buffers[i].pos + MOH_BUFFER_SIZE /2 ) ) + && ( moh->pos < ( class->buffers[i].pos + MOH_BUFFER_SIZE ) ) ) { + // This class member is now about to reach the end of current buffer, + // prepare next buffer by reading data into the next buffer and + // relocating all members in next buffer to one next. + unsigned long next_pos = class->buffers[class->buffers[i].next].pos; + unsigned long new_pos = class->buffers[i].pos + MOH_BUFFER_SIZE; + if( ( new_pos + MOH_BUFFER_SIZE ) < new_pos ) + { +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, + "Moh buffer position is rolling over, resetting to 0\n" ); +#endif + new_pos = 0; + } + if( next_pos != new_pos ) { + if( moh_fill_buffer( class, class->buffers[i].next, new_pos ) ) { + break; + } + moh = class->members; + while(moh) { + if( (moh->pos >= next_pos) && (moh->pos < (next_pos+MOH_BUFFER_SIZE) ) ) { + moh->pos = class->buffers[class->buffers[class->buffers[i].next].next].pos; + } + moh = moh->next; + } + relocated = 1; + break; + } + } + moh = moh->next; + } + if( relocated ) { + break; + } } - pthread_mutex_unlock(&moh_lock); + ast_pthread_mutex_unlock(&moh_lock); + ast_pthread_mutex_unlock( &class->buffer_lock ); + sched_yield(); + + // Sleep to loop approximately 10 times over one buffer. + // As the format is slinear, we have 1sample/short, + // 8000 samples/sec for one buffer. + usleep( ( MOH_BUFFER_SIZE / ( 8000 * 10 ) ) * 1000 * 1000 ); } return NULL; } @@ -305,21 +448,11 @@ static struct mohdata *mohalloc(struct mohclass *cl) { struct mohdata *moh; - long flags; moh = malloc(sizeof(struct mohdata)); if (!moh) return NULL; memset(moh, 0, sizeof(struct mohdata)); - if (pipe(moh->pipe)) { - ast_log(LOG_WARNING, "Failed to create pipe: %s\n", strerror(errno)); - free(moh); - return NULL; - } - /* Make entirely non-blocking */ - flags = fcntl(moh->pipe[0], F_GETFL); - fcntl(moh->pipe[0], F_SETFL, flags | O_NONBLOCK); - flags = fcntl(moh->pipe[1], F_GETFL); - fcntl(moh->pipe[1], F_SETFL, flags | O_NONBLOCK); + moh->pos = 0; moh->parent = cl; moh->next = cl->members; cl->members = moh; @@ -346,8 +479,7 @@ cur = cur->next; } ast_pthread_mutex_unlock(&moh_lock); - close(moh->pipe[0]); - close(moh->pipe[1]); + ast_log( LOG_DEBUG, "Moh release on %s\n", chan->name ); oldrfmt = moh->origrfmt; oldwfmt = moh->origwfmt; free(moh); @@ -358,6 +490,12 @@ if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Stopped music on hold on %s\n", chan->name); } + ast_log( LOG_DEBUG, "Set format (original: %d/%d) to %d/%d on %s\n", + moh->origrfmt, moh->origwfmt, chan->readformat, chan->writeformat, + chan->name ); + fprintf( stderr, "Set format (original: %d/%d) to %d/%d on %s\n", + moh->origrfmt, moh->origwfmt, chan->readformat, chan->writeformat, + chan->name ); } static void *moh_alloc(struct ast_channel *chan, void *params) @@ -374,6 +512,8 @@ res = NULL; } ast_pthread_mutex_unlock(&moh_lock); + ast_log( LOG_DEBUG, "Moh alloc res=%p with params=<%s> on %s\n", res, (char*)params, chan->name ); + fprintf( stderr, "Moh alloc res=%p with params=<%s> on %s\n", res, (char*)params, chan->name ); if (res) { res->origrfmt = chan->readformat; res->origwfmt = chan->writeformat; @@ -386,6 +526,9 @@ moh_release(NULL, res); res = NULL; } + ast_log( LOG_DEBUG, "Set format from %d/%d to %d/%d on %s\n", + res->origrfmt, res->origwfmt, chan->readformat, chan->writeformat, + chan->name ); /* Allow writes to interrupt */ chan->writeinterrupt = 1; if (option_verbose > 2) @@ -398,18 +541,20 @@ { struct ast_frame f; struct mohdata *moh = data; - short buf[640 + AST_FRIENDLY_OFFSET / 2]; + short buf[640 + AST_FRIENDLY_OFFSET/2 ]; int res; - if (len > sizeof(buf)) { - ast_log(LOG_WARNING, "Only doing %d of %d requested bytes on %s\n", sizeof(buf), len, chan->name); - len = sizeof(buf); +#ifdef DEBUG_MOH + ast_log( LOG_DEBUG, "Moh generating len:%d samples:%d\n", len, samples ); +#endif + if (len > (sizeof(buf)-AST_FRIENDLY_OFFSET)) { + ast_log( LOG_WARNING, "Only doing %d of %d requested bytes on %s\n", + sizeof(buf)-AST_FRIENDLY_OFFSET, len, chan->name); + len = sizeof(buf)-AST_FRIENDLY_OFFSET; } - res = read(moh->pipe[0], buf + AST_FRIENDLY_OFFSET/2, len); -#if 0 + res = moh_read_buffer( moh, buf + AST_FRIENDLY_OFFSET/2, len ); if (res != len) { - ast_log(LOG_WARNING, "Read only %d of %d bytes: %s\n", res, len, strerror(errno)); + ast_log(LOG_DEBUG, "Read only %d of %d bytes: %s\n", res, len, strerror(errno)); } -#endif if (res > 0) { memset(&f, 0, sizeof(f)); f.frametype = AST_FRAME_VOICE; @@ -417,7 +562,7 @@ f.mallocd = 0; f.datalen = res; f.samples = res / 2; - f.data = buf + AST_FRIENDLY_OFFSET / 2; + f.data = buf + AST_FRIENDLY_OFFSET/2; f.offset = AST_FRIENDLY_OFFSET; if (ast_write(chan, &f)< 0) { ast_log(LOG_WARNING, "Failed to write frame to '%s': %s\n", chan->name, strerror(errno)); @@ -437,7 +582,10 @@ static int moh_register(char *classname, char *mode, char *param, char *miscargs) { struct mohclass *moh; + int i; +#ifdef ZAPATA_MOH int x; +#endif ast_pthread_mutex_lock(&moh_lock); moh = get_mohbyname(classname); ast_pthread_mutex_unlock(&moh_lock); @@ -471,15 +619,24 @@ #else moh->pseudofd = -1; #endif + for (i = 0; i < MOH_NUM_BUFFERS;i++) { + moh->buffers[i].pos = 0; + moh->buffers[i].data_valid = 0; + moh->buffers[i].next = (i + 1) % MOH_NUM_BUFFERS; + } + ast_pthread_mutex_init( &moh->buffer_lock ); + if (pthread_create(&moh->thread, NULL, monmp3thread, moh)) { ast_log(LOG_WARNING, "Unable to create moh...\n"); if (moh->pseudofd > -1) close(moh->pseudofd); + pthread_mutex_destroy( &moh->buffer_lock ); free(moh); return -1; } } else { ast_log(LOG_WARNING, "Don't know how to do a mode '%s' music on hold\n", mode); + pthread_mutex_destroy( &moh->buffer_lock ); free(moh); return -1; } @@ -561,6 +718,7 @@ int unload_module(void) { + // TODO pthread_mutex_destroy() all moh->buffer_lock's return -1; }