X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fstream.c;h=ac0cdb8f376656e70c08329f0db5b9a3557e58cd;hb=06036898849974797cf49c76a56fc6e10461d37d;hp=ed497d693300c9bfba3511700ee78552ee2231a5;hpb=26ad129e69fc7c800630dbd541dc2dcc8150c3a4;p=openvswitch diff --git a/lib/stream.c b/lib/stream.c index ed497d69..ac0cdb8f 100644 --- a/lib/stream.c +++ b/lib/stream.c @@ -25,6 +25,7 @@ #include #include "coverage.h" #include "dynamic-string.h" +#include "fatal-signal.h" #include "flow.h" #include "ofp-print.h" #include "ofpbuf.h" @@ -34,10 +35,10 @@ #include "poll-loop.h" #include "random.h" #include "util.h" - -#define THIS_MODULE VLM_stream #include "vlog.h" +VLOG_DEFINE_THIS_MODULE(stream) + /* State of an active stream.*/ enum stream_state { SCS_CONNECTING, /* Underlying stream is not connected. */ @@ -222,21 +223,33 @@ error: return error; } +/* Blocks until a previously started stream connection attempt succeeds or + * fails. 'error' should be the value returned by stream_open() and 'streamp' + * should point to the stream pointer set by stream_open(). Returns 0 if + * successful, otherwise a positive errno value other than EAGAIN or + * EINPROGRESS. If successful, leaves '*streamp' untouched; on error, closes + * '*streamp' and sets '*streamp' to null. + * + * Typical usage: + * error = stream_open_block(stream_open("tcp:1.2.3.4:5", &stream), &stream); + */ int -stream_open_block(const char *name, struct stream **streamp) +stream_open_block(int error, struct stream **streamp) { - struct stream *stream; - int error; + struct stream *stream = *streamp; - error = stream_open(name, &stream); - while (error == EAGAIN) { - stream_run(stream); - stream_run_wait(stream); - stream_connect_wait(stream); - poll_block(); - error = stream_connect(stream); + fatal_signal_run(); + + if (!error) { + while ((error = stream_connect(stream)) == EAGAIN) { + stream_run(stream); + stream_run_wait(stream); + stream_connect_wait(stream); + poll_block(); + } assert(error != EINPROGRESS); } + if (error) { stream_close(stream); *streamp = NULL; @@ -310,10 +323,10 @@ scs_connecting(struct stream *stream) } } -/* Tries to complete the connection on 'stream', which must be an active - * stream. If 'stream''s connection is complete, returns 0 if the connection - * was successful or a positive errno value if it failed. If the - * connection is still in progress, returns EAGAIN. */ +/* Tries to complete the connection on 'stream'. If 'stream''s connection is + * complete, returns 0 if the connection was successful or a positive errno + * value if it failed. If the connection is still in progress, returns + * EAGAIN. */ int stream_connect(struct stream *stream) { @@ -562,6 +575,7 @@ pstream_accept_block(struct pstream *pstream, struct stream **new_stream) { int error; + fatal_signal_run(); while ((error = pstream_accept(pstream, new_stream)) == EAGAIN) { pstream_wait(pstream); poll_block(); @@ -639,3 +653,133 @@ pstream_init(struct pstream *pstream, struct pstream_class *class, pstream->class = class; pstream->name = xstrdup(name); } + +static int +count_fields(const char *s_) +{ + char *s, *field, *save_ptr; + int n = 0; + + save_ptr = NULL; + s = xstrdup(s_); + for (field = strtok_r(s, ":", &save_ptr); field != NULL; + field = strtok_r(NULL, ":", &save_ptr)) { + n++; + } + free(s); + + return n; +} + +/* Like stream_open(), but for tcp streams the port defaults to + * 'default_tcp_port' if no port number is given and for SSL streams the port + * defaults to 'default_ssl_port' if no port number is given. */ +int +stream_open_with_default_ports(const char *name_, + uint16_t default_tcp_port, + uint16_t default_ssl_port, + struct stream **streamp) +{ + char *name; + int error; + + if (!strncmp(name_, "tcp:", 4) && count_fields(name_) < 3) { + name = xasprintf("%s:%d", name_, default_tcp_port); + } else if (!strncmp(name_, "ssl:", 4) && count_fields(name_) < 3) { + name = xasprintf("%s:%d", name_, default_ssl_port); + } else { + name = xstrdup(name_); + } + error = stream_open(name, streamp); + free(name); + + return error; +} + +/* Like pstream_open(), but for ptcp streams the port defaults to + * 'default_ptcp_port' if no port number is given and for passive SSL streams + * the port defaults to 'default_pssl_port' if no port number is given. */ +int +pstream_open_with_default_ports(const char *name_, + uint16_t default_ptcp_port, + uint16_t default_pssl_port, + struct pstream **pstreamp) +{ + char *name; + int error; + + if (!strncmp(name_, "ptcp:", 5) && count_fields(name_) < 2) { + name = xasprintf("%s%d", name_, default_ptcp_port); + } else if (!strncmp(name_, "pssl:", 5) && count_fields(name_) < 2) { + name = xasprintf("%s%d", name_, default_pssl_port); + } else { + name = xstrdup(name_); + } + error = pstream_open(name, pstreamp); + free(name); + + return error; +} + +/* Attempts to guess the content type of a stream whose first few bytes were + * the 'size' bytes of 'data'. */ +static enum stream_content_type +stream_guess_content(const uint8_t *data, size_t size) +{ + if (size >= 2) { +#define PAIR(A, B) (((A) << 8) | (B)) + switch (PAIR(data[0], data[1])) { + case PAIR(0x16, 0x03): /* Handshake, version 3. */ + return STREAM_SSL; + case PAIR('{', '"'): + return STREAM_JSONRPC; + case PAIR(OFP_VERSION, OFPT_HELLO): + return STREAM_OPENFLOW; + } + } + + return STREAM_UNKNOWN; +} + +/* Returns a string represenation of 'type'. */ +static const char * +stream_content_type_to_string(enum stream_content_type type) +{ + switch (type) { + case STREAM_UNKNOWN: + default: + return "unknown"; + + case STREAM_JSONRPC: + return "JSON-RPC"; + + case STREAM_OPENFLOW: + return "OpenFlow"; + + case STREAM_SSL: + return "SSL"; + } +} + +/* Attempts to guess the content type of a stream whose first few bytes were + * the 'size' bytes of 'data'. If this is done successfully, and the guessed + * content type is other than 'expected_type', then log a message in vlog + * module 'module', naming 'stream_name' as the source, explaining what + * content was expected and what was actually received. */ +void +stream_report_content(const void *data, size_t size, + enum stream_content_type expected_type, + struct vlog_module *module, const char *stream_name) +{ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5); + enum stream_content_type actual_type; + + actual_type = stream_guess_content(data, size); + if (actual_type != expected_type && actual_type != STREAM_UNKNOWN) { + vlog_rate_limit(module, VLL_WARN, &rl, + "%s: received %s data on %s channel", + stream_name, + stream_content_type_to_string(expected_type), + stream_content_type_to_string(actual_type)); + } +}