/* 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(ci_tail(chn), msg, len);
b_add(&chn->buf, len);
c_adv(chn, len);
chn->total += len;
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 READ_PARTIAL is updated 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. Return the
* available space or -2 if impossible.
*/
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;
}
/* 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 READ_PARTIAL is updated 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. Return the
* available space or -2 if impossible.
*/
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);
chn->total += len;
if (chn->to_forward) {
unsigned long fwd = len;
if (chn->to_forward != CHN_INFINITE_FORWARD) {
if (fwd > chn->to_forward)
fwd = chn->to_forward;
chn->to_forward -= fwd;
}
c_adv(chn, fwd);
}
/* notify that some data was read from the SI into the buffer */
chn->flags |= CF_READ_PARTIAL;
return len;
}
/* 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 READ_PARTIAL is updated 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_PARTIAL;
if (chn->to_forward >= 1) {
if (chn->to_forward != CHN_INFINITE_FORWARD)
chn->to_forward--;
c_adv(chn, 1);
}
chn->total++;
return 1;
}
