/*

 * Channel management functions.

 *

 * Copyright 2000-2014 Willy Tarreau <w@1wt.eu>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version

 * 2 of the License, or (at your option) any later version.

 *

 */

#include <ctype.h>

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

#include <haproxy/api.h>

#include <haproxy/buf.h>

#include <haproxy/channel.h>

/* Schedule up to <bytes> more bytes to be forwarded via the channel without

 * notifying the owner task. Any data pending in the buffer are scheduled to be

 * sent as well, within the limit of the number of bytes to forward. This must

 * be the only method to use to schedule bytes to be forwarded. If the requested

 * number is too large, it is automatically adjusted. The number of bytes taken

 * into account is returned. Directly touching ->to_forward will cause lockups

 * when buf->o goes down to zero if nobody is ready to push the remaining data.

 */

unsigned long long __channel_forward(struct channel *chn, unsigned long long bytes)

{

  unsigned int budget;

  unsigned int forwarded;

  /* This is more of a safety measure as it's not supposed to happen in

   * regular code paths.

   */

  if (unlikely(chn->to_forward == CHN_INFINITE_FORWARD)) {

    c_adv(chn, ci_data(chn));

    return bytes;

  }

  /* Bound the transferred size to a 32-bit count since all our values

   * are 32-bit, and we don't want to reach CHN_INFINITE_FORWARD.

   */

  budget = MIN(bytes, CHN_INFINITE_FORWARD - 1);

  /* transfer as much as we can of buf->i */

  forwarded = MIN(ci_data(chn), budget);

  c_adv(chn, forwarded);

  budget -= forwarded;

  if (!budget)

    return forwarded;

  /* Now we must ensure chn->to_forward stays below CHN_INFINITE_FORWARD,

   * which also implies it won't overflow. It's less operations in 64-bit.

   */

  bytes = (unsigned long long)chn->to_forward + budget;

  if (bytes >= CHN_INFINITE_FORWARD)

    bytes = CHN_INFINITE_FORWARD - 1;

  budget = bytes - chn->to_forward;

  chn->to_forward += budget;

  forwarded += budget;

  return forwarded;

}

/* writes <len> bytes from message <msg> to the channel's buffer. Returns -1 in

 * case of success, -2 if the message is larger than the buffer size, or the

 * number of bytes available otherwise. The send limit is automatically

 * adjusted to the amount of data written. FIXME-20060521: handle unaligned

 * data. Note: this function appends data to the buffer's output and possibly

 * overwrites any pending input data which are assumed not to exist.

 */

int co_inject(struct channel *chn, const char *msg, int len)

{

  int max;

  if (len == 0)

    return -1;

  if (len < 0 || len > c_size(chn)) {

    /* we can't write this chunk and will never be able to, because

     * it is larger than the buffer. This must be reported as an

     * error. Then we return -2 so that writers that don't care can

     * ignore it and go on, and others can check for this value.

     */

    return -2;

  }

  c_realign_if_empty(chn);

  max = b_contig_space(&chn->buf);

  if (len > max)

    return max;

  memcpy(co_tail(chn), msg, len);

  b_add(&chn->buf, len);

  c_adv(chn, len);

  return -1;

}

/* Tries to copy character <c> into the channel's buffer after some length

 * controls. The chn->o and to_forward pointers are updated. If the channel

 * input is closed, -2 is returned. If there is not enough room left in the

 * buffer, -1 is returned. Otherwise the number of bytes copied is returned

 * (1). Channel flag CF_READ_EVENT is set if some data can be transferred.

 */

int ci_putchr(struct channel *chn, char c)

{

  if (unlikely(channel_input_closed(chn)))

    return -2;

  if (!channel_may_recv(chn))

    return -1;

  *ci_tail(chn) = c;

  b_add(&chn->buf, 1);

  chn->flags |= CF_READ_EVENT;

  if (chn->to_forward >= 1) {

    if (chn->to_forward != CHN_INFINITE_FORWARD)

      chn->to_forward--;

    c_adv(chn, 1);

  }

  return 1;

}

/* Tries to copy block <blk> at once into the channel's buffer after length

 * controls. The chn->o and to_forward pointers are updated. If the channel

 * input is closed, -2 is returned. If the block is too large for this buffer,

 * -3 is returned. If there is not enough room left in the buffer, -1 is

 * returned. Otherwise the number of bytes copied is returned (0 being a valid

 * number). Channel flag CF_READ_EVENT is set if some data can be

 * transferred.

 */

int ci_putblk(struct channel *chn, const char *blk, int len)

