static struct jsonrpc *
open_jsonrpc(const char *server)
{
struct stream *stream;
int error;
error = stream_open_block(jsonrpc_stream_open(server, &stream,
DSCP_DEFAULT), &stream);
if (error == EAFNOSUPPORT) {
struct pstream *pstream;
error = jsonrpc_pstream_open(server, &pstream, DSCP_DEFAULT);
if (error) {
ovs_fatal(error, "failed to connect or listen to \"%s\"", server);
}
VLOG_INFO("%s: waiting for connection...", server);
error = pstream_accept_block(pstream, &stream);
if (error) {
ovs_fatal(error, "failed to accept connection on \"%s\"", server);
}
pstream_close(pstream);
} else if (error) {
ovs_fatal(error, "failed to connect to \"%s\"", server);
}
return jsonrpc_open(stream);
}
void
jsonrpc_session_close(struct jsonrpc_session *s)
{
if (s) {
jsonrpc_close(s->rpc);
reconnect_destroy(s->reconnect);
stream_close(s->stream);
pstream_close(s->pstream);
free(s);
}
}
/* Sets the DSCP value used for 's''s connection to 'dscp'. If this is
* different from the DSCP value currently in use then the connection is closed
* and reconnected. */
void
jsonrpc_session_set_dscp(struct jsonrpc_session *s, uint8_t dscp)
{
if (s->dscp != dscp) {
pstream_close(s->pstream);
s->pstream = NULL;
s->dscp = dscp;
jsonrpc_session_force_reconnect(s);
}
}
int main()
{
struct pstream* p_pstream;
struct stream* p_stream;
const char* pstream_name = "ptcp:1234";
char buffer[50];
uint8_t dscp = 1;
int actualrecv = 0;
if(pstream_open(pstream_name,&p_pstream,dscp))
printf("pstream open failure!\n");
else
{
while(1)
{
while(pstream_accept(p_pstream, &p_stream))
;
printf("\nget one steam connect success!\n");
printf("p_pstream name:%s\n", pstream_get_name(p_pstream));
printf("p_pstream bound_port:%d\n", pstream_get_bound_port(p_pstream));
printf("p_stream name:%s\n", stream_get_name(p_stream));
printf("<remote_ip,remote_port> : <%d,%d>\n", stream_get_remote_ip(p_stream),stream_get_remote_port(p_stream));
printf("<local_ip,local_port> : <%d,%d>\n", stream_get_local_ip(p_stream),stream_get_local_port(p_stream));
actualrecv = stream_recv(p_stream,buffer,sizeof(buffer));
if(actualrecv < 0)
printf("pstream receive failure!\n");
else if(actualrecv == 0)
printf("pstream receive 0 bytes!\n");
else
printf("pstream actual receive %d bytes,buffer:%s\n\n",actualrecv,buffer);
}
stream_close(p_stream);
pstream_close(p_pstream);
}
return 0;
}
static void
fpv_close(struct fake_pvconn *fpv)
{
pstream_close(fpv->pstream);
fpv->pstream = NULL;
}
void
jsonrpc_session_run(struct jsonrpc_session *s)
{
if (s->pstream) {
struct stream *stream;
int error;
error = pstream_accept(s->pstream, &stream);
if (!error) {
if (s->rpc || s->stream) {
VLOG_INFO_RL(&rl,
"%s: new connection replacing active connection",
reconnect_get_name(s->reconnect));
jsonrpc_session_disconnect(s);
}
reconnect_connected(s->reconnect, time_msec());
s->rpc = jsonrpc_open(stream);
} else if (error != EAGAIN) {
reconnect_listen_error(s->reconnect, time_msec(), error);
pstream_close(s->pstream);
s->pstream = NULL;
}
}
if (s->rpc) {
size_t backlog;
int error;
backlog = jsonrpc_get_backlog(s->rpc);
jsonrpc_run(s->rpc);
if (jsonrpc_get_backlog(s->rpc) < backlog) {
/* Data previously caught in a queue was successfully sent (or
* there's an error, which we'll catch below.)
*
* We don't count data that is successfully sent immediately as
* activity, because there's a lot of queuing downstream from us,
* which means that we can push a lot of data into a connection
* that has stalled and won't ever recover.
*/
reconnect_activity(s->reconnect, time_msec());
}
error = jsonrpc_get_status(s->rpc);
if (error) {
reconnect_disconnected(s->reconnect, time_msec(), error);
jsonrpc_session_disconnect(s);
s->last_error = error;
}
} else if (s->stream) {
int error;
stream_run(s->stream);
error = stream_connect(s->stream);
if (!error) {
reconnect_connected(s->reconnect, time_msec());
s->rpc = jsonrpc_open(s->stream);
s->stream = NULL;
} else if (error != EAGAIN) {
reconnect_connect_failed(s->reconnect, time_msec(), error);
stream_close(s->stream);
s->stream = NULL;
s->last_error = error;
}
}
switch (reconnect_run(s->reconnect, time_msec())) {
case RECONNECT_CONNECT:
jsonrpc_session_connect(s);
break;
case RECONNECT_DISCONNECT:
reconnect_disconnected(s->reconnect, time_msec(), 0);
jsonrpc_session_disconnect(s);
break;
case RECONNECT_PROBE:
if (s->rpc) {
struct json *params;
struct jsonrpc_msg *request;
params = json_array_create_empty();
request = jsonrpc_create_request("echo", params, NULL);
json_destroy(request->id);
request->id = json_string_create("echo");
jsonrpc_send(s->rpc, request);
}
break;
}
}
static void
do_listen(struct ovs_cmdl_context *ctx)
{
struct pstream *pstream;
struct jsonrpc **rpcs;
size_t n_rpcs, allocated_rpcs;
bool done;
int error;
error = jsonrpc_pstream_open(ctx->argv[1], &pstream, DSCP_DEFAULT);
if (error) {
ovs_fatal(error, "could not listen on \"%s\"", ctx->argv[1]);
}
daemonize();
rpcs = NULL;
n_rpcs = allocated_rpcs = 0;
done = false;
for (;;) {
struct stream *stream;
size_t i;
/* Accept new connections. */
error = pstream_accept(pstream, &stream);
if (!error) {
if (n_rpcs >= allocated_rpcs) {
rpcs = x2nrealloc(rpcs, &allocated_rpcs, sizeof *rpcs);
}
rpcs[n_rpcs++] = jsonrpc_open(stream);
} else if (error != EAGAIN) {
ovs_fatal(error, "pstream_accept failed");
}
/* Service existing connections. */
for (i = 0; i < n_rpcs; ) {
struct jsonrpc *rpc = rpcs[i];
struct jsonrpc_msg *msg;
jsonrpc_run(rpc);
if (!jsonrpc_get_backlog(rpc)) {
error = jsonrpc_recv(rpc, &msg);
if (!error) {
error = handle_rpc(rpc, msg, &done);
jsonrpc_msg_destroy(msg);
} else if (error == EAGAIN) {
error = 0;
}
}
if (!error) {
error = jsonrpc_get_status(rpc);
}
if (error) {
jsonrpc_close(rpc);
ovs_error(error, "connection closed");
memmove(&rpcs[i], &rpcs[i + 1],
(n_rpcs - i - 1) * sizeof *rpcs);
n_rpcs--;
} else {
i++;
}
}
/* Wait for something to do. */
if (done && !n_rpcs) {
break;
}
pstream_wait(pstream);
for (i = 0; i < n_rpcs; i++) {
struct jsonrpc *rpc = rpcs[i];
jsonrpc_wait(rpc);
if (!jsonrpc_get_backlog(rpc)) {
jsonrpc_recv_wait(rpc);
}
}
poll_block();
}
free(rpcs);
pstream_close(pstream);
}
void
jsonrpc_session_run(struct jsonrpc_session *s)
{
if (s->pstream) {
struct stream *stream;
int error;
error = pstream_accept(s->pstream, &stream);
if (!error) {
if (s->rpc || s->stream) {
VLOG_INFO_RL(&rl,
"%s: new connection replacing active connection",
reconnect_get_name(s->reconnect));
jsonrpc_session_disconnect(s);
}
reconnect_connected(s->reconnect, time_msec());
s->rpc = jsonrpc_open(stream);
} else if (error != EAGAIN) {
reconnect_listen_error(s->reconnect, time_msec(), error);
pstream_close(s->pstream);
s->pstream = NULL;
}
}
if (s->rpc) {
int error;
jsonrpc_run(s->rpc);
error = jsonrpc_get_status(s->rpc);
if (error) {
reconnect_disconnected(s->reconnect, time_msec(), error);
jsonrpc_session_disconnect(s);
}
} else if (s->stream) {
int error;
stream_run(s->stream);
error = stream_connect(s->stream);
if (!error) {
reconnect_connected(s->reconnect, time_msec());
s->rpc = jsonrpc_open(s->stream);
s->stream = NULL;
} else if (error != EAGAIN) {
reconnect_connect_failed(s->reconnect, time_msec(), error);
stream_close(s->stream);
s->stream = NULL;
}
}
switch (reconnect_run(s->reconnect, time_msec())) {
case RECONNECT_CONNECT:
jsonrpc_session_connect(s);
break;
case RECONNECT_DISCONNECT:
reconnect_disconnected(s->reconnect, time_msec(), 0);
jsonrpc_session_disconnect(s);
break;
case RECONNECT_PROBE:
if (s->rpc) {
struct json *params;
struct jsonrpc_msg *request;
params = json_array_create_empty();
request = jsonrpc_create_request("echo", params, NULL);
json_destroy(request->id);
request->id = json_string_create("echo");
jsonrpc_send(s->rpc, request);
}
break;
}
}