int packet_fxp_fsetstat(Buffer *buff, Buffer *preped_buff) {
    u_int msg_len;
    u_int xmsg_len;
    
    // File names
    u_int file_len;
    u_char *handle;
    
    // Copy first part of packet over to prepared buffer
    msg_len = get_u32(buffer_ptr(buff));
    xmsg_len = msg_len;
    
    buffer_append(preped_buff, buffer_ptr(buff), 9);
    buffer_consume(buff, 9);
    xmsg_len -= 5;
    
    // Copy handle
    handle = buffer_get_string(buff, &file_len);
    buffer_put_string(preped_buff, (char*) handle, file_len);
    xmsg_len -= (file_len + 4);
    
    // Copy attributes through, cleaning extensions where required
    parse_attrs(buff, preped_buff, &msg_len, &xmsg_len);
    
    // Copy any remaining packet data over
    buffer_append(preped_buff, buffer_ptr(buff), xmsg_len);
    buffer_consume(buff, xmsg_len);
    
    // Rewrite message length
    put_u32(buffer_end(preped_buff)-msg_len-4, msg_len);
    
    return 1;
}

void
_parse_aiff_comm(Buffer *buf, uint32_t chunk_size, HV *info)
{
  uint16_t channels = buffer_get_short(buf);
  uint32_t frames = buffer_get_int(buf);
  uint16_t bits_per_sample = buffer_get_short(buf);
  double samplerate = buffer_get_ieee_float(buf);
  
  my_hv_store( info, "channels", newSVuv(channels) );
  my_hv_store( info, "bits_per_sample", newSVuv(bits_per_sample) );
  my_hv_store( info, "samplerate", newSVuv(samplerate) );
  
  my_hv_store( info, "bitrate", newSVuv( samplerate * channels * bits_per_sample ) );
  my_hv_store( info, "song_length_ms", newSVuv( ((frames * 1.0) / samplerate) * 1000 ) );
  my_hv_store( info, "block_align", newSVuv( channels * bits_per_sample / 8 ) );
  
  if (chunk_size > 18) {
    // AIFC extra data
    my_hv_store( info, "compression_type", newSVpvn( buffer_ptr(buf), 4 ) );
    buffer_consume(buf, 4);
    
    my_hv_store( info, "compression_name", newSVpvn( buffer_ptr(buf), chunk_size - 22 ) );
    buffer_consume(buf, chunk_size - 22);
  }
}

uint16_t packet_peek_session_id(uint8_t *data, size_t length)
{
  buffer_t *buffer = NULL;
  uint16_t session_id = -1;

  /* Create a buffer of the first 5 bytes. */
  if(length < 5)
  {
    LOG_FATAL("Packet is too short!\n");
    return -1;
  }

  /* Create a buffer with the first 5 bytes of data. */
  buffer = buffer_create_with_data(BO_BIG_ENDIAN, data, 5);

  /* Discard packet_id. */
  buffer_consume(buffer, 2);

  /* Discard packet_type. */
  buffer_consume(buffer, 1);

  /* Finally, get the session_id. */
  session_id = buffer_read_next_int16(buffer);

  /* Kill the buffer. */
  buffer_destroy(buffer);

  /* Done! */
  return session_id;
}

static Key *
keygrab_ssh1(con *c)
{
    static Key *rsa;
    static Buffer msg;

    if (rsa == NULL) {
        buffer_init(&msg);
        rsa = key_new(KEY_RSA1);
    }
    buffer_append(&msg, c->c_data, c->c_plen);
    buffer_consume(&msg, 8 - (c->c_plen & 7));	/* padding */
    if (buffer_get_char(&msg) != (int) SSH_SMSG_PUBLIC_KEY) {
        error("%s: invalid packet type", c->c_name);
        buffer_clear(&msg);
        return NULL;
    }
    buffer_consume(&msg, 8);		/* cookie */

    /* server key */
    (void) buffer_get_int(&msg);
    buffer_get_bignum(&msg, rsa->rsa->e);
    buffer_get_bignum(&msg, rsa->rsa->n);

    /* host key */
    (void) buffer_get_int(&msg);
    buffer_get_bignum(&msg, rsa->rsa->e);
    buffer_get_bignum(&msg, rsa->rsa->n);

    buffer_clear(&msg);

    return (rsa);
}