{

  int max;

  if (unlikely(channel_input_closed(chn)))

    return -2;

  if (len < 0)

    return -3;

  max = channel_recv_limit(chn);

  if (unlikely(len > max - c_data(chn))) {

    /* we can't write this chunk right now because the buffer is

     * almost full or because the block is too large. Returns

     * -3 if block is too large for this buffer. Or -1 if the

     * room left is not large enough.

     */

    if (len > max)

      return -3;

    return -1;

  }

  if (unlikely(len == 0))

    return 0;

  /* OK so the data fits in the buffer in one or two blocks */

  max = b_contig_space(&chn->buf);

  memcpy(ci_tail(chn), blk, MIN(len, max));

  if (len > max)

    memcpy(c_orig(chn), blk + max, len - max);

  b_add(&chn->buf, len);

  channel_add_input(chn, len);

  return len;

}

/* Locates the longest part of the channel's output buffer that is composed

 * exclusively of characters not in the <delim> set, and delimited by one of

 * these characters, and returns the initial part and the first of such

 * delimiters. A single escape character in <escape> may be specified so that

 * when not 0 and found, the character that follows it is never taken as a

 * delimiter. Note that <delim> cannot contain the zero byte, hence this

 * function is not usable with byte zero as a delimiter.

 *

 * Return values :

 *   >0 : number of bytes read. Includes the sep if present before len or end.

 *   =0 : no sep before end found. <str> is left undefined.

 *   <0 : no more bytes readable because output is shut.

 * The channel status is not changed. The caller must call co_skip() to

 * update it. One of the delimiters is waited for as long as neither the buffer

 * nor the output are full. If either of them is full, the string may be

 * returned as is, without the delimiter.

 */

int co_getdelim(const struct channel *chn, char *str, int len, const char *delim, char escape)

{

  uchar delim_map[256 / 8];

  int found, escaped;

  uint pos, bit;

  int ret, max;

  uchar b;

  char *p;

  ret = 0;

  max = len;

  /* closed or empty + imminent close = -1; empty = 0 */

  if (unlikely((chn_cons(chn)->flags & SC_FL_SHUT_DONE) || !co_data(chn))) {

    if (chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED))

      ret = -1;

    goto out;

  }

  p = co_head(chn);

  if (max > co_data(chn)) {

    max = co_data(chn);

    str[max-1] = 0;

  }

  /* create the byte map */

  memset(delim_map, 0, sizeof(delim_map));

  while ((b = *delim)) {

    pos = b >> 3;

    bit = b &  7;

    delim_map[pos] |= 1 << bit;

    delim++;

  }

  found = escaped = 0;

  while (max) {

    *str++ = b = *p;

    ret++;

    max--;

    if (escape && (escaped || *p == escape)) {

      escaped = !escaped;

      goto skip;

    }

    pos = b >> 3;

    bit = b &  7;

    if (delim_map[pos] & (1 << bit)) {

      found = 1;

      break;

    }

  skip:

    p = b_next(&chn->buf, p);

  }

  if (ret > 0 && ret < len &&

      (ret < co_data(chn) || channel_may_recv(chn)) &&

      !found &&

      !(chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED)))

    ret = 0;

 out:

  if (max)

    *str = 0;

  return ret;

}

/* Gets one text word out of a channel's buffer from a stream connector.

 * Return values :

 *   >0 : number of bytes read. Includes the sep if present before len or end.

 *   =0 : no sep before end found. <str> is left undefined.

 *   <0 : no more bytes readable because output is shut.

 * The channel status is not changed. The caller must call co_skip() to

 * update it. The line separator is waited for as long as neither the buffer

 * nor the output are full. If either of them is full, the string may be

 * returned as is, without the line separator.

 */

int co_getword(const struct channel *chn, char *str, int len, char sep)

{

  int ret, max;

  char *p;

  ret = 0;

  max = len;

  /* closed or empty + imminent close = -1; empty = 0 */

  if (unlikely((chn_cons(chn)->flags & SC_FL_SHUT_DONE) || !co_data(chn))) {

    if (chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED))

      ret = -1;

    goto out;

  }

  p = co_head(chn);

  if (max > co_data(chn)) {

    max = co_data(chn);

    str[max-1] = 0;

  }

  while (max) {

    *str++ = *p;

    ret++;

    max--;

    if (*p == sep)

      break;

    p = b_next(&chn->buf, p);

  }

  if (ret > 0 && ret < len &&

      (ret < co_data(chn) || channel_may_recv(chn)) &&

      *(str-1) != sep &&

      !(chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED)))

    ret = 0;

 out:

  if (max)

    *str = 0;

  return ret;

}

/* Gets one text line out of a channel's buffer from a stream connector.

 * Return values :

 *   >0 : number of bytes read. Includes the \n if present before len or end.

 *   =0 : no '\n' before end found. <str> is left undefined.

 *   <0 : no more bytes readable because output is shut.

 * The channel status is not changed. The caller must call co_skip() to

 * update it. The '\n' is waited for as long as neither the buffer nor the

 * output are full. If either of them is full, the string may be returned

 * as is, without the '\n'.

 */

