X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fvconn-stream.c;h=9347b5ea09e54acc4052e9cbac25160a09fedb46;hb=HEAD;hp=0a721d97a1aa3de9ceac388fb98eefd3da208862;hpb=c088c3be069e991e2d8a3acfdcbb9af278c6d5e5;p=sliver-openvswitch.git diff --git a/lib/vconn-stream.c b/lib/vconn-stream.c index 0a721d97a..9347b5ea0 100644 --- a/lib/vconn-stream.c +++ b/lib/vconn-stream.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,7 +15,6 @@ */ #include -#include #include #include #include @@ -23,7 +22,6 @@ #include #include #include "fatal-signal.h" -#include "leak-checker.h" #include "ofpbuf.h" #include "openflow/openflow.h" #include "poll-loop.h" @@ -32,9 +30,9 @@ #include "util.h" #include "vconn-provider.h" #include "vconn.h" - #include "vlog.h" -#define THIS_MODULE VLM_vconn_stream + +VLOG_DEFINE_THIS_MODULE(vconn_stream); /* Active stream socket vconn. */ @@ -44,29 +42,28 @@ struct vconn_stream struct stream *stream; struct ofpbuf *rxbuf; struct ofpbuf *txbuf; + int n_packets; }; -static struct vconn_class stream_vconn_class; +static const struct vconn_class stream_vconn_class; static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(10, 25); static void vconn_stream_clear_txbuf(struct vconn_stream *); static struct vconn * -vconn_stream_new(struct stream *stream, int connect_status) +vconn_stream_new(struct stream *stream, int connect_status, + uint32_t allowed_versions) { struct vconn_stream *s; s = xmalloc(sizeof *s); vconn_init(&s->vconn, &stream_vconn_class, connect_status, - stream_get_name(stream)); + stream_get_name(stream), allowed_versions); s->stream = stream; s->txbuf = NULL; s->rxbuf = NULL; - s->vconn.remote_ip = stream_get_remote_ip(stream); - s->vconn.remote_port = stream_get_remote_port(stream); - s->vconn.local_ip = stream_get_local_ip(stream); - s->vconn.local_port = stream_get_local_port(stream); + s->n_packets = 0; return &s->vconn; } @@ -75,21 +72,23 @@ vconn_stream_new(struct stream *stream, int connect_status) * * Returns 0 if successful, otherwise a positive errno value. */ static int -vconn_stream_open(const char *name, char *suffix OVS_UNUSED, - struct vconn **vconnp) +vconn_stream_open(const char *name, uint32_t allowed_versions, + char *suffix OVS_UNUSED, struct vconn **vconnp, uint8_t dscp) { struct stream *stream; int error; - error = stream_open_with_default_ports(name, OFP_TCP_PORT, OFP_SSL_PORT, - &stream); - - if (error && error != EAGAIN) { - return error; + error = stream_open_with_default_port(name, OFP_OLD_PORT, &stream, dscp); + if (!error) { + error = stream_connect(stream); + if (!error || error == EAGAIN) { + *vconnp = vconn_stream_new(stream, error, allowed_versions); + return 0; + } } - *vconnp = vconn_stream_new(stream, error); - return 0; + stream_close(stream); + return error; } static struct vconn_stream * @@ -102,6 +101,12 @@ static void vconn_stream_close(struct vconn *vconn) { struct vconn_stream *s = vconn_stream_cast(vconn); + + if ((vconn->error == EPROTO || s->n_packets < 1) && s->rxbuf) { + stream_report_content(ofpbuf_data(s->rxbuf), ofpbuf_size(s->rxbuf), STREAM_OPENFLOW, + THIS_MODULE, vconn_get_name(vconn)); + } + stream_close(s->stream); vconn_stream_clear_txbuf(s); ofpbuf_delete(s->rxbuf); @@ -121,14 +126,14 @@ vconn_stream_recv__(struct vconn_stream *s, int rx_len) struct ofpbuf *rx = s->rxbuf; int want_bytes, retval; - want_bytes = rx_len - rx->size; + want_bytes = rx_len - ofpbuf_size(rx); ofpbuf_prealloc_tailroom(rx, want_bytes); retval = stream_recv(s->stream, ofpbuf_tail(rx), want_bytes); if (retval > 0) { - rx->size += retval; + ofpbuf_set_size(rx, ofpbuf_size(rx) + retval); return retval == want_bytes ? 0 : EAGAIN; } else if (retval == 0) { - if (rx->size) { + if (ofpbuf_size(rx)) { VLOG_ERR_RL(&rl, "connection dropped mid-packet"); return EPROTO; } @@ -151,7 +156,7 @@ vconn_stream_recv(struct vconn *vconn, struct ofpbuf **bufferp) } /* Read ofp_header. */ - if (s->rxbuf->size < sizeof(struct ofp_header)) { + if (ofpbuf_size(s->rxbuf) < sizeof(struct ofp_header)) { int retval = vconn_stream_recv__(s, sizeof(struct ofp_header)); if (retval) { return retval; @@ -159,19 +164,19 @@ vconn_stream_recv(struct vconn *vconn, struct ofpbuf **bufferp) } /* Read payload. */ - oh = s->rxbuf->data; + oh = ofpbuf_data(s->rxbuf); rx_len = ntohs(oh->length); if (rx_len < sizeof(struct ofp_header)) { - VLOG_ERR_RL(&rl, "received too-short ofp_header (%zu bytes)", - rx_len); + VLOG_ERR_RL(&rl, "received too-short ofp_header (%d bytes)", rx_len); return EPROTO; - } else if (s->rxbuf->size < rx_len) { + } else if (ofpbuf_size(s->rxbuf) < rx_len) { int retval = vconn_stream_recv__(s, rx_len); if (retval) { return retval; } } + s->n_packets++; *bufferp = s->rxbuf; s->rxbuf = NULL; return 0; @@ -194,12 +199,11 @@ vconn_stream_send(struct vconn *vconn, struct ofpbuf *buffer) return EAGAIN; } - retval = stream_send(s->stream, buffer->data, buffer->size); - if (retval == buffer->size) { + retval = stream_send(s->stream, ofpbuf_data(buffer), ofpbuf_size(buffer)); + if (retval == ofpbuf_size(buffer)) { ofpbuf_delete(buffer); return 0; } else if (retval >= 0 || retval == -EAGAIN) { - leak_checker_claim(buffer); s->txbuf = buffer; if (retval > 0) { ofpbuf_pull(buffer, retval); @@ -216,20 +220,21 @@ vconn_stream_run(struct vconn *vconn) struct vconn_stream *s = vconn_stream_cast(vconn); ssize_t retval; + stream_run(s->stream); if (!s->txbuf) { return; } - retval = stream_send(s->stream, s->txbuf->data, s->txbuf->size); + retval = stream_send(s->stream, ofpbuf_data(s->txbuf), ofpbuf_size(s->txbuf)); if (retval < 0) { if (retval != -EAGAIN) { - VLOG_ERR_RL(&rl, "send: %s", strerror(-retval)); + VLOG_ERR_RL(&rl, "send: %s", ovs_strerror(-retval)); vconn_stream_clear_txbuf(s); return; } } else if (retval > 0) { ofpbuf_pull(s->txbuf, retval); - if (!s->txbuf->size) { + if (!ofpbuf_size(s->txbuf)) { vconn_stream_clear_txbuf(s); return; } @@ -241,6 +246,7 @@ vconn_stream_run_wait(struct vconn *vconn) { struct vconn_stream *s = vconn_stream_cast(vconn); + stream_run_wait(s->stream); if (s->txbuf) { stream_send_wait(s->stream); } @@ -271,7 +277,7 @@ vconn_stream_wait(struct vconn *vconn, enum vconn_wait_type wait) break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -283,7 +289,7 @@ struct pvconn_pstream struct pstream *pstream; }; -static struct pvconn_class pstream_pvconn_class; +static const struct pvconn_class pstream_pvconn_class; static struct pvconn_pstream * pvconn_pstream_cast(struct pvconn *pvconn) @@ -297,21 +303,22 @@ pvconn_pstream_cast(struct pvconn *pvconn) * Returns 0 if successful, otherwise a positive errno value. (The current * implementation never fails.) */ static int -pvconn_pstream_listen(const char *name, char *suffix OVS_UNUSED, - struct pvconn **pvconnp) +pvconn_pstream_listen(const char *name, uint32_t allowed_versions, + char *suffix OVS_UNUSED, struct pvconn **pvconnp, + uint8_t dscp) { struct pvconn_pstream *ps; struct pstream *pstream; int error; - error = pstream_open_with_default_ports(name, OFP_TCP_PORT, OFP_SSL_PORT, - &pstream); + error = pstream_open_with_default_port(name, OFP_OLD_PORT, + &pstream, dscp); if (error) { return error; } ps = xmalloc(sizeof *ps); - pvconn_init(&ps->pvconn, &pstream_pvconn_class, name); + pvconn_init(&ps->pvconn, &pstream_pvconn_class, name, allowed_versions); ps->pstream = pstream; *pvconnp = &ps->pvconn; return 0; @@ -336,12 +343,12 @@ pvconn_pstream_accept(struct pvconn *pvconn, struct vconn **new_vconnp) if (error) { if (error != EAGAIN) { VLOG_DBG_RL(&rl, "%s: accept: %s", - pstream_get_name(ps->pstream), strerror(error)); + pstream_get_name(ps->pstream), ovs_strerror(error)); } return error; } - *new_vconnp = vconn_stream_new(stream, 0); + *new_vconnp = vconn_stream_new(stream, 0, pvconn->allowed_versions); return 0; } @@ -354,9 +361,9 @@ pvconn_pstream_wait(struct pvconn *pvconn) /* Stream-based vconns and pvconns. */ -#define DEFINE_VCONN_STREAM_CLASS(NAME) \ - struct vconn_class NAME##_vconn_class = { \ - #NAME, \ +#define STREAM_INIT(NAME) \ + { \ + NAME, \ vconn_stream_open, \ vconn_stream_close, \ vconn_stream_connect, \ @@ -365,27 +372,27 @@ pvconn_pstream_wait(struct pvconn *pvconn) vconn_stream_run, \ vconn_stream_run_wait, \ vconn_stream_wait, \ - }; + } -#define DEFINE_PVCONN_STREAM_CLASS(NAME) \ - struct pvconn_class NAME##_pvconn_class = { \ - #NAME, \ +#define PSTREAM_INIT(NAME) \ + { \ + NAME, \ pvconn_pstream_listen, \ pvconn_pstream_close, \ pvconn_pstream_accept, \ pvconn_pstream_wait \ - }; + } -static DEFINE_VCONN_STREAM_CLASS(stream); -static DEFINE_PVCONN_STREAM_CLASS(pstream); +static const struct vconn_class stream_vconn_class = STREAM_INIT("stream"); +static const struct pvconn_class pstream_pvconn_class = PSTREAM_INIT("pstream"); -DEFINE_VCONN_STREAM_CLASS(tcp); -DEFINE_PVCONN_STREAM_CLASS(ptcp); +const struct vconn_class tcp_vconn_class = STREAM_INIT("tcp"); +const struct pvconn_class ptcp_pvconn_class = PSTREAM_INIT("ptcp"); -DEFINE_VCONN_STREAM_CLASS(unix); -DEFINE_PVCONN_STREAM_CLASS(punix); +const struct vconn_class unix_vconn_class = STREAM_INIT("unix"); +const struct pvconn_class punix_pvconn_class = PSTREAM_INIT("punix"); #ifdef HAVE_OPENSSL -DEFINE_VCONN_STREAM_CLASS(ssl); -DEFINE_PVCONN_STREAM_CLASS(pssl); +const struct vconn_class ssl_vconn_class = STREAM_INIT("ssl"); +const struct pvconn_class pssl_pvconn_class = PSTREAM_INIT("pssl"); #endif