int packet_fxp_realpath(Buffer *buff, Buffer *preped_buff) {
    u_int msg_len, xmsg_len;
    u_int file_len;
    u_char *filename;
      
     // Copy first part of packet over to prepared buffer
    msg_len = get_u32(buffer_ptr(buff));
    xmsg_len = msg_len;
    
    buffer_append(preped_buff, buffer_ptr(buff), 9);
    buffer_consume(buff, 9);
    xmsg_len -= 5;
    
    // Rewrite path
    filename = buffer_get_string(buff, &file_len);
    filename = unchroot_filename(filename, (u_char*) user_homedir);
    buffer_put_cstring(preped_buff, (char*) filename);
    xmsg_len -= (file_len + 4);
    msg_len += (strlen((char*) filename) - file_len);
    
    // Copy packet over to prepared buffer
    buffer_append(preped_buff, buffer_ptr(buff), xmsg_len);
    buffer_consume(buff, xmsg_len);
    
    // Replace length with new length
    put_u32(buffer_end(preped_buff)-msg_len-4, msg_len);
    
    return 1;
}

int packet_fxp_mkdir(Buffer *buff, Buffer *preped_buff) {
    u_int msg_len;
    u_int xmsg_len;
    
    // File names
    u_int file_len;
    u_char *filename;
    
    // Copy first part of packet over to prepared buffer
    msg_len = get_u32(buffer_ptr(buff));
    xmsg_len = msg_len;
    
    buffer_append(preped_buff, buffer_ptr(buff), 9);
    buffer_consume(buff, 9);
    xmsg_len -= 5;
    
    // Rewrite path
    filename = buffer_get_string(buff, &file_len);
    filename = unchroot_filename(filename, (u_char*) user_homedir);
    buffer_put_cstring(preped_buff, (char*) filename);
    xmsg_len -= (file_len + 4);
    msg_len += (strlen((char*) filename) - file_len);
    
    // Copy attributes through, cleaning extensions where required
    parse_attrs(buff, preped_buff, &msg_len, &xmsg_len);
    
    // Copy any remaining packet data over
    buffer_append(preped_buff, buffer_ptr(buff), xmsg_len);
    buffer_consume(buff, xmsg_len);
    
    // Rewrite message length
    put_u32(buffer_end(preped_buff)-msg_len-4, msg_len);
    
    return 1;
}

int read_and_callback(struct reader *rdr, void *arg)
{
	ssize_t ret;
	ssize_t i;
	char *cur;
	int msglen;

	cur = rdr->buf->data + rdr->buf->used;

	/* Read attempt. */
	while ((ret = read(*(rdr->fd), cur, buffer_remaining(rdr->buf))) == -1 &&
	       errno == EINTR)
		;

	/* EOF or read error. */
	if (ret == 0 || ret == -1)
		return ret;

	assert(buffer_append(rdr->buf, cur, ret) == 0);

	/* Process each read character and update internal state. */
	for (i = 0; i < ret; ++i) {
		switch (rdr->state) {
		case RS_NORMAL:
			if (*cur == '\n') {
				/* Callback on new message. */
				msglen = cur - rdr->buf->data + 1;
				if (msglen > 2)
					/* Nonempty message. */
					rdr->cb(*(rdr->fd), rdr->buf->data, msglen, arg);

				/* Consume message. */
				buffer_consume(rdr->buf, msglen);
				cur = rdr->buf->data;
				continue;
			}
			break;
		case RS_GREEDY:
			if (*cur == '\n') {
				buffer_consume(rdr->buf, cur - rdr->buf->data + 1);
				cur = rdr->buf->data;
				rdr->state = RS_NORMAL;
				continue;
			}
			break;
		}
		++cur;
	}

	/* Change to greedy mode if buffer filled. */
	if (buffer_remaining(rdr->buf) == 0 && rdr->state != RS_GREEDY)
		rdr->state = RS_GREEDY;

	/* Discard buffer data if in greedy mode. */
	if (rdr->state == RS_GREEDY)
		buffer_consume(rdr->buf, -1);

	return ret;
}