int co_getline(const struct channel *chn, char *str, int len)

{

  int ret, max;

  size_t ofs;

  ret = 0;

  max = len;

  /* closed or empty + imminent close = -1; empty = 0 */

  if (unlikely((chn_cons(chn)->flags & SC_FL_SHUT_DONE) || !co_data(chn))) {

    if (chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED))

      ret = -1;

    goto out;

  }

  if (max > co_data(chn)) {

    max = co_data(chn);

    str[max-1] = 0;

  }

  ofs = 0;

  while (max) {

    size_t contig = b_contig_data(&chn->buf, ofs);

    size_t len = MIN(max, contig);

    const char *beg = b_peek(&chn->buf, ofs);

    const char *lf = memchr(beg, '\n', len);

    if (lf) /* take the LF with it before stopping */

      len = lf + 1 - beg;

    memcpy(str, beg, len);

    ret += len;

    str += len;

    ofs += len;

    max -= len;

    if (lf)

      break;

  }

  if (ret > 0 && ret < len &&

      (ret < co_data(chn) || channel_may_recv(chn)) &&

      *(str-1) != '\n' &&

      !(chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED)))

    ret = 0;

 out:

  if (max)

    *str = 0;

  return ret;

}

/* Gets one char of data from a channel's buffer,

 * Return values :

 *    1 : number of bytes read, equal to requested size.

 *   =0 : not enough data available. <c> is left undefined.

 *   <0 : no more bytes readable because output is shut.

 * The channel status is not changed. The caller must call co_skip() to

 * update it.

 */

int co_getchar(const struct channel *chn, char *c)

{

  if (chn_cons(chn)->flags & SC_FL_SHUT_DONE)

    return -1;

  if (unlikely(co_data(chn) == 0)) {

    if (chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED))

      return -1;

    return 0;

  }

  *c = *(co_head(chn));

  return 1;

}

/* Gets one full block of data at once from a channel's buffer, optionally from

 * a specific offset. Return values :

 *   >0 : number of bytes read, equal to requested size.

 *   =0 : not enough data available. <blk> is left undefined.

 *   <0 : no more bytes readable because output is shut.

 * The channel status is not changed. The caller must call co_skip() to

 * update it.

 */

int co_getblk(const struct channel *chn, char *blk, int len, int offset)

{

  if (chn_cons(chn)->flags & SC_FL_SHUT_DONE)

    return -1;

  if (len + offset > co_data(chn) || co_data(chn) == 0) {

    if (chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED))

      return -1;

    return 0;

  }

  return b_getblk(&chn->buf, blk, len, offset);

}

/* Gets one or two blocks of data at once from a channel's output buffer.

 * Return values :

 *   >0 : number of blocks filled (1 or 2). blk1 is always filled before blk2.

 *   =0 : not enough data available. <blk*> are left undefined.

 *   <0 : no more bytes readable because output is shut.

 * The channel status is not changed. The caller must call co_skip() to

 * update it. Unused buffers are left in an undefined state.

 */

int co_getblk_nc(const struct channel *chn, const char **blk1, size_t *len1, const char **blk2, size_t *len2)

{

  if (unlikely(co_data(chn) == 0)) {

    if (chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED))

      return -1;

    return 0;

  }

  return b_getblk_nc(&chn->buf, blk1, len1, blk2, len2, 0, co_data(chn));

}

/* Gets one text line out of a channel's output buffer from a stream connector.

 * Return values :

 *   >0 : number of blocks returned (1 or 2). blk1 is always filled before blk2.

 *   =0 : not enough data available.

 *   <0 : no more bytes readable because output is shut.

 * The '\n' is waited for as long as neither the buffer nor the output are

 * full. If either of them is full, the string may be returned as is, without

 * the '\n'. Unused buffers are left in an undefined state.

 */

int co_getline_nc(const struct channel *chn,

                  const char **blk1, size_t *len1,

                  const char **blk2, size_t *len2)

{

  int retcode;

  int l;

  retcode = co_getblk_nc(chn, blk1, len1, blk2, len2);

  if (unlikely(retcode <= 0))

    return retcode;

  for (l = 0; l < *len1 && (*blk1)[l] != '\n'; l++);

  if (l < *len1 && (*blk1)[l] == '\n') {

    *len1 = l + 1;

    return 1;

  }

  if (retcode >= 2) {

    for (l = 0; l < *len2 && (*blk2)[l] != '\n'; l++);

    if (l < *len2 && (*blk2)[l] == '\n') {

      *len2 = l + 1;

      return 2;

    }

  }

  if (chn_cons(chn)->flags & (SC_FL_SHUT_DONE|SC_FL_SHUT_WANTED)) {

    /* If we have found no LF and the buffer is shut, then

     * the resulting string is made of the concatenation of

     * the pending blocks (1 or 2).

     */

    return retcode;

  }

  /* No LF yet and not shut yet */

  return 0;

}

