Fix crashes with ALSA e.g., when disabling BUFSZ_P2 in alsa-plugins

PR:		196051
Differential Revision:	https://reviews.freebsd.org/D1788
Submitted by:	mi
Approved by:	bapt (mentor)

2 files changed, 173 insertions, 1 deletions

diff --git a/mail/thunderbird/Makefile b/mail/thunderbird/Makefile
index 19a64522a8e..a6ffab6b53a 100644
--- a/mail/thunderbird/Makefile
+++ b/mail/thunderbird/Makefile
@@ -3,7 +3,7 @@
 
 PORTNAME=	thunderbird
 DISTVERSION=	31.4.0
-PORTREVISION=	1
+PORTREVISION=	2
 CATEGORIES=	mail news net-im ipv6
 MASTER_SITES=	MOZILLA/${PORTNAME}/releases/${DISTVERSION}/source \
 		https://ftp.mozilla.org/pub/mozilla.org/${PORTNAME}/candidates/${DISTVERSION}-candidates/build1/source/
diff --git a/mail/thunderbird/files/patch-bug1130155 b/mail/thunderbird/files/patch-bug1130155
new file mode 100644
index 00000000000..ea5b87c9c72
--- /dev/null
+++ b/mail/thunderbird/files/patch-bug1130155
@@ -0,0 +1,172 @@
+commit eab3e3a
+Author: Mikhail Teterin <mi@aldan.algebra.com>
+Date:   Tue Dec 16 19:34:02 2014 -0800
+
+    Bug 1130155 - Avoid assert failures when consuming only part of buffer.
+---
+ media/libcubeb/src/cubeb_alsa.c | 112 ++++++++++++++++++++++++++++++----------
+ 1 file changed, 85 insertions(+), 27 deletions(-)
+
+diff --git media/libcubeb/src/cubeb_alsa.c media/libcubeb/src/cubeb_alsa.c
+index 9bbc129..e72944a 100644
+--- mozilla/media/libcubeb/src/cubeb_alsa.c
++++ mozilla/media/libcubeb/src/cubeb_alsa.c
+@@ -14,6 +14,8 @@
+ #include <limits.h>
+ #include <dlfcn.h>
+ #include <poll.h>
++#include <stdlib.h>
++#include <stdio.h>
+ #include <unistd.h>
+ #include <alsa/asoundlib.h>
+ #include "cubeb/cubeb.h"
+@@ -45,6 +47,7 @@ MAKE_TYPEDEF(snd_pcm_avail_update);
+ MAKE_TYPEDEF(snd_pcm_close);
+ MAKE_TYPEDEF(snd_pcm_delay);
+ MAKE_TYPEDEF(snd_pcm_drain);
++MAKE_TYPEDEF(snd_pcm_forward);
+ MAKE_TYPEDEF(snd_pcm_frames_to_bytes);
+ MAKE_TYPEDEF(snd_pcm_get_params);
+ /* snd_pcm_hw_params_alloca is actually a macro */
+@@ -305,32 +308,35 @@ alsa_refill_stream(cubeb_stream * stm)
+   long got;
+   void * p;
+   int draining;
++  unsigned pipefailures, againfailures;
+ 
+   draining = 0;
+ 
+   pthread_mutex_lock(&stm->mutex);
+ 
+-  r = WRAP(snd_pcm_poll_descriptors_revents)(stm->pcm, stm->fds, stm->nfds, &revents);
+-  if (r < 0 || revents != POLLOUT) {
+-    /* This should be a stream error; it makes no sense for poll(2) to wake
+-       for this stream and then have the stream report that it's not ready.
+-       Unfortunately, this does happen, so just bail out and try again. */
+-    pthread_mutex_unlock(&stm->mutex);
+-    return RUNNING;
+-  }
++  for (pipefailures = 0;;) {
++    r = WRAP(snd_pcm_poll_descriptors_revents)(stm->pcm, stm->fds, stm->nfds, &revents);
++    if (r < 0 || revents != POLLOUT ||
++      (avail = WRAP(snd_pcm_avail_update)(stm->pcm)) == 0) {
++      /* This should be a stream error; it makes no sense for poll(2) to wake
++         for this stream and then have the stream report that it's not ready.
++         Unfortunately, this does happen, so just bail out and try again. */
++      pthread_mutex_unlock(&stm->mutex);
++      return RUNNING;
++    }
+ 
+-  avail = WRAP(snd_pcm_avail_update)(stm->pcm);
+-  if (avail == -EPIPE) {
++    if (avail > 0)
++      break;
++    if (pipefailures++ > 11) {
++      fprintf(stderr, "%s: repeated failures from snd_pcm_avail_update, "
++              "giving up\n", __func__);
++      pthread_mutex_unlock(&stm->mutex);
++      stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
++      return ERROR;
++    }
+     WRAP(snd_pcm_recover)(stm->pcm, avail, 1);
+-    avail = WRAP(snd_pcm_avail_update)(stm->pcm);
+-  }
+-
+-  /* Failed to recover from an xrun, this stream must be broken. */
+-  if (avail < 0) {
+-    pthread_mutex_unlock(&stm->mutex);
+-    stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
+-    return ERROR;
+   }
++  pipefailures = againfailures = 0;
+ 
+   /* This should never happen. */
+   if ((unsigned int) avail > stm->buffer_size) {
+@@ -355,17 +361,67 @@ alsa_refill_stream(cubeb_stream * stm)
+   if (got < 0) {
+     pthread_mutex_unlock(&stm->mutex);
+     stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
++    free(p);
+     return ERROR;
+   }
+   if (got > 0) {
+-    snd_pcm_sframes_t wrote = WRAP(snd_pcm_writei)(stm->pcm, p, got);
+-    if (wrote == -EPIPE) {
+-      WRAP(snd_pcm_recover)(stm->pcm, wrote, 1);
+-      wrote = WRAP(snd_pcm_writei)(stm->pcm, p, got);
+-    }
+-    assert(wrote >= 0 && wrote == got);
+-    stm->write_position += wrote;
+-    gettimeofday(&stm->last_activity, NULL);
++    snd_pcm_sframes_t wrote, towrite = got;
++    for (;;) {
++      wrote = WRAP(snd_pcm_writei)(stm->pcm, p,
++        towrite > avail ? avail : towrite);
++      switch(wrote) {
++      case -EPIPE:
++        if (pipefailures++ > 3) {
++          fprintf(stderr, "%s: Too many underflows, giving up\n", __func__);
++          stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
++          pthread_mutex_unlock(&stm->mutex);
++          free(p);
++          return ERROR;
++        }
++        WRAP(snd_pcm_recover)(stm->pcm, wrote, 1);
++        continue;
++      case -EAGAIN:
++        if (againfailures++ > 3) {
++          fprintf(stderr, "%s: Too many -EAGAIN errors from snd_pcm_writei, "
++	    "giving up\n", __func__);
++          stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
++          pthread_mutex_unlock(&stm->mutex);
++          free(p);
++          return ERROR;
++        }
++        continue;
++      case -EBADFD:
++        fprintf(stderr, "%s: snc_pcm_writei returned -%s, giving up\n",
++                __func__, "EBADFD");
++        free(p);
++        stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
++        pthread_mutex_unlock(&stm->mutex);
++        return ERROR;
++      }
++      if (wrote < 0) {
++        fprintf(stderr, "%s: snc_pcm_writei returned unexpected error %lld, "
++                "giving up\n", __func__, (long long)wrote);
++        free(p);
++        stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
++        pthread_mutex_unlock(&stm->mutex);
++        return ERROR;
++      }
++      pipefailures = againfailures = 0;
++      stm->write_position += wrote;
++      gettimeofday(&stm->last_activity, NULL);
++      if (wrote > towrite) {
++        fprintf(stderr, "%s: snc_pcm_writei wrote %lld frames, which was more "
++	        "than we requested (%lld). This should not happen, giving up\n",
++                __func__, (long long)wrote, (long long)towrite);
++        free(p);
++        stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
++        pthread_mutex_unlock(&stm->mutex);
++        return ERROR;
++      }
++      if (towrite == wrote)
++        break;
++      towrite -= wrote;
++    }
+   }
+   if (got != avail) {
+     long buffer_fill = stm->buffer_size - (avail - got);
+@@ -1177,7 +1232,10 @@ alsa_stream_get_position(cubeb_stream * stm, uint64_t * position)
+     return CUBEB_OK;
+   }
+ 
+-  assert(delay >= 0);
++  if (delay < 0) {
++    WRAP(snd_pcm_forward)(stm->pcm, -delay);
++    delay = 0;
++  }
+ 
+   *position = 0;
+   if (stm->write_position >= (snd_pcm_uframes_t) delay) {