static int methodline_parse(struct buffer *bu, struct methodline_state *ms,
	struct buffer *method, struct buffer *uri, struct buffer *version)
{
	const char *s = bu->data;
	unsigned rem = bu->cur;
	char ch;

	while (rem > 0) {
		ch = *s;
		s++;
		rem--;

		switch (ms->state) {
		case 0: /* method */
			if (ch == ' ')
				ms->state = 1;
			else
				buffer_addch(method, ch);
			break;
		case 1: /* uri */
			if (ch == ' ')
				ms->state = 2;
			else
				buffer_addch(uri, ch);
			break;
		case 2: /* version */
			if (ch == '\r')
				ms->state = 3;
			else if (isspace(ch))
				goto parse_error;
			else
				buffer_addch(version, ch);
			break;
		case 3: /* CR */
			if (ch == '\n')
				goto complete;
			else
				goto parse_error;
			break;
		default:
			assert(0);
		}
	}

	buffer_consume(bu, s - bu->data);
	return 0;
complete:
	ms->done = true;
	buffer_consume(bu, s - bu->data);
	return 0;
parse_error:
	Error("%s():parse failure (%.*s)\n",
		__func__, bu->cur, bu->data);
	buffer_consume(bu, s - bu->data);
	Error("%s():parse failure @ %d (state=%d)\n",
		__func__, bu->cur, ms->state);
	return -1;
}

// Parses body. Returns true iff progress was made.
bool frameparser_parse_body(frameparser *fp, buffer *b)
{
  log_printf(LOG_LEVEL_DEBUG, "frameparser_parse_body\n");

  if (fp->length_left == FP_LENGTH_UNKNOWN)
  {
    // Look for NUL terminator
    int nulpos = buffer_find_byte(b, '\x00');
    if (nulpos < 0)
    {
      // No NUL, so grab everything
      int count = buffer_get_length(b);
      bytestring *body = frame_ensure_body(fp->cur_frame);
      buffer_append_bytestring(b, body, 0, count);
      buffer_consume(b, count);
      return true;
    }
    else if (nulpos == 0)
    {
      // NUL as next character, so the frame is complete
      fp->state = FP_STATE_END;
      return true;
    }
    else
    {
      // NUL after some other bytes, so grab them and the frame is complete
      bytestring *body = frame_ensure_body(fp->cur_frame);
      buffer_append_bytestring(b, body, 0, nulpos);
      buffer_consume(b, nulpos);
      fp->state = FP_STATE_END;
      return true;
    }
  }
  else
  {
    // Remaining length is known. Figure out how many bytes to grab.
    int count = buffer_get_length(b);
    if (fp->length_left < count)
      count = fp->length_left;

    // Grab the bytes
    bytestring *body = frame_ensure_body(fp->cur_frame);
    buffer_append_bytestring(b, body, 0, count);
    buffer_consume(b, count);
    fp->length_left -= count;

    // If we satisfied the expected length then the frame is complete
    if (fp->length_left == 0)
      fp->state = FP_STATE_END;

    return true;
  }
}

int packet_fxp_init(Buffer *buff, Buffer *preped_buff) {
    u_char *cp;
    u_int msg_len;
    u_int xmsg_len;
    u_int msg_ver;
    
    cp = buffer_ptr(buff);
    
    // 1. Ensure  extensions are not forwarded. Drop packet size down to 5 bytes + 4 byte length. Later byte are ignored through buffer_consume.
    msg_len = get_u32(cp);
    xmsg_len = 5;
    put_u32(cp, xmsg_len);
    
    // 2. Ensure client version number presented is not greater than that supported.
    cp += 5;
    msg_ver = get_u32(cp);
    if (msg_ver > 3)
	msg_ver = 3;
    
    put_u32(cp, msg_ver);
    
    // Copy packet over to prepared buffer
    buffer_append(preped_buff, buffer_ptr(buff), xmsg_len + sizeof(u_int));
    buffer_consume(buff, msg_len + sizeof(u_int));
    
    return 1;
}