/* Gets one full block of data at once from a channel's input buffer.

 * This function can return the data slitted in one or two blocks.

 * Return values :

 *   >0 : number of blocks returned (1 or 2). blk1 is always filled before blk2.

 *   =0 : not enough data available.

 *   <0 : no more bytes readable because input is shut.

 */

int ci_getblk_nc(const struct channel *chn,

                 char **blk1, size_t *len1,

                 char **blk2, size_t *len2)

{

  if (unlikely(ci_data(chn) == 0)) {

    if (chn_prod(chn)->flags & (SC_FL_EOS|SC_FL_ABRT_DONE))

      return -1;

    return 0;

  }

  if (unlikely(ci_head(chn) + ci_data(chn) > c_wrap(chn))) {

    *blk1 = ci_head(chn);

    *len1 = c_wrap(chn) - ci_head(chn);

    *blk2 = c_orig(chn);

    *len2 = ci_data(chn) - *len1;

    return 2;

  }

  *blk1 = ci_head(chn);

  *len1 = ci_data(chn);

  return 1;

}

/* Gets one text line out of a channel's input buffer from a stream connector.

 * Return values :

 *   >0 : number of blocks returned (1 or 2). blk1 is always filled before blk2.

 *   =0 : not enough data available.

 *   <0 : no more bytes readable because output is shut.

 * The '\n' is waited for as long as neither the buffer nor the input are

 * full. If either of them is full, the string may be returned as is, without

 * the '\n'. Unused buffers are left in an undefined state.

 */

int ci_getline_nc(const struct channel *chn,

                  char **blk1, size_t *len1,

                  char **blk2, size_t *len2)

{

  int retcode;

  int l;

  retcode = ci_getblk_nc(chn, blk1, len1, blk2, len2);

  if (unlikely(retcode <= 0))

    return retcode;

  for (l = 0; l < *len1 && (*blk1)[l] != '\n'; l++);

  if (l < *len1 && (*blk1)[l] == '\n') {

    *len1 = l + 1;

    return 1;

  }

  if (retcode >= 2) {

    for (l = 0; l < *len2 && (*blk2)[l] != '\n'; l++);

    if (l < *len2 && (*blk2)[l] == '\n') {

      *len2 = l + 1;

      return 2;

    }

  }

  if (chn_cons(chn)->flags & SC_FL_SHUT_DONE) {

    /* If we have found no LF and the buffer is shut, then

     * the resulting string is made of the concatenation of

     * the pending blocks (1 or 2).

     */

    return retcode;

  }

  /* No LF yet and not shut yet */

  return 0;

}

/* Inserts <str> at position <pos> relative to channel <c>'s  * input head. The

 * <len> argument informs about the length of string <str> so that we don't have

 * to measure it. <str> must be a valid pointer.

 *

 * The number of bytes added is returned on success. 0 is returned on failure.

 */

int ci_insert(struct channel *c, int pos, const char *str, int len)

{

  struct buffer *b = &c->buf;

  char *dst = c_ptr(c, pos);

  if (__b_tail(b) + len >= b_wrap(b))

    return 0;  /* no space left */

  if (b_data(b) &&

      b_tail(b) + len > b_head(b) &&

      b_head(b) >= b_tail(b))

    return 0;  /* no space left before wrapping data */

  /* first, protect the end of the buffer */

  memmove(dst + len, dst, b_tail(b) - dst);

  /* now, copy str over dst */

  memcpy(dst, str, len);

  b_add(b, len);

  return len;

}

/* Inserts <str> followed by "\r\n" at position <pos> relative to channel <c>'s

 * input head. The <len> argument informs about the length of string <str> so

 * that we don't have to measure it. <str> must be a valid pointer and must not

 * include the trailing "\r\n".

 *

 * The number of bytes added is returned on success. 0 is returned on failure.

 */

int ci_insert_line2(struct channel *c, int pos, const char *str, int len)

{

  struct buffer *b = &c->buf;

  char *dst = c_ptr(c, pos);

  int delta;

  delta = len + 2;

  if (__b_tail(b) + delta >= b_wrap(b))

    return 0;  /* no space left */

  if (b_data(b) &&

      b_tail(b) + delta > b_head(b) &&

      b_head(b) >= b_tail(b))

    return 0;  /* no space left before wrapping data */

  /* first, protect the end of the buffer */

  memmove(dst + delta, dst, b_tail(b) - dst);

  /* now, copy str over dst */

  memcpy(dst, str, len);

  dst[len] = '\r';

  dst[len + 1] = '\n';

  b_add(b, delta);

  return delta;

}

/*

 * Local variables:

 *  c-indent-level: 8

 *  c-basic-offset: 8

 * End:

 */