1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <stdio.h>
27 #include <sys/types.h>
28 #include <sys/socket.h>
29 #include <sys/ethernet.h>
30 #include <netinet/in.h>
31 #include <arpa/inet.h>
32 #include <sys/stat.h>
33 #include <sys/dld_ioc.h>
34 #include <string.h>
35 #include <fcntl.h>
36 #include <unistd.h>
37 #include <stropts.h>
38 #include <stdlib.h>
39 #include <errno.h>
40 #include <strings.h>
41 #include <libintl.h>
42 #include <netdb.h>
43 #include <net/if_types.h>
44 #include <net/if_dl.h>
45 #include <inet/ip.h>
46 #include <inet/ip6.h>
47 #include <libdlflow.h>
48 #include <libdlflow_impl.h>
49 #include <libdladm_impl.h>
50 
51 /* minimum buffer size for DLDIOCWALKFLOW */
52 #define	MIN_INFO_SIZE	(4 * 1024)
53 
54 #define	DLADM_FLOW_DB		"/etc/dladm/flowadm.conf"
55 #define	DLADM_FLOW_DB_TMP	"/etc/dladm/flowadm.conf.new"
56 #define	DLADM_FLOW_DB_LOCK	"/tmp/flowadm.conf.lock"
57 
58 #define	DLADM_FLOW_DB_PERMS	S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
59 #define	DLADM_FLOW_DB_OWNER	UID_DLADM
60 #define	DLADM_FLOW_DB_GROUP	GID_NETADM
61 
62 #define	BLANK_LINE(s)	((s[0] == '\0') || (s[0] == '#') || (s[0] == '\n'))
63 #define	MAXLINELEN	1024
64 #define	MAXPATHLEN	1024
65 
66 /* database file parameters */
67 static const char *BW_LIMIT = "bw_limit";
68 static const char *PRIORITY = "priority";
69 static const char *LOCAL_IP_ADDR = "local_ip";
70 static const char *REMOTE_IP_ADDR = "remote_ip";
71 static const char *TRANSPORT = "transport";
72 static const char *LOCAL_PORT = "local_port";
73 static const char *REMOTE_PORT = "remote_port";
74 static const char *DSFIELD = "dsfield";
75 
76 /*
77  * Open and lock the flowadm configuration file lock. The lock is
78  * acquired as a reader (F_RDLCK) or writer (F_WRLCK).
79  */
80 static int
i_dladm_flow_lock_db(short type)81 i_dladm_flow_lock_db(short type)
82 {
83 	int lock_fd;
84 	struct flock lock;
85 
86 	if ((lock_fd = open(DLADM_FLOW_DB_LOCK, O_RDWR | O_CREAT | O_TRUNC,
87 	    DLADM_FLOW_DB_PERMS)) < 0)
88 		return (-1);
89 
90 	lock.l_type = type;
91 	lock.l_whence = SEEK_SET;
92 	lock.l_start = 0;
93 	lock.l_len = 0;
94 
95 	if (fcntl(lock_fd, F_SETLKW, &lock) < 0) {
96 		(void) close(lock_fd);
97 		(void) unlink(DLADM_FLOW_DB_LOCK);
98 		return (-1);
99 	}
100 	return (lock_fd);
101 }
102 
103 /*
104  * Unlock and close the specified file.
105  */
106 static void
i_dladm_flow_unlock_db(int fd)107 i_dladm_flow_unlock_db(int fd)
108 {
109 	struct flock lock;
110 
111 	if (fd < 0)
112 		return;
113 
114 	lock.l_type = F_UNLCK;
115 	lock.l_whence = SEEK_SET;
116 	lock.l_start = 0;
117 	lock.l_len = 0;
118 
119 	(void) fcntl(fd, F_SETLKW, &lock);
120 	(void) close(fd);
121 	(void) unlink(DLADM_FLOW_DB_LOCK);
122 }
123 
124 /*
125  * Parse one line of the link flowadm DB
126  * Returns -1 on failure, 0 on success.
127  */
128 dladm_status_t
dladm_flow_parse_db(char * line,dld_flowinfo_t * attr)129 dladm_flow_parse_db(char *line, dld_flowinfo_t *attr)
130 {
131 	char		*token;
132 	char		*value, *name = NULL;
133 	char		*lasts = NULL;
134 	dladm_status_t	status = DLADM_STATUS_FLOW_DB_PARSE_ERR;
135 
136 	bzero(attr, sizeof (*attr));
137 
138 	/* flow name */
139 	if ((token = strtok_r(line, " \t", &lasts)) == NULL)
140 		goto done;
141 
142 	if (strlcpy(attr->fi_flowname, token, MAXFLOWNAMELEN) >= MAXFLOWNAMELEN)
143 		goto done;
144 
145 	/* resource control and flow descriptor parameters */
146 	while ((token = strtok_r(NULL, " \t", &lasts)) != NULL) {
147 		if ((name = strdup(token)) == NULL)
148 			goto done;
149 
150 		(void) strtok(name, "=");
151 		value = strtok(NULL, "=");
152 		if (value == NULL)
153 			goto done;
154 
155 		if (strcmp(name, "linkid") == 0) {
156 			if ((attr->fi_linkid =
157 			    (uint32_t)strtol(value, NULL, 10)) ==
158 			    DATALINK_INVALID_LINKID)
159 				goto done;
160 
161 		} else if (strcmp(name, BW_LIMIT) == 0) {
162 			attr->fi_resource_props.mrp_mask |=
163 			    MRP_MAXBW;
164 			attr->fi_resource_props.mrp_maxbw =
165 			    (uint64_t)strtol(value, NULL, 0);
166 
167 		} else if (strcmp(name, PRIORITY) == 0) {
168 			attr->fi_resource_props.mrp_mask |= MRP_PRIORITY;
169 			status = dladm_str2pri(value,
170 			    &attr->fi_resource_props.mrp_priority);
171 			if (status != DLADM_STATUS_OK)
172 				goto done;
173 
174 		} else if (strcmp(name, DSFIELD) == 0) {
175 			status = do_check_dsfield(value,
176 			    &attr->fi_flow_desc);
177 			if (status != DLADM_STATUS_OK)
178 				goto done;
179 
180 		} else if (strcmp(name, LOCAL_IP_ADDR) == 0) {
181 			status = do_check_ip_addr(value, B_TRUE,
182 			    &attr->fi_flow_desc);
183 			if (status != DLADM_STATUS_OK)
184 				goto done;
185 
186 		} else if (strcmp(name, REMOTE_IP_ADDR) == 0) {
187 			status = do_check_ip_addr(value, B_FALSE,
188 			    &attr->fi_flow_desc);
189 			if (status != DLADM_STATUS_OK)
190 				goto done;
191 
192 		} else if (strcmp(name, TRANSPORT) == 0) {
193 			attr->fi_flow_desc.fd_mask |= FLOW_IP_PROTOCOL;
194 			attr->fi_flow_desc.fd_protocol =
195 			    (uint8_t)strtol(value, NULL, 0);
196 
197 		} else if (strcmp(name, LOCAL_PORT) == 0) {
198 			attr->fi_flow_desc.fd_mask |= FLOW_ULP_PORT_LOCAL;
199 			attr->fi_flow_desc.fd_local_port =
200 			    (uint16_t)strtol(value, NULL, 10);
201 			attr->fi_flow_desc.fd_local_port =
202 			    htons(attr->fi_flow_desc.fd_local_port);
203 		} else if (strcmp(name, REMOTE_PORT) == 0) {
204 			attr->fi_flow_desc.fd_mask |= FLOW_ULP_PORT_REMOTE;
205 			attr->fi_flow_desc.fd_remote_port =
206 			    (uint16_t)strtol(value, NULL, 10);
207 			attr->fi_flow_desc.fd_remote_port =
208 			    htons(attr->fi_flow_desc.fd_remote_port);
209 		}
210 		free(name);
211 		name = NULL;
212 	}
213 	if (attr->fi_linkid != DATALINK_INVALID_LINKID)
214 		status = DLADM_STATUS_OK;
215 done:
216 	free(name);
217 	return (status);
218 }
219 
220 #define	FPRINTF_ERR(fcall) if ((fcall) < 0) return (-1);
221 
222 /*
223  * Write the attribute of a group to the specified file. Returns 0 on
224  * success, -1 on failure.
225  */
226 static int
i_dladm_flow_fput_grp(FILE * fp,dld_flowinfo_t * attr)227 i_dladm_flow_fput_grp(FILE *fp, dld_flowinfo_t *attr)
228 {
229 
230 	FPRINTF_ERR(fprintf(fp, "%s\tlinkid=%d\t",
231 	    attr->fi_flowname, attr->fi_linkid));
232 
233 	/* flow policy */
234 	if (attr->fi_resource_props.mrp_mask & MRP_MAXBW)
235 		FPRINTF_ERR(fprintf(fp, "%s=%" PRIu64 "\t", BW_LIMIT,
236 		    attr->fi_resource_props.mrp_maxbw));
237 
238 	if (attr->fi_resource_props.mrp_mask & MRP_PRIORITY)
239 		FPRINTF_ERR(fprintf(fp, "%s=%d\t", PRIORITY,
240 		    attr->fi_resource_props.mrp_priority));
241 
242 	/* flow descriptor */
243 	if (attr->fi_flow_desc.fd_mask & FLOW_IP_DSFIELD)
244 		FPRINTF_ERR(fprintf(fp, "%s=%x:%x\t", DSFIELD,
245 		    attr->fi_flow_desc.fd_dsfield,
246 		    attr->fi_flow_desc.fd_dsfield_mask));
247 
248 	if (attr->fi_flow_desc.fd_mask & FLOW_IP_LOCAL) {
249 		char abuf[INET6_ADDRSTRLEN], *ap;
250 		struct in_addr ipaddr;
251 		int prefix_len, prefix_max;
252 
253 		if (attr->fi_flow_desc.fd_ipversion != 6) {
254 			ipaddr.s_addr =
255 			    attr->fi_flow_desc.
256 			    fd_local_addr._S6_un._S6_u32[3];
257 
258 			ap = inet_ntoa(ipaddr);
259 			prefix_max = IP_ABITS;
260 		} else {
261 			(void) inet_ntop(AF_INET6,
262 			    &attr->fi_flow_desc.fd_local_addr,
263 			    abuf, INET6_ADDRSTRLEN);
264 
265 			ap = abuf;
266 			prefix_max = IPV6_ABITS;
267 		}
268 		(void) dladm_mask2prefixlen(
269 		    &attr->fi_flow_desc.fd_local_netmask, prefix_max,
270 		    &prefix_len);
271 
272 		FPRINTF_ERR(fprintf(fp, "%s=%s/%d\t", LOCAL_IP_ADDR,
273 		    ap, prefix_len));
274 	}
275 	if (attr->fi_flow_desc.fd_mask & FLOW_IP_REMOTE) {
276 		char abuf[INET6_ADDRSTRLEN], *ap;
277 		struct in_addr ipaddr;
278 		int prefix_len, prefix_max;
279 
280 		if (attr->fi_flow_desc.fd_ipversion != 6) {
281 			ipaddr.s_addr =
282 			    attr->fi_flow_desc.
283 			    fd_remote_addr._S6_un._S6_u32[3];
284 
285 			ap = inet_ntoa(ipaddr);
286 			prefix_max = IP_ABITS;
287 		} else {
288 			(void) inet_ntop(AF_INET6,
289 			    &(attr->fi_flow_desc.fd_remote_addr),
290 			    abuf, INET6_ADDRSTRLEN);
291 
292 			ap = abuf;
293 			prefix_max = IPV6_ABITS;
294 		}
295 		(void) dladm_mask2prefixlen(
296 		    &attr->fi_flow_desc.fd_remote_netmask, prefix_max,
297 		    &prefix_len);
298 
299 		FPRINTF_ERR(fprintf(fp, "%s=%s/%d\t", REMOTE_IP_ADDR,
300 		    ap, prefix_len));
301 	}
302 	if (attr->fi_flow_desc.fd_mask & FLOW_IP_PROTOCOL)
303 		FPRINTF_ERR(fprintf(fp, "%s=%d\t", TRANSPORT,
304 		    attr->fi_flow_desc.fd_protocol));
305 
306 	if (attr->fi_flow_desc.fd_mask & FLOW_ULP_PORT_LOCAL)
307 		FPRINTF_ERR(fprintf(fp, "%s=%d\t", LOCAL_PORT,
308 		    ntohs(attr->fi_flow_desc.fd_local_port)));
309 
310 	if (attr->fi_flow_desc.fd_mask & FLOW_ULP_PORT_REMOTE)
311 		FPRINTF_ERR(fprintf(fp, "%s=%d\t", REMOTE_PORT,
312 		    ntohs(attr->fi_flow_desc.fd_remote_port)));
313 
314 	FPRINTF_ERR(fprintf(fp, "\n"));
315 
316 	return (0);
317 
318 }
319 
320 static dladm_status_t
i_dladm_flow_walk_rw_db(int (* fn)(void *,dld_flowinfo_t *),void * arg,const char * root)321 i_dladm_flow_walk_rw_db(int (*fn)(void *, dld_flowinfo_t *),
322     void *arg,
323     const char *root)
324 {
325 	FILE *fp, *nfp;
326 	int nfd, fn_rc, lock_fd;
327 	char line[MAXLINELEN];
328 	dld_flowinfo_t attr;
329 	char *db_file, *tmp_db_file;
330 	char db_file_buf[MAXPATHLEN];
331 	char tmp_db_file_buf[MAXPATHLEN];
332 	dladm_status_t	status = DLADM_STATUS_FLOW_DB_ERR;
333 
334 	if (root == NULL) {
335 		db_file = DLADM_FLOW_DB;
336 		tmp_db_file = DLADM_FLOW_DB_TMP;
337 	} else {
338 		(void) snprintf(db_file_buf, MAXPATHLEN, "%s%s", root,
339 		    DLADM_FLOW_DB);
340 		(void) snprintf(tmp_db_file_buf, MAXPATHLEN, "%s%s", root,
341 		    DLADM_FLOW_DB_TMP);
342 		db_file = db_file_buf;
343 		tmp_db_file = tmp_db_file_buf;
344 	}
345 
346 	if ((lock_fd = i_dladm_flow_lock_db(F_WRLCK)) < 0)
347 		return (DLADM_STATUS_FLOW_DB_ERR);
348 
349 	if ((fp = fopen(db_file, "r")) == NULL) {
350 		i_dladm_flow_unlock_db(lock_fd);
351 		return (DLADM_STATUS_FLOW_DB_OPEN_ERR);
352 	}
353 
354 	if ((nfd = open(tmp_db_file, O_WRONLY|O_CREAT|O_TRUNC,
355 	    DLADM_FLOW_DB_PERMS)) == -1) {
356 		(void) fclose(fp);
357 		i_dladm_flow_unlock_db(lock_fd);
358 		return (DLADM_STATUS_FLOW_DB_OPEN_ERR);
359 	}
360 
361 	if ((nfp = fdopen(nfd, "w")) == NULL) {
362 		(void) close(nfd);
363 		(void) fclose(fp);
364 		(void) unlink(tmp_db_file);
365 		i_dladm_flow_unlock_db(lock_fd);
366 		return (DLADM_STATUS_FLOW_DB_OPEN_ERR);
367 	}
368 
369 	while (fgets(line, MAXLINELEN, fp) != NULL) {
370 
371 		/* skip comments */
372 		if (BLANK_LINE(line)) {
373 			if (fputs(line, nfp) == EOF)
374 				goto failed;
375 			continue;
376 		}
377 		(void) strtok(line, " \n");
378 
379 		if ((status = dladm_flow_parse_db(line, &attr)) !=
380 		    DLADM_STATUS_OK)
381 			goto failed;
382 
383 		fn_rc = fn(arg, &attr);
384 
385 		switch (fn_rc) {
386 		case -1:
387 			/* failure, stop walking */
388 			goto failed;
389 		case 0:
390 			/*
391 			 * Success, write group attributes, which could
392 			 * have been modified by fn().
393 			 */
394 			if (i_dladm_flow_fput_grp(nfp, &attr) != 0)
395 				goto failed;
396 			break;
397 		case 1:
398 			/* skip current group */
399 			break;
400 		}
401 	}
402 	if (fchmod(nfd, DLADM_FLOW_DB_PERMS) == -1)
403 		goto failed;
404 
405 	if (fchown(nfd, DLADM_FLOW_DB_OWNER, DLADM_FLOW_DB_GROUP) == -1)
406 		goto failed;
407 
408 	if (fflush(nfp) == EOF)
409 		goto failed;
410 
411 	(void) fclose(fp);
412 	(void) fclose(nfp);
413 
414 	if (rename(tmp_db_file, db_file) == -1) {
415 		(void) unlink(tmp_db_file);
416 		i_dladm_flow_unlock_db(lock_fd);
417 		return (DLADM_STATUS_FLOW_DB_ERR);
418 	}
419 	i_dladm_flow_unlock_db(lock_fd);
420 	return (DLADM_STATUS_OK);
421 
422 failed:
423 	(void) fclose(fp);
424 	(void) fclose(nfp);
425 	(void) unlink(tmp_db_file);
426 	i_dladm_flow_unlock_db(lock_fd);
427 
428 	return (status);
429 }
430 
431 /*
432  * Remove existing flow from DB.
433  */
434 
435 typedef struct remove_db_state {
436 	dld_flowinfo_t	rs_newattr;
437 	dld_flowinfo_t	rs_oldattr;
438 	boolean_t	rs_found;
439 } remove_db_state_t;
440 
441 static int
i_dladm_flow_remove_db_fn(void * arg,dld_flowinfo_t * grp)442 i_dladm_flow_remove_db_fn(void *arg, dld_flowinfo_t *grp)
443 {
444 	remove_db_state_t *state = (remove_db_state_t *)arg;
445 	dld_flowinfo_t *attr = &state->rs_newattr;
446 
447 	if ((strcmp(grp->fi_flowname, attr->fi_flowname)) != 0)
448 		return (0);
449 	else {
450 		bcopy(grp, &state->rs_oldattr,
451 		    sizeof (dld_flowinfo_t));
452 		state->rs_found = B_TRUE;
453 		return (1);
454 	}
455 }
456 
457 /* ARGSUSED */
458 static int
i_dladm_flow_remove_db(remove_db_state_t * state,const char * root)459 i_dladm_flow_remove_db(remove_db_state_t *state, const char *root)
460 {
461 	if (i_dladm_flow_walk_rw_db(i_dladm_flow_remove_db_fn, state, root)
462 	    != 0)
463 		return (-1);
464 
465 	if (!state->rs_found) {
466 		errno = ENOENT;
467 		return (-1);
468 	}
469 
470 	return (0);
471 }
472 
473 /*
474  * Create a flow in the DB.
475  */
476 
477 typedef struct modify_db_state {
478 	dld_flowinfo_t	ms_newattr;
479 	dld_flowinfo_t	ms_oldattr;
480 	boolean_t	ms_found;
481 } modify_db_state_t;
482 
483 static dladm_status_t
i_dladm_flow_create_db(dld_flowinfo_t * attr,const char * root)484 i_dladm_flow_create_db(dld_flowinfo_t *attr, const char *root)
485 {
486 	FILE 	*fp;
487 	char 	line[MAXLINELEN];
488 	char	*db_file;
489 	char	db_file_buf[MAXPATHLEN];
490 	int	lock_fd;
491 	dladm_status_t	status = DLADM_STATUS_OK;
492 
493 	if (root == NULL) {
494 		db_file = DLADM_FLOW_DB;
495 	} else {
496 		(void) snprintf(db_file_buf, MAXPATHLEN, "%s%s", root,
497 		    DLADM_FLOW_DB);
498 		db_file = db_file_buf;
499 	}
500 
501 	if ((lock_fd = i_dladm_flow_lock_db(F_WRLCK)) < 0)
502 		return (DLADM_STATUS_FLOW_DB_ERR);
503 
504 	if ((fp = fopen(db_file, "r+")) == NULL &&
505 	    (fp = fopen(db_file, "w")) == NULL) {
506 		i_dladm_flow_unlock_db(lock_fd);
507 		return (DLADM_STATUS_FLOW_DB_OPEN_ERR);
508 	}
509 
510 	/* look for existing group with same flowname */
511 	while (fgets(line, MAXLINELEN, fp) != NULL) {
512 		char *holder, *lasts;
513 
514 		/* skip comments */
515 		if (BLANK_LINE(line))
516 			continue;
517 
518 		/* ignore corrupted lines */
519 		holder = strtok_r(line, " \t", &lasts);
520 		if (holder == NULL)
521 			continue;
522 
523 		/* flow id */
524 		if (strcmp(holder, attr->fi_flowname) == 0) {
525 			/* group with flow id already exists */
526 			status = DLADM_STATUS_PERSIST_FLOW_EXISTS;
527 			goto failed;
528 		}
529 	}
530 	/*
531 	 * If we get here, we've verified that no existing group with
532 	 * the same flow id already exists. Its now time to add the new
533 	 * group to the DB.
534 	 */
535 	if (i_dladm_flow_fput_grp(fp, attr) != 0)
536 		status = DLADM_STATUS_FLOW_DB_PARSE_ERR;
537 
538 failed:
539 	(void) fclose(fp);
540 	i_dladm_flow_unlock_db(lock_fd);
541 	return (status);
542 }
543 
544 static dladm_status_t
i_dladm_flow_add(dladm_handle_t handle,char * flowname,datalink_id_t linkid,flow_desc_t * flowdesc,mac_resource_props_t * mrp)545 i_dladm_flow_add(dladm_handle_t handle, char *flowname, datalink_id_t linkid,
546     flow_desc_t *flowdesc, mac_resource_props_t *mrp)
547 {
548 	dld_ioc_addflow_t	attr;
549 
550 	/* create flow */
551 	bzero(&attr, sizeof (attr));
552 	bcopy(flowdesc, &attr.af_flow_desc, sizeof (flow_desc_t));
553 	if (mrp != NULL) {
554 		bcopy(mrp, &attr.af_resource_props,
555 		    sizeof (mac_resource_props_t));
556 	}
557 
558 	(void) strlcpy(attr.af_name, flowname, sizeof (attr.af_name));
559 	attr.af_linkid = linkid;
560 
561 	if (ioctl(dladm_dld_fd(handle), DLDIOC_ADDFLOW, &attr) < 0)
562 		return (dladm_errno2status(errno));
563 
564 	return (DLADM_STATUS_OK);
565 }
566 
567 static dladm_status_t
i_dladm_flow_remove(dladm_handle_t handle,char * flowname)568 i_dladm_flow_remove(dladm_handle_t handle, char *flowname)
569 {
570 	dld_ioc_removeflow_t	attr;
571 	dladm_status_t		status = DLADM_STATUS_OK;
572 
573 	(void) strlcpy(attr.rf_name, flowname,
574 	    sizeof (attr.rf_name));
575 
576 	if (ioctl(dladm_dld_fd(handle), DLDIOC_REMOVEFLOW, &attr) < 0)
577 		status = dladm_errno2status(errno);
578 
579 	return (status);
580 }
581 
582 
583 /* ARGSUSED */
584 dladm_status_t
dladm_flow_add(dladm_handle_t handle,datalink_id_t linkid,dladm_arg_list_t * attrlist,dladm_arg_list_t * proplist,char * flowname,boolean_t tempop,const char * root)585 dladm_flow_add(dladm_handle_t handle, datalink_id_t linkid,
586     dladm_arg_list_t *attrlist, dladm_arg_list_t *proplist, char *flowname,
587     boolean_t tempop, const char *root)
588 {
589 	dld_flowinfo_t		db_attr;
590 	flow_desc_t		flowdesc;
591 	mac_resource_props_t	mrp;
592 	dladm_status_t		status;
593 
594 	/* Extract flow attributes from attrlist */
595 	bzero(&flowdesc, sizeof (flow_desc_t));
596 	if (attrlist != NULL && (status = dladm_flow_attrlist_extract(attrlist,
597 	    &flowdesc)) != DLADM_STATUS_OK) {
598 		return (status);
599 	}
600 
601 	/* Extract resource_ctl and cpu_list from proplist */
602 	bzero(&mrp, sizeof (mac_resource_props_t));
603 	if (proplist != NULL && (status = dladm_flow_proplist_extract(proplist,
604 	    &mrp)) != DLADM_STATUS_OK) {
605 		return (status);
606 	}
607 
608 	/* Add flow in kernel */
609 	status = i_dladm_flow_add(handle, flowname, linkid, &flowdesc, &mrp);
610 	if (status != DLADM_STATUS_OK)
611 		return (status);
612 
613 	/* Add flow to DB */
614 	if (!tempop) {
615 		bzero(&db_attr, sizeof (db_attr));
616 		bcopy(&flowdesc, &db_attr.fi_flow_desc, sizeof (flow_desc_t));
617 		(void) strlcpy(db_attr.fi_flowname, flowname,
618 		    sizeof (db_attr.fi_flowname));
619 		db_attr.fi_linkid = linkid;
620 
621 		if ((status = i_dladm_flow_create_db(&db_attr, root)) !=
622 		    DLADM_STATUS_OK) {
623 			(void) i_dladm_flow_remove(handle, flowname);
624 			return (status);
625 		}
626 		/* set flow properties */
627 		if (proplist != NULL) {
628 			status = i_dladm_set_flow_proplist_db(handle, flowname,
629 			    proplist);
630 			if (status != DLADM_STATUS_OK) {
631 				(void) i_dladm_flow_remove(handle, flowname);
632 				return (status);
633 			}
634 		}
635 	}
636 	return (status);
637 }
638 
639 /*
640  * Remove a flow.
641  */
642 /* ARGSUSED */
643 dladm_status_t
dladm_flow_remove(dladm_handle_t handle,char * flowname,boolean_t tempop,const char * root)644 dladm_flow_remove(dladm_handle_t handle, char *flowname, boolean_t tempop,
645     const char *root)
646 {
647 	remove_db_state_t		state;
648 	dladm_status_t			status = DLADM_STATUS_OK;
649 	dladm_status_t			s = DLADM_STATUS_OK;
650 
651 	/* remove flow */
652 	status = i_dladm_flow_remove(handle, flowname);
653 	if ((status != DLADM_STATUS_OK) &&
654 	    (tempop || status != DLADM_STATUS_NOTFOUND))
655 		goto done;
656 
657 	/* remove flow from DB */
658 	if (!tempop) {
659 		bzero(&state, sizeof (state));
660 		(void) strlcpy(state.rs_newattr.fi_flowname, flowname,
661 		    sizeof (state.rs_newattr.fi_flowname));
662 		state.rs_found = B_FALSE;
663 
664 		/* flow DB */
665 		if (i_dladm_flow_remove_db(&state, root) < 0) {
666 			s = dladm_errno2status(errno);
667 			goto done;
668 		}
669 
670 		/* flow prop DB */
671 		s = dladm_set_flowprop(handle, flowname, NULL, NULL, 0,
672 		    DLADM_OPT_PERSIST, NULL);
673 	}
674 
675 done:
676 	if (!tempop) {
677 		if (s == DLADM_STATUS_OK) {
678 			if (status == DLADM_STATUS_NOTFOUND)
679 				status = s;
680 		} else {
681 			if (s != DLADM_STATUS_NOTFOUND)
682 				status = s;
683 		}
684 	}
685 	return (status);
686 }
687 
688 /*
689  * Get an existing flow in the DB.
690  */
691 
692 typedef struct get_db_state {
693 	int		(*gs_fn)(dladm_handle_t, dladm_flow_attr_t *, void *);
694 	void		*gs_arg;
695 	datalink_id_t	gs_linkid;
696 } get_db_state_t;
697 
698 /*
699  * For each flow which matches the linkid, copy all flow information
700  * to a new dladm_flow_attr_t structure and call the provided
701  * function.  This is used to display perisistent flows from
702  * the database.
703  */
704 
705 static int
i_dladm_flow_get_db_fn(void * arg,dld_flowinfo_t * grp)706 i_dladm_flow_get_db_fn(void *arg, dld_flowinfo_t *grp)
707 {
708 	get_db_state_t		*state = (get_db_state_t *)arg;
709 	dladm_flow_attr_t	attr;
710 	dladm_handle_t		handle = NULL;
711 
712 	if (grp->fi_linkid == state->gs_linkid) {
713 		attr.fa_linkid = state->gs_linkid;
714 		bcopy(grp->fi_flowname, &attr.fa_flowname,
715 		    sizeof (attr.fa_flowname));
716 		bcopy(&grp->fi_flow_desc, &attr.fa_flow_desc,
717 		    sizeof (attr.fa_flow_desc));
718 		bcopy(&grp->fi_resource_props, &attr.fa_resource_props,
719 		    sizeof (attr.fa_resource_props));
720 		(void) state->gs_fn(handle, &attr, state->gs_arg);
721 	}
722 	return (0);
723 }
724 
725 /*
726  * Walk through the flows defined on the system and for each flow
727  * invoke <fn>(<arg>, <flow>);
728  * Currently used for show-flow.
729  */
730 /* ARGSUSED */
731 dladm_status_t
dladm_walk_flow(int (* fn)(dladm_handle_t,dladm_flow_attr_t *,void *),dladm_handle_t handle,datalink_id_t linkid,void * arg,boolean_t persist)732 dladm_walk_flow(int (*fn)(dladm_handle_t, dladm_flow_attr_t *, void *),
733     dladm_handle_t handle, datalink_id_t linkid, void *arg, boolean_t persist)
734 {
735 	dld_flowinfo_t		*flow;
736 	int			i, bufsize;
737 	dld_ioc_walkflow_t	*ioc = NULL;
738 	dladm_flow_attr_t 	attr;
739 	dladm_status_t		status = DLADM_STATUS_OK;
740 
741 	if (fn == NULL)
742 		return (DLADM_STATUS_BADARG);
743 
744 	if (persist) {
745 		get_db_state_t state;
746 
747 		bzero(&state, sizeof (state));
748 
749 		state.gs_linkid = linkid;
750 		state.gs_fn = fn;
751 		state.gs_arg = arg;
752 		status = i_dladm_flow_walk_rw_db(i_dladm_flow_get_db_fn,
753 		    &state, NULL);
754 		if (status != DLADM_STATUS_OK)
755 			return (status);
756 	} else {
757 		bufsize = MIN_INFO_SIZE;
758 		if ((ioc = calloc(1, bufsize)) == NULL) {
759 			status = dladm_errno2status(errno);
760 			return (status);
761 		}
762 
763 		ioc->wf_linkid = linkid;
764 		ioc->wf_len = bufsize - sizeof (*ioc);
765 
766 		while (ioctl(dladm_dld_fd(handle), DLDIOC_WALKFLOW, ioc) < 0) {
767 			if (errno == ENOSPC) {
768 				bufsize *= 2;
769 				ioc = realloc(ioc, bufsize);
770 				if (ioc != NULL) {
771 					ioc->wf_linkid = linkid;
772 					ioc->wf_len = bufsize - sizeof (*ioc);
773 					continue;
774 				}
775 			}
776 			goto bail;
777 		}
778 
779 		flow = (dld_flowinfo_t *)(void *)(ioc + 1);
780 		for (i = 0; i < ioc->wf_nflows; i++, flow++) {
781 			bzero(&attr, sizeof (attr));
782 
783 			attr.fa_linkid = flow->fi_linkid;
784 			bcopy(&flow->fi_flowname, &attr.fa_flowname,
785 			    sizeof (attr.fa_flowname));
786 			bcopy(&flow->fi_flow_desc, &attr.fa_flow_desc,
787 			    sizeof (attr.fa_flow_desc));
788 			bcopy(&flow->fi_resource_props, &attr.fa_resource_props,
789 			    sizeof (attr.fa_resource_props));
790 
791 			if (fn(handle, &attr, arg) == DLADM_WALK_TERMINATE)
792 				break;
793 		}
794 	}
795 
796 bail:
797 	free(ioc);
798 	return (status);
799 }
800 
801 dladm_status_t
dladm_flow_init(dladm_handle_t handle)802 dladm_flow_init(dladm_handle_t handle)
803 {
804 	flow_desc_t		flowdesc;
805 	datalink_id_t		linkid;
806 	dladm_status_t		s, status = DLADM_STATUS_OK;
807 	char			name[MAXFLOWNAMELEN];
808 	char			line[MAXLINELEN];
809 	dld_flowinfo_t		attr;
810 	FILE			*fp;
811 
812 	if ((fp = fopen(DLADM_FLOW_DB, "r")) == NULL)
813 		return (DLADM_STATUS_DB_NOTFOUND);
814 
815 	while (fgets(line, MAXLINELEN, fp) != NULL) {
816 		/* skip comments */
817 		if (BLANK_LINE(line))
818 			continue;
819 
820 		(void) strtok(line, " \n");
821 
822 		s = dladm_flow_parse_db(line, &attr);
823 		if (s != DLADM_STATUS_OK) {
824 			status = s;
825 			continue;
826 		}
827 		bzero(&flowdesc, sizeof (flowdesc));
828 		bcopy(&attr.fi_flow_desc, &flowdesc, sizeof (flow_desc_t));
829 		(void) strlcpy(name, attr.fi_flowname,
830 		    sizeof (attr.fi_flowname));
831 		linkid = attr.fi_linkid;
832 
833 		s = i_dladm_flow_add(handle, name, linkid, &flowdesc, NULL);
834 		if (s != DLADM_STATUS_OK)
835 			status = s;
836 	}
837 	s = i_dladm_init_flowprop_db(handle);
838 	if (s != DLADM_STATUS_OK)
839 		status = s;
840 
841 	(void) fclose(fp);
842 	return (status);
843 }
844 
845 dladm_status_t
dladm_prefixlen2mask(int prefixlen,int maxlen,uchar_t * mask)846 dladm_prefixlen2mask(int prefixlen, int maxlen, uchar_t *mask)
847 {
848 	if (prefixlen < 0 || prefixlen > maxlen)
849 		return (DLADM_STATUS_BADARG);
850 
851 	while (prefixlen > 0) {
852 		if (prefixlen >= 8) {
853 			*mask++ = 0xFF;
854 			prefixlen -= 8;
855 			continue;
856 		}
857 		*mask |= 1 << (8 - prefixlen);
858 		prefixlen--;
859 	}
860 	return (DLADM_STATUS_OK);
861 }
862 
863 dladm_status_t
dladm_mask2prefixlen(in6_addr_t * mask,int plen,int * prefixlen)864 dladm_mask2prefixlen(in6_addr_t *mask, int plen, int *prefixlen)
865 {
866 	int		bits;
867 	int		i, end;
868 
869 	switch (plen) {
870 	case IP_ABITS:
871 		end = 3;
872 		break;
873 	case IPV6_ABITS:
874 		end = 0;
875 		break;
876 	default:
877 		return (DLADM_STATUS_BADARG);
878 	}
879 
880 	for (i = 3; i >= end; i--) {
881 		if (mask->_S6_un._S6_u32[i] == 0) {
882 			plen -= 32;
883 			continue;
884 		}
885 		bits = ffs(ntohl(mask->_S6_un._S6_u32[i])) - 1;
886 		if (bits == 0)
887 			break;
888 		plen -= bits;
889 	}
890 	*prefixlen = plen;
891 	return (DLADM_STATUS_OK);
892 }
893