static boolean buf_src_fill_input_buffer(j_decompress_ptr cinfo) {
  static JOCTET mybuffer[4];
  buf_src_mgr *src = (buf_src_mgr *)cinfo->src;

  // Consume the entire buffer, even if bytes are still in bytes_in_buffer
  buffer_consume(src->buf, buffer_len(src->buf));

  if (!buffer_check_load(src->buf, src->fp, 1, BUF_SIZE))
    goto eof;

  cinfo->src->next_input_byte = (JOCTET *)buffer_ptr(src->buf);
  cinfo->src->bytes_in_buffer = buffer_len(src->buf);

  goto ok;

eof:
  // Insert a fake EOI marker if we can't read enough data
  LOG_DEBUG("  EOF filling input buffer, returning EOI marker\n");

  mybuffer[0] = (JOCTET)0xFF;
  mybuffer[1] = (JOCTET)JPEG_EOI;

  cinfo->src->next_input_byte = mybuffer;
  cinfo->src->bytes_in_buffer = 2;

ok:
  return TRUE;
}

static int
monitor_valid_userblob(u_char *data, u_int datalen)
{
	Buffer b;
	u_char *p;
	char *userstyle, *cp;
	u_int len;
	int fail = 0;

	buffer_init(&b);
	buffer_append(&b, data, datalen);

	if (datafellows & SSH_OLD_SESSIONID) {
		p = buffer_ptr(&b);
		len = buffer_len(&b);
		if ((session_id2 == NULL) ||
		    (len < session_id2_len) ||
		    (timingsafe_bcmp(p, session_id2, session_id2_len) != 0))
			fail++;
		buffer_consume(&b, session_id2_len);
	} else {
		p = buffer_get_string(&b, &len);
		if ((session_id2 == NULL) ||
		    (len != session_id2_len) ||
		    (timingsafe_bcmp(p, session_id2, session_id2_len) != 0))
			fail++;
		free(p);
	}
	if (buffer_get_char(&b) != SSH2_MSG_USERAUTH_REQUEST)
		fail++;
	cp = buffer_get_cstring(&b, NULL);
	xasprintf(&userstyle, "%s%s%s", authctxt->user,
	    authctxt->style ? ":" : "",
	    authctxt->style ? authctxt->style : "");
	if (strcmp(userstyle, cp) != 0) {
		logit("wrong user name passed to monitor: "
		    "expected %s != %.100s", userstyle, cp);
		fail++;
	}
	free(userstyle);
	free(cp);
	buffer_skip_string(&b);
	if (datafellows & SSH_BUG_PKAUTH) {
		if (!buffer_get_char(&b))
			fail++;
	} else {
		cp = buffer_get_cstring(&b, NULL);
		if (strcmp("publickey", cp) != 0)
			fail++;
		free(cp);
		if (!buffer_get_char(&b))
			fail++;
		buffer_skip_string(&b);
	}
	buffer_skip_string(&b);
	if (buffer_len(&b) != 0)
		fail++;
	buffer_free(&b);
	return (fail == 0);
}

// Parses trailing NUL character. Returns true iff progress was made.
bool frameparser_parse_end(frameparser *fp, buffer *b)
{
  // Valid input in this state is simply a single NUL character
  log_printf(LOG_LEVEL_DEBUG, "frameparser_parse_end\n");

  // If there is already a parsed frame that hasn't been picked up yet, we
  //  don't want to overwrite it, so refrain from finishing this frame.
  if (fp->fin_frame)
    return false;  // No progress

  // Check for the NUL
  uint8_t byte = buffer_get_byte(b, 0);
  if (byte != '\x00')
  {
    frameparser_set_error(fp, "Expected trailing NUL at end of frame");
    return false;
  }

  // Consume it
  buffer_consume(b, 1);

  // All done with the current frame
  fp->fin_frame = fp->cur_frame;
  fp->cur_frame = NULL;
  fp->state = FP_STATE_IDLE;

  return true;
}

void SFTP::send_msg(Buffer *m)
{
	size_t mlen = buffer_len(m);

  toChannel->put (buffer_ptr (m), mlen);
	buffer_consume(m, mlen);
}

