int puts(const char *s)
{
size_t len = strlen(s);
if (stream_send(STDOUT_FILENO, s, len, 0) < len)
return EOF;
if (stream_send(STDOUT_FILENO, "\n", 1, 0) < 1)
return EOF;
return 0;
}
/* Performs periodic maintenance on 'rpc', such as flushing output buffers. */
void
jsonrpc_run(struct jsonrpc *rpc)
{
if (rpc->status) {
return;
}
stream_run(rpc->stream);
while (!list_is_empty(&rpc->output)) {
struct ofpbuf *buf = ofpbuf_from_list(rpc->output.next);
int retval;
retval = stream_send(rpc->stream, buf->data, buf->size);
if (retval >= 0) {
rpc->backlog -= retval;
ofpbuf_pull(buf, retval);
if (!buf->size) {
list_remove(&buf->list_node);
rpc->output_count--;
ofpbuf_delete(buf);
}
} else {
if (retval != -EAGAIN) {
VLOG_WARN_RL(&rl, "%s: send error: %s",
rpc->name, ovs_strerror(-retval));
jsonrpc_error(rpc, -retval);
}
break;
}
}
}
static void check_telev(struct audio *a, struct autx *tx)
{
const struct sdp_format *fmt;
bool marker = false;
int err;
tx->mb->pos = tx->mb->end = STREAM_PRESZ;
err = telev_poll(a->telev, &marker, tx->mb);
if (err)
return;
if (marker)
tx->ts_tel = tx->ts;
fmt = sdp_media_rformat(stream_sdpmedia(audio_strm(a)), telev_rtpfmt);
if (!fmt)
return;
tx->mb->pos = STREAM_PRESZ;
err = stream_send(a->strm, marker, fmt->pt, tx->ts_tel, tx->mb);
if (err) {
DEBUG_WARNING("telev: stream_send %m\n", err);
}
}
/**
* Encoder audio and send via stream
*
* @note This function has REAL-TIME properties
*/
static void encode_rtp_send(struct audio *a, struct autx *tx,
int16_t *sampv, size_t sampc)
{
size_t len;
int err;
if (!tx->ac)
return;
tx->mb->pos = tx->mb->end = STREAM_PRESZ;
len = mbuf_get_space(tx->mb);
err = tx->ac->ench(tx->enc, mbuf_buf(tx->mb), &len, sampv, sampc);
if (err) {
DEBUG_WARNING("%s encode error: %d samples (%m)\n",
tx->ac->name, sampc, err);
goto out;
}
tx->mb->pos = STREAM_PRESZ;
tx->mb->end = STREAM_PRESZ + len;
if (mbuf_get_left(tx->mb)) {
err = stream_send(a->strm, tx->marker, -1, tx->ts, tx->mb);
if (err)
goto out;
}
tx->ts += (uint32_t)(tx->is_g722 ? sampc/2 : sampc);
out:
tx->marker = false;
}
int main()
{
struct stream* p_stream;
const char* stream_name = "tcp:127.0.0.1:1234";
char pnum[4];
uint8_t dscp = 1;
int actualsend = 0;
int index = 0;
while(1)
{
if(stream_open(stream_name,&p_stream,dscp))
{
printf("stream open failure!\n");
}
else
{
printf("stream open sucessed!\n");
if(stream_connect(p_stream))
{
printf("stream connect failure!\n");
}
else
{
printf("stream connect successed!\n");
sprintf(pnum,"%d",index);
actualsend = stream_send(p_stream,pnum,sizeof(pnum));
index++;
if(actualsend < 0)
printf("stream send failure!\n");
else if(actualsend == 0)
printf("stream send 0 bytes!\n");
else
printf("stream actual send %d bytes,Data:%s\n",actualsend,pnum);
}
}
stream_close(p_stream);
sleep(1);
}
return 0;
}
/**
* Encoder audio and send via stream
*
* @note This function has REAL-TIME properties
*
* @param a Audio object
* @param tx Audio transmit object
* @param sampv Audio samples
* @param sampc Number of audio samples
*/
static void encode_rtp_send(struct audio *a, struct autx *tx,
int16_t *sampv, size_t sampc)
{
size_t frame_size; /* number of samples per channel */
size_t len;
int err;
if (!tx->ac)
return;
tx->mb->pos = tx->mb->end = STREAM_PRESZ;
len = mbuf_get_space(tx->mb);
err = tx->ac->ench(tx->enc, mbuf_buf(tx->mb), &len, sampv, sampc);
if (err) {
warning("audio: %s encode error: %d samples (%m)\n",
tx->ac->name, sampc, err);
goto out;
}
tx->mb->pos = STREAM_PRESZ;
tx->mb->end = STREAM_PRESZ + len;
if (mbuf_get_left(tx->mb)) {
err = stream_send(a->strm, tx->marker, -1, tx->ts, tx->mb);
if (err)
goto out;
}
/* The RTP clock rate used for generating the RTP timestamp is
* independent of the number of channels and the encoding
*/
frame_size = (tx->is_g722 ? sampc/2 : sampc) / tx->ac->ch;
tx->ts += (uint32_t)frame_size;
out:
tx->marker = false;
}
/* Connects to a fake_pvconn with vconn_open(), accepts that connection and
* sends the 'out' bytes in 'out_size' to it (presumably an OFPT_HELLO
* message), then verifies that vconn_connect() reports
* 'expect_connect_error'. */
static void
test_send_hello(const char *type, const void *out, size_t out_size,
int expect_connect_error)
{
struct fake_pvconn fpv;
struct vconn *vconn;
bool read_hello, connected;
struct ofpbuf *msg;
struct stream *stream;
size_t n_sent;
fpv_create(type, &fpv);
CHECK_ERRNO(vconn_open(fpv.vconn_name, 0, DSCP_DEFAULT, &vconn), 0);
vconn_run(vconn);
stream = fpv_accept(&fpv);
fpv_destroy(&fpv);
n_sent = 0;
while (n_sent < out_size) {
int retval;
retval = stream_send(stream, (char *) out + n_sent, out_size - n_sent);
if (retval > 0) {
n_sent += retval;
} else if (retval == -EAGAIN) {
stream_run(stream);
vconn_run(vconn);
stream_recv_wait(stream);
vconn_connect_wait(vconn);
vconn_run_wait(vconn);
poll_block();
} else {
ovs_fatal(0, "stream_send returned unexpected value %d", retval);
}
}
read_hello = connected = false;
for (;;) {
if (!read_hello) {
struct ofp_header hello;
int retval = stream_recv(stream, &hello, sizeof hello);
if (retval == sizeof hello) {
enum ofpraw raw;
CHECK(hello.version, OFP13_VERSION);
CHECK(ofpraw_decode_partial(&raw, &hello, sizeof hello), 0);
CHECK(raw, OFPRAW_OFPT_HELLO);
CHECK(ntohs(hello.length), sizeof hello);
read_hello = true;
} else {
CHECK_ERRNO(retval, -EAGAIN);
}
}
vconn_run(vconn);
if (!connected) {
int error = vconn_connect(vconn);
if (error == expect_connect_error) {
if (!error) {
connected = true;
} else {
stream_close(stream);
vconn_close(vconn);
return;
}
} else {
CHECK_ERRNO(error, EAGAIN);
}
}
if (read_hello && connected) {
break;
}
vconn_run_wait(vconn);
if (!connected) {
vconn_connect_wait(vconn);
}
if (!read_hello) {
stream_recv_wait(stream);
}
poll_block();
}
stream_close(stream);
CHECK_ERRNO(vconn_recv_block(vconn, &msg), EOF);
vconn_close(vconn);
}