Home | History | Annotate | Line # | Download | only in altqstat
quip_client.c revision 1.9 
      1 /*	$NetBSD: quip_client.c,v 1.9 2006/10/12 19:59:13 peter Exp $	*/
      2 /*	$KAME: quip_client.c,v 1.9 2003/05/17 05:59:00 itojun Exp $	*/
      3 /*
      4  * Copyright (C) 1999-2000
      5  *	Sony Computer Science Laboratories, Inc.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
     17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19  * ARE DISCLAIMED.  IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
     20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  * SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/param.h>
     30 #include <sys/socket.h>
     31 #include <sys/time.h>
     32 #include <sys/un.h>
     33 
     34 #include <stdio.h>
     35 #include <stdlib.h>
     36 #include <unistd.h>
     37 #include <string.h>
     38 #include <errno.h>
     39 #include <err.h>
     40 
     41 #include "quip_client.h"
     42 #include "altqstat.h"
     43 
     44 /*
     45  * quip (queue information protocol) is a http-like protocol
     46  * in order to retrieve information from the server.
     47  * a unix domain TCP socket "/var/run/altq_quip" is used for
     48  * client-server style communication.
     49  *
     50  * there are 2 quip message types: request and response.
     51  * request format: (only single-line request message is used at this moment)
     52  *	request-line
     53  *
     54  *      request-line = <method> <operation>[?<query>] <quip-version>
     55  *	<method> = GET (only GET is defined at this moment)
     56  *	<operation> = list | handle-to-name | qdisc | filter
     57  *	query format is operation dependent but most query takes
     58  *	<interface> or <class> or <filter>.
     59  *	<interface> = <if_name>
     60  *	<class>     = <if_name>:<class_path>/<class_name>
     61  *	<filter>    = <if_name>:<class_path>/<class_name>:<filter_name>
     62  *	"list" operation accepts "*" as a wildcard.
     63  *
     64  * response format:
     65  *	status-line
     66  * 	response-headers (0 or more)
     67  *	<blank line>
     68  *	body
     69  *
     70  *	status-line = <quip-version> <status-code> <reason phrase>
     71  *	response-header = Content-Length:<value>
     72  *
     73  *	"Content-Length" specifies the length of the message body.
     74  *
     75  * example:
     76  *	to retrieve a list of classes (handle and name) on interface "fxp0":
     77  *	a request message looks like,
     78  *		GET list?fxp0:* QUIP/1.0<cr>
     79  *	a response message looks like,
     80  *		QUIP/1.0 200 OK<cr>
     81  *		Content-Length:86<cr>
     82  *		<cr>
     83  *		0000000000	fxp0:/root<cr>
     84  *		0xc0d1be00	fxp0:/root/parent<cr>
     85  *		0xc0d1ba00	fxp0:/root/parent/child<cr>
     86  *
     87  *	other examples:
     88  *	list all interfaces, classes, and filters:
     89  *		GET list QUIP/1.0<cr>
     90  *	list all interfaces:
     91  *		GET list?* QUIP/1.0<cr>
     92  *	list all classes:
     93  *		GET list?*:* QUIP/1.0<cr>
     94  *	list all filters:
     95  *		GET list?*:*:* QUIP/1.0<cr>
     96  *	convert class handle to class name:
     97  *		GET handle-to-name?fxp0:0xc0d1be00 QUIP/1.0<cr>
     98  *	convert filter handle to filter name:
     99  *		GET handle-to-name?fxp0::0x1000000a QUIP/1.0<cr>
    100  */
    101 
    102 #define	MAXLINESIZE	1024
    103 
    104 enum nametype { INTERFACE, CLASS, FILTER, CONDITIONER };
    105 
    106 static FILE *server = NULL;
    107 int quip_echo = 0;
    108 
    109 static char *extract_ifname(const char *);
    110 
    111 int
    112 quip_openserver(void)
    113 {
    114 	struct sockaddr_un addr;
    115 	int fd;
    116 
    117 	if ((fd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0)
    118 		err(1, "can't open socket");
    119 
    120 	bzero(&addr, sizeof(addr));
    121 	addr.sun_family = AF_LOCAL;
    122 	strlcpy(addr.sun_path, QUIP_PATH,sizeof(addr.sun_path));
    123 
    124 	if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
    125 		fprintf(stderr, "can't talk to altqd!\n"
    126 			"probably, altqd is not running\n");
    127 		return (-1);
    128 	}
    129 
    130 	if ((server = fdopen(fd, "r+")) == NULL) {
    131 		warn("fdopen: can't open stream to the quip server");
    132 		return (-1);
    133 	}
    134 	return (0);
    135 }
    136 
    137 int
    138 quip_closeserver(void)
    139 {
    140 	if (server != NULL)
    141 		return fclose(server);
    142 	return (0);
    143 }
    144 
    145 void
    146 quip_sendrequest(FILE *fp, const char *request)
    147 {
    148 	char buf[QUIPMSG_MAXSIZE], *cp;
    149 	int n;
    150 
    151 	if ((cp = strstr(request, "QUIP")) == NULL) {
    152 		cp = strchr(request, '\n');
    153 		n = cp - request;
    154 		if (cp == NULL || n > REQ_MAXSIZE - 10)
    155 			return;
    156 		strncpy(buf, request, n);
    157 		snprintf(buf + n, REQ_MAXSIZE - n, " QUIP/1.0");
    158 		strlcat(buf, cp, REQ_MAXSIZE);
    159 	}
    160 	else
    161 		strlcpy(buf, request, REQ_MAXSIZE);
    162 
    163 	if (fputs(buf, fp) != 0)
    164 		err(1, "fputs");
    165 	if (fflush(fp) != 0)
    166 		err(1, "fflush");
    167 	if (quip_echo) {
    168 		fputs("<< ", stdout);
    169 		fputs(buf, stdout);
    170 	}
    171 }
    172 
    173 /*
    174  * recv_response receives a response message from the server
    175  * and returns status_code.
    176  */
    177 int
    178 quip_recvresponse(FILE *fp, char *header, char *body, int *blen)
    179 {
    180 	char buf[MAXLINESIZE], version[MAXLINESIZE];
    181 	int code, resid, len, buflen;
    182 	int end_of_header = 0;
    183 
    184 	if (blen != NULL)
    185 		*blen = 0;
    186 	code = 0;
    187 	resid = 0;
    188 	buflen = RES_MAXSIZE;
    189 	while (fgets(buf, sizeof(buf), fp) != 0) {
    190 		if (quip_echo) {
    191 			fputs(">  ", stdout);
    192 			fputs(buf, stdout);
    193 		}
    194 
    195 		if (!end_of_header) {
    196 			/* process message header */
    197 			if (header != NULL) {
    198 				len = strlcpy(header, buf, buflen);
    199 				if (len >= buflen) {
    200 					/* header too long */
    201 					fpurge(fp);
    202 					return (-1);
    203 				}
    204 				header += len;
    205 				buflen -= len;
    206 			}
    207 
    208 			if (code == 0) {
    209 				/* status line expected */
    210 				if (buf[0] == '\n') {
    211 					/* ignore blank lines */
    212 				}
    213 				/* XXX sizeof(version) == 1024 */
    214 				else if (sscanf(buf, "%1023s %d",
    215 						version, &code) != 2) {
    216 					/* can't get result code */
    217 					fpurge(fp);
    218 					return (-1);
    219 				}
    220 			}
    221 			else {
    222 				/* entity header expected */
    223 				char *field, *cp;
    224 
    225 				if (buf[0] == '\n') {
    226 					/* end of header */
    227 					end_of_header = 1;
    228 					buflen = BODY_MAXSIZE;
    229 					if (resid == 0)
    230 						/* no message body */
    231 						return (code);
    232 				}
    233 
    234 				cp = buf;
    235 				field = strsep(&cp, ":");
    236 				if (strcmp(field, "Content-Length") == 0) {
    237 					if (sscanf(cp, "%d", &resid) != 1) {
    238 						fpurge(fp);
    239 						return (-1);
    240 					}
    241 					if (blen != NULL)
    242 						*blen = resid;
    243 				}
    244 			}
    245 		}
    246 		else {
    247 			/* process message body */
    248 			if (body != NULL) {
    249 				len = strlcpy(body, buf, buflen);
    250 				if (len >= buflen) {
    251 					/* body too long */
    252 					fpurge(fp);
    253 					return (-1);
    254 				}
    255 				body += len;
    256 				buflen -= len;
    257 			}
    258 			else
    259 				len = strlen(buf);
    260 			resid -= len;
    261 			if (resid <= 0)
    262 				return (code);
    263 		}
    264 	}
    265 	return (-1);
    266 }
    267 
    268 void
    269 quip_rawmode(void)
    270 {
    271 	char line[MAXLINESIZE];
    272 	int result_code;
    273 
    274 	printf(">>>Entering the raw interactive mode to the server:\n\n");
    275 	if (server == NULL) {
    276 		printf("No server available!\n");
    277 		return;
    278 	}
    279 
    280 	while (1) {
    281 		printf("%% "); fflush(stdout);
    282 		/* read a line from stdin */
    283 		if (fgets(line, sizeof(line), stdin) == NULL)
    284 			break;
    285 
    286 		if (line[0] == '\n') {
    287 			/* if a blank line, echo locally */
    288 			fputs(line, stdout);
    289 			continue;
    290 		}
    291 		if (line[0] == 'q') {
    292 			printf("Exit\n");
    293 			break;
    294 		}
    295 
    296 		/* send the input line to the server */
    297 		quip_sendrequest(server, line);
    298 
    299 		/* get a response message from the server */
    300 		result_code = quip_recvresponse(server, NULL, NULL, NULL);
    301 	}
    302 }
    303 
    304 char *
    305 quip_selectinterface(char *ifname)
    306 {
    307 	char buf[BODY_MAXSIZE], *cp;
    308 	int result_code, len;
    309 	u_int if_index;
    310 	static char interface[64];
    311 
    312 	if (server == NULL)
    313 		return (ifname);
    314 
    315 	/* get an inferface list from the server */
    316 	quip_sendrequest(server, "GET list?*\n");
    317 
    318 	result_code = quip_recvresponse(server, NULL, buf, &len);
    319 	if (result_code != 200)
    320 		errx(1, "can't get interface list");
    321 
    322 	cp = buf;
    323 	while (1) {
    324 		if (sscanf(cp, "%x %63s", &if_index, interface) != 2)
    325 			break;
    326 		if (ifname == NULL) {
    327 			/* if name isn't specified, return the 1st entry */
    328 			return (interface);
    329 		}
    330 		if (strcmp(ifname, interface) == 0)
    331 			/* found the matching entry */
    332 			return (interface);
    333 		if ((cp = strchr(cp+1, '\n')) == NULL)
    334 			break;
    335 	}
    336 	errx(1, "can't get interface");
    337 	return (NULL);
    338 }
    339 
    340 char *
    341 quip_selectqdisc(char *ifname, char *qdisc_name)
    342 {
    343 	char buf[BODY_MAXSIZE], req[REQ_MAXSIZE];
    344 	int result_code, len;
    345 	static char qdisc[64];
    346 
    347 	if (server == NULL) {
    348 		if (ifname == NULL || qdisc_name == NULL)
    349 			errx(1, "when disabling server communication,\n"
    350 			    "specify both interface (-i) and qdisc (-q)!");
    351 		return (qdisc_name);
    352 	}
    353 
    354 	/* get qdisc info from the server */
    355 	snprintf(req, sizeof(req), "GET qdisc?%s\n", ifname);
    356 	quip_sendrequest(server, req);
    357 
    358 	result_code = quip_recvresponse(server, NULL, buf, &len);
    359 	if (result_code != 200)
    360 		errx(1, "can't get qdisc info");
    361 
    362 	if (sscanf(buf, "%s", qdisc) != 1)
    363 		errx(1, "can't get qdisc name");
    364 
    365 	if (qdisc_name != NULL && strcmp(qdisc, qdisc_name) != 0)
    366 		errx(1, "qdisc %s on %s doesn't match specified qdisc %s",
    367 		    qdisc, ifname, qdisc_name);
    368 
    369 	return (qdisc);
    370 }
    371 
    372 void
    373 quip_chandle2name(const char *ifname, u_long handle, char *name, size_t size)
    374 {
    375 	char buf[BODY_MAXSIZE], req[REQ_MAXSIZE], *cp;
    376 	int result_code, len;
    377 
    378 	name[0] = '\0';
    379 	if (server == NULL)
    380 		return;
    381 
    382 	/* get class name from the server */
    383 	snprintf(req, sizeof(req), "GET handle-to-name?%s:%#lx\n", ifname, handle);
    384 	quip_sendrequest(server, req);
    385 
    386 	result_code = quip_recvresponse(server, NULL, buf, &len);
    387 	if (result_code != 200)
    388 		errx(1, "can't get class name");
    389 
    390 	if ((cp = strchr(buf, '\n')) != NULL)
    391 		*cp = '\0';
    392 	if ((cp = strrchr(buf, '/')) != NULL)
    393 		strlcpy(name, cp+1, size);
    394 }
    395 
    396 void
    397 quip_printqdisc(const char *ifname)
    398 {
    399 	char buf[BODY_MAXSIZE], req[REQ_MAXSIZE], *cp;
    400 	int result_code, len;
    401 
    402 	if (server == NULL) {
    403 		printf("No server available!\n");
    404 		return;
    405 	}
    406 
    407 	/* get qdisc info from the server */
    408 	snprintf(req, sizeof(req), "GET qdisc?%s\n", ifname);
    409 	quip_sendrequest(server, req);
    410 
    411 	result_code = quip_recvresponse(server, NULL, buf, &len);
    412 	if (result_code != 200)
    413 		errx(1, "can't get qdisc info");
    414 
    415 	/* replace newline by space */
    416 	cp = buf;
    417 	while ((cp = strchr(cp, '\n')) != NULL)
    418 		*cp = ' ';
    419 
    420 	printf("  qdisc:%s\n", buf);
    421 }
    422 
    423 void
    424 quip_printfilter(const char *ifname, const u_long handle)
    425 {
    426 	char buf[BODY_MAXSIZE], req[REQ_MAXSIZE], *cp;
    427 	int result_code, len;
    428 
    429 	if (server == NULL) {
    430 		printf("No server available!\n");
    431 		return;
    432 	}
    433 
    434 	/* get qdisc info from the server */
    435 	snprintf(req, sizeof(req), "GET filter?%s::%#lx\n", ifname, handle);
    436 	quip_sendrequest(server, req);
    437 
    438 	result_code = quip_recvresponse(server, NULL, buf, &len);
    439 	if (result_code != 200)
    440 		errx(1, "can't get filter info");
    441 
    442 	if ((cp = strchr(buf, '\n')) != NULL)
    443 		*cp = '\0';
    444 	printf("%s", buf);
    445 }
    446 
    447 static char *
    448 extract_ifname(const char *name)
    449 {
    450 	char *cp;
    451 	int len;
    452 	static char ifname[64];
    453 
    454 	if ((cp = strchr(name, ':')) != NULL)
    455 		len = cp - name;
    456 	else
    457 		len = strlen(name);
    458 	len = MIN(len, 63);
    459 	strncpy(ifname, name, len);
    460 	ifname[len] = '\0';
    461 	return (ifname);
    462 }
    463 
    464 void
    465 quip_printconfig(void)
    466 {
    467 	char buf[BODY_MAXSIZE], name[256], *cp, *p, *flname;
    468 	int result_code, len;
    469 	enum nametype type;
    470 	u_long handle;
    471 
    472 	if (server == NULL) {
    473 		printf("No server available!\n");
    474 		return;
    475 	}
    476 
    477 	/* get a total list from the server */
    478 	quip_sendrequest(server, "GET list\n");
    479 
    480 	result_code = quip_recvresponse(server, NULL, buf, &len);
    481 	if (result_code != 200)
    482 		errx(1, "can't get total list");
    483 
    484 	printf("------------ current configuration ------------");
    485 
    486 	cp = buf;
    487 	while (1) {
    488 		if (sscanf(cp, "%lx %255s", &handle, name) != 2)
    489 			break;
    490 
    491 		if ((p = strchr(name, ':')) == NULL)
    492 			type = INTERFACE;
    493 		else if (strchr(p+1, ':') == NULL)
    494 			type = CLASS;
    495 		else
    496 			type = FILTER;
    497 
    498 		switch (type) {
    499 		case INTERFACE:
    500 			printf("\ninterface: %s  (index:%lu)\n",
    501 			       name, handle);
    502 			quip_printqdisc(name);
    503 			break;
    504 		case CLASS:
    505 			printf("class: %s  (handle:%#lx)\n",
    506 			       name, handle);
    507 			break;
    508 		case FILTER:
    509 			flname = strrchr(name, ':') + 1;
    510 			printf("  filter: name:%s [", flname);
    511 			quip_printfilter(extract_ifname(name), handle);
    512 			printf("]  (handle:%#lx)\n", handle);
    513 			break;
    514 		case CONDITIONER:
    515 			break;
    516 		}
    517 
    518 		if ((cp = strchr(cp+1, '\n')) == NULL)
    519 			break;
    520 	}
    521 	printf("-----------------------------------------------\n\n");
    522 }
    523 
    524