static int
image_gif_read_buf(GifFileType *gif, GifByteType *data, int len)
{
  image *im = (image *)gif->UserData;

  //DEBUG_TRACE("GIF read_buf wants %d bytes, %d in buffer\n", len, buffer_len(im->buf));

  if (im->fh != NULL) {
    if ( !_check_buf(im->fh, im->buf, len, MAX(len, BUFFER_SIZE)) ) {
      warn("Image::Scale not enough GIF data (%s)\n", SvPVX(im->path));
      return 0;
    }
  }
  else {
    if (len > buffer_len(im->buf)) {
      // read from SV into buffer
      int sv_readlen = len - buffer_len(im->buf);

      if (sv_readlen > sv_len(im->sv_data) - im->sv_offset) {
        warn("Image::Scale not enough GIF data (%s)\n", SvPVX(im->path));
        return 0;
      }

      DEBUG_TRACE("  Reading %d bytes of SV data @ %d\n", sv_readlen, im->sv_offset);
      buffer_append(im->buf, SvPVX(im->sv_data) + im->sv_offset, sv_readlen);
      im->sv_offset += sv_readlen;
     }
  }

  memcpy(data, buffer_ptr(im->buf), len);
  buffer_consume(im->buf, len);

  return len;
}

void *consumer_function(void *b)
{
  buffer *buff = (buffer *)b;

  int i;
  for (i = 0; i < 100; i++)
    {
      pthread_mutex_lock(buff->mut);
      if(buff->empty)
	{
	  printf("buffer empty, waiting...\n");
	  pthread_cond_wait(buff->notEmpty, buff->mut);
	}

      int consumed = buffer_consume(buff);

      printf("consumed %d\n", consumed);

      pthread_mutex_unlock(buff->mut);

      /* Sleep either 1s or 5s (50% chance for each) */
      if (generate_random_number(99) < 50)
	{
	  usleep(1000000);
	}
      else
	{
	  usleep(5000000);
	}
    }

  return NULL;
}

static void
_parse_wav_peak(ScanData s, Buffer *buf, uint32_t chunk_size, uint8_t big_endian)
{
  uint16_t channels  = 0;
  AV *peaklist = newAV();
  
  SV **entry = my_hv_fetch( info, "channels" );
  if ( entry != NULL ) {
    channels = SvIV(*entry);
  }
  
  // Skip version/timestamp
  buffer_consume(buf, 8);
  
  while ( channels-- ) {
    HV *peak = newHV();
    
    my_hv_store( peak, "value", newSVnv( big_endian ? buffer_get_float32(buf) : buffer_get_float32_le(buf) ) );
    my_hv_store( peak, "position", newSVuv( big_endian ? buffer_get_int(buf) : buffer_get_int_le(buf) ) );
    
    av_push( peaklist, newRV_noinc( (SV *)peak) );
  }
  
  my_hv_store( info, "peak", newRV_noinc( (SV *)peaklist ) );
}

/* scans forward to the next aac frame and makes sure
 * the entire frame is in the buffer.
 */
static int buffer_fill_frame(struct aac_data *data)
{
	unsigned char *datap;
	int rc, n, len;
	int max = 32768;

	while (1) {
		/* need at least 6 bytes of data */
		rc = buffer_fill_min(data, 6);
		if (rc <= 0)
			break;

		len = buffer_length(data);
		datap = buffer_data(data);

		/* scan for a frame */
		for (n = 0; n < len - 5; n++) {
			/* give up after 32KB */
			if (max-- == 0) {
				logit ("no frame found!");
				/* FIXME: set errno? */
				return -1;
			}

			/* see if there's a frame at this location */
			rc = parse_frame(datap + n);
			if (rc == 0)
				continue;

			/* found a frame, consume all data up to the frame */
			buffer_consume (data, n);

			/* rc == frame length */
			rc = buffer_fill_min (data, rc);
			if (rc <= 0)
				goto end;

			return 1;
		}

		/* consume what we used */
		buffer_consume (data, n);
	}

end:
	return rc;
}

void buffer_add(bufferADT buffer, char c) {
	if(buffer_is_full(buffer)) {
		buffer_consume(buffer);
	}
	
	buffer->mem_start[buffer->head] = c;
	buffer->head = buffer_next_index(buffer, buffer->head);
}

char *
octstr_drop(octstr_t *octstr, size_t n)
{
	assert(octstr != NULL);

	buffer_consume(octstr->buf, n);
	return buffer_ptr(octstr->buf);
}