socket-util: Move get_mtime() here from stream-ssl.
[openvswitch] / ofproto / status.c
1 /*
2  * Copyright (c) 2008, 2009, 2010 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "status.h"
19 #include <arpa/inet.h>
20 #include <assert.h>
21 #include <errno.h>
22 #include <inttypes.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include "dynamic-string.h"
26 #include "list.h"
27 #include "ofpbuf.h"
28 #include "ofproto.h"
29 #include "openflow/nicira-ext.h"
30 #include "packets.h"
31 #include "rconn.h"
32 #include "svec.h"
33 #include "timeval.h"
34 #include "vconn.h"
35
36 #define THIS_MODULE VLM_status
37 #include "vlog.h"
38
39 struct status_category {
40     struct list node;
41     char *name;
42     void (*cb)(struct status_reply *, void *aux);
43     void *aux;
44 };
45
46 struct switch_status {
47     time_t booted;
48     struct status_category *config_cat;
49     struct status_category *switch_cat;
50     struct list categories;
51 };
52
53 struct status_reply {
54     struct status_category *category;
55     struct ds request;
56     struct ds output;
57 };
58
59 int
60 switch_status_handle_request(struct switch_status *ss, struct rconn *rconn,
61                              struct nicira_header *request)
62 {
63     struct status_category *c;
64     struct nicira_header *reply;
65     struct status_reply sr;
66     struct ofpbuf *b;
67     int retval;
68
69     sr.request.string = (void *) (request + 1);
70     sr.request.length = ntohs(request->header.length) - sizeof *request;
71     ds_init(&sr.output);
72     LIST_FOR_EACH (c, struct status_category, node, &ss->categories) {
73         if (!memcmp(c->name, sr.request.string,
74                     MIN(strlen(c->name), sr.request.length))) {
75             sr.category = c;
76             c->cb(&sr, c->aux);
77         }
78     }
79     reply = make_openflow_xid(sizeof *reply + sr.output.length,
80                               OFPT_VENDOR, request->header.xid, &b);
81     reply->vendor = htonl(NX_VENDOR_ID);
82     reply->subtype = htonl(NXT_STATUS_REPLY);
83     memcpy(reply + 1, sr.output.string, sr.output.length);
84     retval = rconn_send(rconn, b, NULL);
85     if (retval && retval != EAGAIN) {
86         VLOG_WARN("send failed (%s)", strerror(retval));
87     }
88     ds_destroy(&sr.output);
89     return 0;
90 }
91
92 void
93 rconn_status_cb(struct status_reply *sr, void *rconn_)
94 {
95     struct rconn *rconn = rconn_;
96     time_t now = time_now();
97     uint32_t remote_ip = rconn_get_remote_ip(rconn);
98     uint32_t local_ip = rconn_get_local_ip(rconn);
99
100     status_reply_put(sr, "name=%s", rconn_get_name(rconn));
101     if (remote_ip) {
102         status_reply_put(sr, "remote-ip="IP_FMT, IP_ARGS(&remote_ip));
103         status_reply_put(sr, "remote-port=%d", 
104                          ntohs(rconn_get_remote_port(rconn)));
105         status_reply_put(sr, "local-ip="IP_FMT, IP_ARGS(&local_ip));
106         status_reply_put(sr, "local-port=%d", 
107                          ntohs(rconn_get_local_port(rconn)));
108     }
109     status_reply_put(sr, "state=%s", rconn_get_state(rconn));
110     status_reply_put(sr, "backoff=%d", rconn_get_backoff(rconn));
111     status_reply_put(sr, "probe-interval=%d", rconn_get_probe_interval(rconn));
112     status_reply_put(sr, "is-connected=%s",
113                      rconn_is_connected(rconn) ? "true" : "false");
114     status_reply_put(sr, "sent-msgs=%u", rconn_packets_sent(rconn));
115     status_reply_put(sr, "received-msgs=%u", rconn_packets_received(rconn));
116     status_reply_put(sr, "attempted-connections=%u",
117                      rconn_get_attempted_connections(rconn));
118     status_reply_put(sr, "successful-connections=%u",
119                      rconn_get_successful_connections(rconn));
120     status_reply_put(sr, "last-connection=%ld",
121                      (long int) (now - rconn_get_last_connection(rconn)));
122     status_reply_put(sr, "last-received=%ld",
123                      (long int) (now - rconn_get_last_received(rconn)));
124     status_reply_put(sr, "time-connected=%lu",
125                      rconn_get_total_time_connected(rconn));
126     status_reply_put(sr, "state-elapsed=%u", rconn_get_state_elapsed(rconn));
127 }
128
129 static void
130 config_status_cb(struct status_reply *sr, void *ofproto_)
131 {
132     const struct ofproto *ofproto = ofproto_;
133     uint64_t datapath_id;
134     struct svec listeners;
135     size_t i;
136
137     datapath_id = ofproto_get_datapath_id(ofproto);
138     if (datapath_id) {
139         status_reply_put(sr, "datapath-id=%016"PRIx64, datapath_id);
140     }
141
142     svec_init(&listeners);
143     ofproto_get_listeners(ofproto, &listeners);
144     for (i = 0; i < listeners.n; i++) {
145         status_reply_put(sr, "management%zu=%s", i, listeners.names[i]);
146     }
147     svec_destroy(&listeners);
148 }
149
150 static void
151 switch_status_cb(struct status_reply *sr, void *ss_)
152 {
153     struct switch_status *ss = ss_;
154     time_t now = time_now();
155
156     status_reply_put(sr, "now=%ld", (long int) now);
157     status_reply_put(sr, "uptime=%ld", (long int) (now - ss->booted));
158     status_reply_put(sr, "pid=%ld", (long int) getpid());
159 }
160
161 struct switch_status *
162 switch_status_create(const struct ofproto *ofproto)
163 {
164     struct switch_status *ss = xzalloc(sizeof *ss);
165     ss->booted = time_now();
166     list_init(&ss->categories);
167     ss->config_cat = switch_status_register(ss, "config", config_status_cb,
168                                             (void *) ofproto);
169     ss->switch_cat = switch_status_register(ss, "switch", switch_status_cb,
170                                             ss);
171     return ss;
172 }
173
174 void
175 switch_status_destroy(struct switch_status *ss)
176 {
177     if (ss) {
178         /* Orphan any remaining categories, so that unregistering them later
179          * won't write to bad memory. */
180         struct status_category *c, *next;
181         LIST_FOR_EACH_SAFE (c, next,
182                             struct status_category, node, &ss->categories) {
183             list_init(&c->node);
184         }
185         switch_status_unregister(ss->config_cat);
186         switch_status_unregister(ss->switch_cat);
187         free(ss);
188     }
189 }
190
191 struct status_category *
192 switch_status_register(struct switch_status *ss,
193                        const char *category,
194                        status_cb_func *cb, void *aux)
195 {
196     struct status_category *c = xmalloc(sizeof *c);
197     c->cb = cb;
198     c->aux = aux;
199     c->name = xstrdup(category);
200     list_push_back(&ss->categories, &c->node);
201     return c;
202 }
203
204 void
205 switch_status_unregister(struct status_category *c)
206 {
207     if (c) {
208         if (!list_is_empty(&c->node)) {
209             list_remove(&c->node);
210         }
211         free(c->name);
212         free(c);
213     }
214 }
215
216 void
217 status_reply_put(struct status_reply *sr, const char *content, ...)
218 {
219     size_t old_length = sr->output.length;
220     size_t added;
221     va_list args;
222
223     /* Append the status reply to the output. */
224     ds_put_format(&sr->output, "%s.", sr->category->name);
225     va_start(args, content);
226     ds_put_format_valist(&sr->output, content, args);
227     va_end(args);
228     if (ds_last(&sr->output) != '\n') {
229         ds_put_char(&sr->output, '\n');
230     }
231
232     /* Drop what we just added if it doesn't match the request. */
233     added = sr->output.length - old_length;
234     if (added < sr->request.length
235         || memcmp(&sr->output.string[old_length],
236                   sr->request.string, sr->request.length)) {
237         ds_truncate(&sr->output, old_length);
238     }
239 }