X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fstream.c;h=217191cabd700666cfe6cacf8d38593994d72fce;hb=d0a46cb4608e632f5028034762f0adde2ce947a0;hp=066de4e8772488697e8b87509f99c268df03ab8d;hpb=87ea5e5e26c97598cd66ef64c8386afac2b77fff;p=cascardo%2Fovs.git diff --git a/lib/stream.c b/lib/stream.c index 066de4e87..217191cab 100644 --- a/lib/stream.c +++ b/lib/stream.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2015 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,6 @@ #include #include "stream-provider.h" -#include #include #include #include @@ -27,15 +26,18 @@ #include "dynamic-string.h" #include "fatal-signal.h" #include "flow.h" +#include "jsonrpc.h" #include "ofp-print.h" #include "ofpbuf.h" #include "openflow/nicira-ext.h" #include "openflow/openflow.h" +#include "ovs-thread.h" #include "packets.h" #include "poll-loop.h" #include "random.h" +#include "socket-util.h" #include "util.h" -#include "vlog.h" +#include "openvswitch/vlog.h" VLOG_DEFINE_THIS_MODULE(stream); @@ -51,7 +53,11 @@ enum stream_state { static const struct stream_class *stream_classes[] = { &tcp_stream_class, +#ifndef _WIN32 &unix_stream_class, +#else + &windows_stream_class, +#endif #ifdef HAVE_OPENSSL &ssl_stream_class, #endif @@ -59,7 +65,11 @@ static const struct stream_class *stream_classes[] = { static const struct pstream_class *pstream_classes[] = { &ptcp_pstream_class, +#ifndef _WIN32 &punix_pstream_class, +#else + &pwindows_pstream_class, +#endif #ifdef HAVE_OPENSSL &pssl_pstream_class, #endif @@ -74,14 +84,14 @@ check_stream_classes(void) for (i = 0; i < ARRAY_SIZE(stream_classes); i++) { const struct stream_class *class = stream_classes[i]; - assert(class->name != NULL); - assert(class->open != NULL); + ovs_assert(class->name != NULL); + ovs_assert(class->open != NULL); if (class->close || class->recv || class->send || class->run || class->run_wait || class->wait) { - assert(class->close != NULL); - assert(class->recv != NULL); - assert(class->send != NULL); - assert(class->wait != NULL); + ovs_assert(class->close != NULL); + ovs_assert(class->recv != NULL); + ovs_assert(class->send != NULL); + ovs_assert(class->wait != NULL); } else { /* This class delegates to another one. */ } @@ -89,12 +99,12 @@ check_stream_classes(void) for (i = 0; i < ARRAY_SIZE(pstream_classes); i++) { const struct pstream_class *class = pstream_classes[i]; - assert(class->name != NULL); - assert(class->listen != NULL); + ovs_assert(class->name != NULL); + ovs_assert(class->listen != NULL); if (class->close || class->accept || class->wait) { - assert(class->close != NULL); - assert(class->accept != NULL); - assert(class->wait != NULL); + ovs_assert(class->close != NULL); + ovs_assert(class->accept != NULL); + ovs_assert(class->wait != NULL); } else { /* This class delegates to another one. */ } @@ -194,7 +204,7 @@ stream_verify_name(const char *name) * stores a pointer to the new connection in '*streamp', otherwise a null * pointer. */ int -stream_open(const char *name, struct stream **streamp) +stream_open(const char *name, struct stream **streamp, uint8_t dscp) { const struct stream_class *class; struct stream *stream; @@ -211,7 +221,7 @@ stream_open(const char *name, struct stream **streamp) /* Call class's "open" function. */ suffix_copy = xstrdup(strchr(name, ':') + 1); - error = class->open(name, suffix_copy, &stream); + error = class->open(name, suffix_copy, &stream, dscp); free(suffix_copy); if (error) { goto error; @@ -250,7 +260,7 @@ stream_open_block(int error, struct stream **streamp) stream_connect_wait(stream); poll_block(); } - assert(error != EINPROGRESS); + ovs_assert(error != EINPROGRESS); } if (error) { @@ -281,43 +291,11 @@ stream_get_name(const struct stream *stream) return stream ? stream->name : "(null)"; } -/* Returns the IP address of the peer, or 0 if the peer is not connected over - * an IP-based protocol or if its IP address is not yet known. */ -ovs_be32 -stream_get_remote_ip(const struct stream *stream) -{ - return stream->remote_ip; -} - -/* Returns the transport port of the peer, or 0 if the connection does not - * contain a port or if the port is not yet known. */ -ovs_be16 -stream_get_remote_port(const struct stream *stream) -{ - return stream->remote_port; -} - -/* Returns the IP address used to connect to the peer, or 0 if the connection - * is not an IP-based protocol or if its IP address is not yet known. */ -ovs_be32 -stream_get_local_ip(const struct stream *stream) -{ - return stream->local_ip; -} - -/* Returns the transport port used to connect to the peer, or 0 if the - * connection does not contain a port or if the port is not yet known. */ -ovs_be16 -stream_get_local_port(const struct stream *stream) -{ - return stream->local_port; -} - static void scs_connecting(struct stream *stream) { int retval = (stream->class->connect)(stream); - assert(retval != EINPROGRESS); + ovs_assert(retval != EINPROGRESS); if (!retval) { stream->state = SCS_CONNECTED; } else if (retval != EAGAIN) { @@ -349,7 +327,7 @@ stream_connect(struct stream *stream) return stream->error; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } while (stream->state != last_state); @@ -419,8 +397,8 @@ stream_run_wait(struct stream *stream) void stream_wait(struct stream *stream, enum stream_wait_type wait) { - assert(wait == STREAM_CONNECT || wait == STREAM_RECV - || wait == STREAM_SEND); + ovs_assert(wait == STREAM_CONNECT || wait == STREAM_RECV + || wait == STREAM_SEND); switch (stream->state) { case SCS_CONNECTING: @@ -489,6 +467,25 @@ pstream_verify_name(const char *name) return pstream_lookup_class(name, &class); } +/* Returns 1 if the stream or pstream specified by 'name' needs periodic probes + * to verify connectivity. For [p]streams which need probes, it can take a + * long time to notice the connection has been dropped. Returns 0 if the + * stream or pstream does not need probes, and -1 if 'name' is not valid. */ +int +stream_or_pstream_needs_probes(const char *name) +{ + const struct pstream_class *pclass; + const struct stream_class *class; + + if (!stream_lookup_class(name, &class)) { + return class->needs_probes; + } else if (!pstream_lookup_class(name, &pclass)) { + return pclass->needs_probes; + } else { + return -1; + } +} + /* Attempts to start listening for remote stream connections. 'name' is a * connection name in the form "TYPE:ARGS", where TYPE is an passive stream * class's name and ARGS are stream class-specific. @@ -497,7 +494,7 @@ pstream_verify_name(const char *name) * stores a pointer to the new connection in '*pstreamp', otherwise a null * pointer. */ int -pstream_open(const char *name, struct pstream **pstreamp) +pstream_open(const char *name, struct pstream **pstreamp, uint8_t dscp) { const struct pstream_class *class; struct pstream *pstream; @@ -514,7 +511,7 @@ pstream_open(const char *name, struct pstream **pstreamp) /* Call class's "open" function. */ suffix_copy = xstrdup(strchr(name, ':') + 1); - error = class->listen(name, suffix_copy, &pstream); + error = class->listen(name, suffix_copy, &pstream, dscp); free(suffix_copy); if (error) { goto error; @@ -561,8 +558,8 @@ pstream_accept(struct pstream *pstream, struct stream **new_stream) if (retval) { *new_stream = NULL; } else { - assert((*new_stream)->state != SCS_CONNECTING - || (*new_stream)->class->connect); + ovs_assert((*new_stream)->state != SCS_CONNECTING + || (*new_stream)->class->connect); } return retval; } @@ -594,6 +591,14 @@ pstream_wait(struct pstream *pstream) { (pstream->class->wait)(pstream); } + +/* Returns the transport port on which 'pstream' is listening, or 0 if the + * concept doesn't apply. */ +ovs_be16 +pstream_get_bound_port(const struct pstream *pstream) +{ + return pstream->bound_port; +} /* Initializes 'stream' as a new stream named 'name', implemented via 'class'. * The initial connection status, supplied as 'connect_status', is interpreted @@ -623,40 +628,23 @@ stream_init(struct stream *stream, const struct stream_class *class, : SCS_DISCONNECTED); stream->error = connect_status; stream->name = xstrdup(name); - assert(stream->state != SCS_CONNECTING || class->connect); -} - -void -stream_set_remote_ip(struct stream *stream, ovs_be32 ip) -{ - stream->remote_ip = ip; -} - -void -stream_set_remote_port(struct stream *stream, ovs_be16 port) -{ - stream->remote_port = port; -} - -void -stream_set_local_ip(struct stream *stream, ovs_be32 ip) -{ - stream->local_ip = ip; -} - -void -stream_set_local_port(struct stream *stream, ovs_be16 port) -{ - stream->local_port = port; + ovs_assert(stream->state != SCS_CONNECTING || class->connect); } void pstream_init(struct pstream *pstream, const struct pstream_class *class, const char *name) { + memset(pstream, 0, sizeof *pstream); pstream->class = class; pstream->name = xstrdup(name); } + +void +pstream_set_bound_port(struct pstream *pstream, ovs_be16 port) +{ + pstream->bound_port = port; +} static int count_fields(const char *s_) @@ -675,51 +663,56 @@ count_fields(const char *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. */ +/* Like stream_open(), but the port defaults to 'default_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) +stream_open_with_default_port(const char *name_, + uint16_t default_port, + struct stream **streamp, + uint8_t dscp) { 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); + if ((!strncmp(name_, "tcp:", 4) || !strncmp(name_, "ssl:", 4)) + && count_fields(name_) < 3) { + if (default_port == OFP_PORT) { + VLOG_WARN_ONCE("The default OpenFlow port number has changed " + "from %d to %d", + OFP_OLD_PORT, OFP_PORT); + } else if (default_port == OVSDB_PORT) { + VLOG_WARN_ONCE("The default OVSDB port number has changed " + "from %d to %d", + OVSDB_OLD_PORT, OVSDB_PORT); + } + name = xasprintf("%s:%d", name_, default_port); } else { name = xstrdup(name_); } - error = stream_open(name, streamp); + error = stream_open(name, streamp, dscp); 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. */ +/* Like pstream_open(), but port defaults to 'default_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) +pstream_open_with_default_port(const char *name_, + uint16_t default_port, + struct pstream **pstreamp, + uint8_t dscp) { 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); + if ((!strncmp(name_, "ptcp:", 5) || !strncmp(name_, "pssl:", 5)) + && count_fields(name_) < 2) { + name = xasprintf("%s%d", name_, default_port); } else { name = xstrdup(name_); } - error = pstream_open(name, pstreamp); + error = pstream_open(name, pstreamp, dscp); free(name); return error; @@ -728,21 +721,18 @@ pstream_open_with_default_ports(const char *name_, /* * This function extracts IP address and port from the target string. * - * - On success, function returns true and fills *sin structure with port + * - On success, function returns true and fills *ss structure with port * and IP address. If port was absent in target string then it will use * corresponding default port value. - * - On error, function returns false and *sin contains garbage. + * - On error, function returns false and *ss contains garbage. */ bool -stream_parse_target_with_default_ports(const char *target, - uint16_t default_tcp_port, - uint16_t default_ssl_port, - struct sockaddr_in *sin) +stream_parse_target_with_default_port(const char *target, + uint16_t default_port, + struct sockaddr_storage *ss) { - return (!strncmp(target, "tcp:", 4) - && inet_parse_active(target + 4, default_tcp_port, sin)) || - (!strncmp(target, "ssl:", 4) - && inet_parse_active(target + 4, default_ssl_port, sin)); + return ((!strncmp(target, "tcp:", 4) || !strncmp(target, "ssl:", 4)) + && inet_parse_active(target + 4, default_port, ss)); } /* Attempts to guess the content type of a stream whose first few bytes were @@ -757,7 +747,7 @@ stream_guess_content(const uint8_t *data, ssize_t size) return STREAM_SSL; case PAIR('{', '"'): return STREAM_JSONRPC; - case PAIR(OFP10_VERSION, OFPT_HELLO): + case PAIR(OFP10_VERSION, 0 /* OFPT_HELLO */): return STREAM_OPENFLOW; } }