| blob | 975adc4a7b9f6810eb3a7785475a231bca1d754c |
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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
27 /* enable debug output and some debug asserts */
28 #undef _IPQOS_CONF_DEBUG
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <libintl.h>
33 #include <signal.h>
34 #include <strings.h>
35 #include <sys/nvpair.h>
36 #include <stdio.h>
37 #include <netinet/in.h>
38 #include <arpa/inet.h>
39 #include <ctype.h>
40 #include <sys/socket.h>
41 #include <limits.h>
42 #include <netdb.h>
43 #include <fcntl.h>
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 #include <errno.h>
47 #include <libipp.h>
48 #include <ipp/ipp_config.h>
49 #include <ipp/ipgpc/ipgpc.h>
50 #include <ipp/ipp.h>
51 #ifdef _IPQOS_CONF_DEBUG
52 #include <assert.h>
53 #endif
54 #include <sys/sockio.h>
55 #include <syslog.h>
56 #include <stdarg.h>
57 #include <libintl.h>
58 #include <locale.h>
59 #include <pwd.h>
62 #if defined(_IPQOS_CONF_DEBUG)
64 /* debug level */
66 /*
67 */
68 RBK |
69 MHME |
70 KRET |
71 DIFF |
72 APPLY |
73 L2 |
74 L1 |
75 L0 |
80 #define IPQOSCDBG0(lvl, x)\
81 if (lvl & ipqosconf_dbg_flgs)\
82 (void) fprintf(stderr, x)
84 #define IPQOSCDBG1(lvl, x, y)\
85 if (lvl & ipqosconf_dbg_flgs)\
86 (void) fprintf(stderr, x, y)
88 #define IPQOSCDBG2(lvl, x, y, z)\
89 if (lvl & ipqosconf_dbg_flgs)\
90 (void) fprintf(stderr, x, y, z)
92 #define IPQOSCDBG3(lvl, x, y, z, a)\
93 if (lvl & ipqosconf_dbg_flgs)\
94 (void) fprintf(stderr, x, y, z, a)
96 #define IPQOSCDBG4(lvl, x, y, z, a, b)\
97 if (lvl & ipqosconf_dbg_flgs)\
98 (void) fprintf(stderr, x, y, z, a, b)
100 #define IPQOSCDBG5(lvl, x, y, z, a, b, c)\
101 if (lvl & ipqosconf_dbg_flgs)\
102 (void) fprintf(stderr, x, y, z, a, b, c)
106 #define IPQOSCDBG0(lvl, x)
107 #define IPQOSCDBG1(lvl, x, y)
108 #define IPQOSCDBG2(lvl, x, y, z)
109 #define IPQOSCDBG3(lvl, x, y, z, a)
110 #define IPQOSCDBG4(lvl, x, y, z, a, b)
111 #define IPQOSCDBG5(lvl, x, y, z, a, b, c)
117 /* function prototypes */
197 str_val_nd_t *);
224 boolean_t);
248 /*
249 * macros to call list functions with the more complex list element type
250 * cast to the skeletal type iqpos_list_el_t.
251 */
252 #define LIST_END(list, end)\
253 list_end((ipqos_list_el_t **)list, (ipqos_list_el_t ***)end)
254 #define ADD_TO_LIST(list, el)\
255 add_to_list((ipqos_list_el_t **)list, (ipqos_list_el_t *)el)
257 /*
258 * Macros to produce a quoted string containing the value of a
259 * preprocessor macro. For example, if SIZE is defined to be 256,
260 * VAL2STR(SIZE) is "256". This is used to construct format
261 * strings for scanf-family functions below.
262 */
263 #define QUOTE(x) #x
264 #define VAL2STR(x) QUOTE(x)
267 /* globals */
269 /* table of supported parameter types and enum value */
288 };
290 /* table of name to id mappings for originator field */
297 };
299 /* current parse line */
302 /* verbose output flag */
305 /* use syslog for msg reporting flag */
308 #ifdef _IPQOS_CONF_DEBUG
309 /*
310 * flag used to indicate that a rollback should be carried out regardless.
311 * Only settable during debug.
312 */
316 /*
317 * delivers messages to either syslog or stderr, dependant upon the
318 * the state of the flags use_syslog and verbose. The type
319 * of the msg as given in msg_type is indicated in the output msg.
320 *
321 * valid message types are:
322 * o MT_ERROR (standard error message)
323 * o MT_ENOSTR (error message with system error string appended)
324 * o MT_WARNING (warning message)
325 * o MT_LOG (logging message)
326 *
327 * Log messages only go to syslog. Warning messages only go to stderr
328 * and only when the verbose flag is set. All other messages go by default
329 * to the console; to syslog if syslog flag set, and to both if both
330 * syslog and verbose are set.
331 *
332 */
333 /*PRINTFLIKE2*/
334 static void
336 {
346 /*
347 * send msgs to syslog if use_syslog set (except warning msgs),
348 * or a log msg.
349 */
352 /* fill in format string */
355 /*
356 * print message to syslog with appropriate severity
357 */
362 /*
363 * for errno message type suffix with %m for syslog to
364 * interpret.
365 */
367 /*
368 * remove any newline in message parameter.
369 * syslog will reapply a newline for us later.
370 */
375 }
376 }
378 /*
379 * send msgs to stderr if use_syslog not set (except log msgs), or
380 * if verbose set.
381 */
384 /*
385 * prefix message with appropriate severity string
386 */
389 IPQOS_MSG_BUF_SZ);
394 }
396 IPQOS_MSG_BUF_SZ);
399 IPQOS_MSG_BUF_SZ);
402 IPQOS_MSG_BUF_SZ);
403 }
406 /*
407 * for errno message type suffix message with errno string
408 */
410 /*
411 * get rid of any newline in passed message.
412 * we'll apply another later.
413 */
418 IPQOS_MSG_BUF_SZ);
419 }
421 /*
422 * append a newline to message if not one already.
423 */
428 }
431 }
433 /* **************** kernel filter/class/params manipulation fns *********** */
436 /*
437 * modify the kernel parameters of the action action_nm using the nvlist
438 * parameter nvl and setting the stats according to stats_enable.
439 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
440 */
442 static int
447 boolean_t stats_enable)
448 {
455 /* create nvlist if NULL */
457 created++;
462 }
463 }
465 /* add params modify config type */
470 }
472 /*
473 * add module version
474 */
479 }
481 /* add stats_enable */
487 }
489 /* add ipqosconf as originator */
493 }
495 /* call lib to do modify */
499 /* invalid parameters */
504 action_name);
517 }
520 }
523 fail:
527 }
529 }
531 /*
532 * add a class to the kernel action action_name called class_name with
533 * stats set according to stats_enable and the first action set to
534 * first_action.
535 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
536 */
537 static int
542 boolean_t stats_enable,
544 {
553 /* create nvlist */
557 }
559 /* add 'add class' config type */
563 }
565 /*
566 * add module version
567 */
572 }
574 /* add class name */
578 }
580 /* add next action */
584 }
586 /* add stats_enable */
591 }
593 /* add ipqosconf as originator */
596 }
598 /* call lib to do modify */
601 /* ipgpc max classes */
607 IPGPC_NAME);
609 /* other errors */
616 }
619 }
622 fail:
625 }
628 /*
629 * modify the class in the kernel action action_name called class_name with
630 * stats set according to stats_enable and the first action set to
631 * first_action.
632 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
633 */
634 static int
639 boolean_t stats_enable,
642 {
651 /* create nvlist */
655 }
657 /* add 'modify class' config type */
662 }
664 /*
665 * add module version
666 */
671 }
673 /* add class name */
677 }
679 /* add next action */
683 }
685 /* add stats enable */
690 }
692 /* add originator ipqosconf */
695 }
697 /* call lib to do modify */
700 /* generic error message */
707 }
710 fail:
713 }
715 /*
716 * removes the class class_name from the kernel action action_name. The
717 * flags argument can currently be set to IPP_ACTION_DESTROY which will
718 * result in the action this class references being destroyed.
719 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
720 */
721 static int
727 {
734 /* allocate nvlist */
738 }
740 /* add 'remove class' config type */
745 }
747 /*
748 * add module version
749 */
754 }
756 /* add class name */
760 }
764 /* generic error message */
771 }
774 fail:
777 }
779 /*
780 * add the filter flt to the kernel action named action_name.
781 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
782 */
783 static int
788 {
798 /* add 'add filter' config type to filter nvlist */
802 }
804 /*
805 * add module version
806 */
811 }
813 /* add filter name to nvlist */
817 }
819 /* add class name to nvlist */
824 }
826 /* add ipqosconf as originator to nvlist */
829 }
831 /* add ipgpc specific nv entrys */
834 /* add src and dst nodes to nvlist if present */
841 }
847 }
849 /*
850 * add ip_version to private list element if present.
851 * NOTE: this value is of only real use to ipqosconf so
852 * it is placed in this opaque private field.
853 */
860 }
861 }
863 /* add filter instance if present */
869 }
870 }
874 /* invalid parameters */
881 /* max ipgpc filters/classes */
888 /* anything other errnos */
894 }
897 }
900 }
903 /*
904 * modify the filter flt in the kernel action named action_name.
905 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
906 */
907 static int
912 {
921 /* show src address and dst address if present */
922 #ifdef _IPQOS_CONF_DEBUG
924 uint_t tmp;
932 }
938 }
939 }
942 /* add 'modify filter' config type to filters nvlist */
947 }
949 /*
950 * add module version
951 */
956 }
958 /* add filter name to nvlist */
962 }
964 /* add class name to nvlist */
969 }
971 /* add originator ipqosconf to nvlist */
974 }
976 /* add ipgpc specific nvpairs */
979 /* add src and dst nodes to nvlist if present */
986 }
992 }
994 /*
995 * add ip_version to private list element if present.
996 * NOTE: this value is of only real use to ipqosconf so
997 * it is placed in this opaque private field.
998 */
1005 }
1006 }
1008 /* add filter instance if present */
1014 }
1015 }
1019 /* invalid parameters */
1026 /* any other errnos */
1032 }
1035 }
1038 }
1040 /*
1041 * remove the filter named filter_name instance number instance from the
1042 * kernel action action_name.
1043 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
1044 */
1045 static int
1051 {
1058 /* create nvlist */
1062 }
1064 /* add 'remove filter' config type to list */
1069 }
1071 /*
1072 * add module version
1073 */
1078 }
1080 /* add filter name to list */
1084 }
1086 /* add instance number if part of multi-instance filter */
1091 }
1093 /* call into lib to remove */
1096 /* generic error message */
1103 }
1106 }
1108 /* ******************************************************************* */
1111 /*
1112 * add originator nvpair set to ipqosconf to nvl.
1113 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
1114 */
1115 static int
1117 {
1123 }
1126 }
1128 /* ************************* differencing functions ************************ */
1131 /*
1132 * compares the contents of arrays array1 and array2, both of size size, and
1133 * returns B_TRUE or B_FALSE if they're equal or not respectively.
1134 * RETURNS: B_TRUE if equal, else B_FALSE.
1135 */
1136 static boolean_t
1141 {
1147 }
1149 }
1151 /*
1152 * difference class old against class new. It marks the new class as
1153 * modified if it is different.
1154 * RETURNS: IPQOS_CONF_SUCCESS.
1155 */
1156 static int
1160 {
1164 /* two different spec'd actions */
1170 }
1172 /* different stats values */
1178 }
1181 }
1183 /*
1184 * difference params set old against params set new of module module_name. It
1185 * marks the new params as modified if different.
1186 * RETURNS: if error IPQOS_CONF_ERR, else IPQOS_CONF_SUCCESS.
1187 */
1188 static int
1193 {
1200 /* diff stats */
1205 }
1207 /* diff module specific params */
1209 PL_PARAMS);
1212 }
1216 }
1219 }
1221 /*
1222 * differences filter old against filter new of module module_name. It marks
1223 * filter new as different if so.
1224 * RETURNS: if error IPQOS_CONF_ERR, else IPQOS_CONF_SUCCESS.
1225 */
1226 static int
1231 {
1238 /* compare class name */
1245 }
1247 /* compare module specific params */
1250 PL_FILTER);
1253 }
1258 }
1261 }
1264 /*
1265 * mark all the filters and classes in parameter action either
1266 * for deletion (if they are ipqosconf originated) or for modification.
1267 */
1268 static void
1270 {
1278 /* mark all non-permanent filters for del and permanent to modify */
1290 }
1291 }
1293 /* mark all non-permanent classes for del and permanent to modify */
1305 }
1306 }
1307 }
1309 /*
1310 * mark all classes and filters either new (non-permanent) or modified.
1311 */
1312 static void
1314 {
1322 /* mark all permanent filters as modified and all others new */
1336 }
1337 }
1339 /* mark all permanent classes as modified and all others new */
1352 }
1353 }
1354 }
1356 /*
1357 * Marks all the actions and their constituent elements in conf
1358 * as new.
1359 */
1360 static void
1363 {
1370 }
1371 }
1373 /*
1374 * differences the configuration in new against old marking the actions
1375 * and their contents appropriately.
1376 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
1377 */
1378 static int
1382 {
1390 /* check the new actions against the old */
1394 /* if action not in old mark it and it's contents as new */
1402 }
1404 /* if action in old diff old against new */
1409 }
1410 }
1412 /*
1413 * mark actions, and their contents, in old but not new that were
1414 * created by us for del.
1415 */
1424 }
1425 }
1428 }
1430 /*
1431 * differences action old against action new, comparing its classes, filters
1432 * and parameters. If it is different the new action is marked as modified
1433 * and it's different sub-objects are also marked approriately.
1434 * RETURNS: IPQOS_CONF_ERR if error, else IPQOS_CONF_SUCCESS.
1435 */
1436 static int
1440 {
1446 /* compare and mark classes */
1450 }
1452 /* compare and mark filters */
1456 }
1458 /* compare and mark parameters */
1462 }
1464 /* mark action as modified if params are */
1470 }
1473 }
1475 /*
1476 * differences the set of classes in new against those in old, marking any
1477 * that are new/modified, approriately in the new class, and any removed
1478 * in the old class appropriately. Also marks the action which has had an
1479 * object within marked, as modified.
1480 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
1481 */
1483 static int
1487 {
1496 /* loop through old classes checking for classes not present in new */
1502 /* if we created original class mark for deletion */
1510 /* mark old action */
1513 /*
1514 * if permanent class and next action created by us
1515 * copy it, set it's next action to continue and
1516 * add it to new action. This will cause the class
1517 * to be marked as and modified. This returns the class
1518 * to an assumed default state and prevents the
1519 * case where the class is pointing at an action
1520 * we want to remove and therefore couldn't without
1521 * this forced modify.
1522 */
1526 IPP_CONFIG_IPQOSCONF) {
1528 /* copy class */
1533 }
1535 /* set next action to continue */
1538 IPP_ANAME_CONT);
1540 /* add to news classes to be diffed below */
1542 }
1543 }
1544 }
1546 /* loop through new classes checking for new / modified classes */
1550 /* new ipqosconf class */
1563 /* existing ipqosconf/perm class */
1568 }
1572 }
1573 }
1574 }
1577 }
1579 /*
1580 * differences the set of filters in new against those in old, marking any
1581 * that are new/modified, approriately in the new filter/s, and any removed
1582 * in the old filter appropriately. Also marks the action which has had an
1583 * object within marked, as modified.
1584 * RETURNS: IPQOS_CONF_SUCCESS (we return an int for symmetry with diffclasses
1585 * and difffparams).
1586 */
1587 static int
1591 {
1599 /* check for new/modified filters */
1603 /* new ipqosconf filter */
1607 /* mark all instances of this filter as new */
1618 }
1620 }
1623 /* ipqosconf/permanent filter existed */
1625 /*
1626 * if ip node name force filter refresh - ie. mark
1627 * all old filter instances as todel and all new new.
1628 */
1632 /* init max previous filter instance */
1635 /* mark old instances for deletion */
1643 /*
1644 * check and update previous instance
1645 * max.
1646 */
1649 }
1655 /*
1656 * use the max previous instance + 1 for
1657 * the start of the new instance numbers.
1658 */
1661 /*
1662 * mark new instances for addition and
1663 * give new instance number.
1664 */
1676 }
1678 }
1681 /* mark old action */
1684 /* non-node name filter */
1686 /* compare and mark as modified if diff */
1691 }
1693 /* mark action if diff */
1695 }
1696 }
1697 }
1698 }
1700 /*
1701 * Check for deleted ipqosconf created filters and mark
1702 * any found for deletion.
1703 * For non-ipqosconf generated filters, including permanent
1704 * ones (none of these exist at the moment) we just leave
1705 * the filter unmarked.
1706 */
1712 /* mark all old instances for deletions */
1723 }
1725 }
1726 }
1727 }
1730 }
1733 /*
1734 * differences the elements of nvlists old and new using the types file
1735 * for module name to interpret the element types. It sets pdiff to either
1736 * 0 or 1 if they are the same or different respectively.
1737 * RETURNS: IPQOS_CONF_ERR if any errors, else IPQOS_CONF_SUCCESS.
1738 */
1739 static int
1745 place_t place)
1746 {
1756 ipqos_nvtype_t type;
1764 /* open stream to types file */
1770 }
1772 }
1773 start:
1774 /*
1775 * loop through each of the elements of the new list comparing
1776 * it with the old one if present. If the old one isn't present
1777 * then it is compared with the default value for that type (if
1778 * set). Any time the values are determined to be different
1779 * or the default value is to be used but isn't present the diff
1780 * param is set to 1 and we return.
1781 *
1782 * If the loop runs its course then the new and old nvlists are
1783 * reversed and the loop is entered for a second time.
1784 */
1788 /* get name */
1791 /*
1792 * get type.
1793 */
1799 }
1801 /* init diff to 1 */
1806 /* interface name */
1811 /* get new value */
1814 /* compare against old if present */
1818 /* diff values */
1821 /* not in old so see if new value is default */
1825 }
1827 }
1828 /* protocol */
1830 uchar_t proto;
1831 uchar_t oproto;
1840 }
1842 }
1843 /* port */
1854 }
1856 }
1857 /* action name / string */
1869 }
1871 }
1872 /* address mask / address */
1877 uint_t x;
1879 /*
1880 * all addresses are stored as v6 addresses, so
1881 * a uint32_t[4] array is used.
1882 */
1884 /* lookup new value */
1889 /* see if there's an old value and diff it */
1894 /* diff each of the 16 v6 address bytes */
1899 diff++;
1901 }
1902 }
1903 }
1905 }
1906 /* boolean */
1908 boolean_t bl;
1909 boolean_t obl;
1913 /* see if there's an old value and diff it */
1918 /* compare against default if present */
1923 }
1924 }
1926 }
1927 /* uint 8 */
1940 }
1941 }
1943 }
1944 /* int 16 */
1957 }
1958 }
1960 }
1961 /* uint16 */
1974 }
1975 }
1977 }
1978 /*
1979 * int32 and user.
1980 * Since user uids are stored in an int32 nvpair we can use
1981 * the same comparison code.
1982 */
1996 }
1997 }
1999 }
2000 /* uint32 */
2013 }
2014 }
2016 }
2017 /* enumeration */
2030 }
2031 }
2033 }
2042 }
2052 B_FALSE);
2054 }
2055 #ifdef _IPQOS_CONF_DEBUG
2057 /* shouldn't get here as all types should be covered */
2059 }
2060 #endif
2067 }
2072 }
2074 /* now compare all the stuff in the second list with the first */
2081 }
2087 }
2091 /* ************************** difference application *********************** */
2095 /*
2096 * causes all items marked as requiring change in actions and old_actions
2097 * to have the change applied.
2098 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
2099 */
2100 static int
2104 {
2111 /* add each item marked as new */
2116 }
2118 /* modify items marked for modification */
2123 }
2125 /* delete items marked for deletion */
2130 }
2133 }
2135 static int
2138 boolean_t rem_undo)
2139 {
2146 /*
2147 * we need to create ipgpc action before any others as some actions
2148 * such as ftpcl which make calls to it depend on it being there on
2149 * their creation.
2150 */
2159 }
2160 }
2162 /*
2163 * loop though action list and add any actions marked as
2164 * new/modified action and apply any additions there, then return.
2165 */
2171 }
2172 }
2175 }
2178 /*
2179 *
2180 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
2181 */
2182 static int
2185 boolean_t rem_undo)
2186 {
2196 /* if already visited return immediately */
2201 }
2205 /* recurse to last action in tree */
2209 /* if not virtual action */
2215 }
2216 }
2217 }
2221 /* if not virtual */
2227 }
2228 }
2229 }
2232 /* if action marked as new and not ipgpc, create */
2240 }
2241 }
2243 /* add any classes and filters marked as new */
2250 }
2253 }
2256 /*
2257 * Uses the contents of acts params nvlist and adds an originator
2258 * element set to ipqosconf and the stats parameter. This list
2259 * is then used as the parameter to a call to ipp_action_create to create
2260 * this action in the kernel.
2261 * RETURNS: IPQOS_CONF_ERR on err, else IPQOS_CONF_SUCCESS.
2262 */
2263 static int
2265 {
2275 /* alloc params nvlist if not already one */
2282 }
2283 }
2285 /*
2286 * add module version
2287 */
2292 }
2294 /* add action stats */
2300 }
2302 /* add ipqosconf originator id */
2306 }
2308 /* call into lib to create action */
2315 /* invalid params */
2330 }
2333 }
2335 /* mark action as created */
2339 }
2341 /*
2342 * for each of the filters in parameter filters if rem_undo is false and
2343 * the filter is marked as new or if rem_undo is true and the filter is
2344 * marked as deleted then add the filter to the kernel action named by action
2345 * and if successful mark as created.
2346 * RETURNS: IPQOS_CONF_ERR on errors, else IPQOS_CONF_SUCCESS.
2347 */
2348 static int
2353 boolean_t rem_undo)
2354 {
2360 /* loop through filters in filters param */
2362 /*
2363 * skip filter if in normal mode and not new filter or
2364 * if doing rollback and filter wasn't previously deleted.
2365 */
2369 }
2371 /* add filter to action */
2373 IPQOS_CONF_SUCCESS) {
2375 }
2377 /* mark as created */
2379 }
2382 }
2384 /*
2385 * for each of the classes in parameter classes if rem_undo is false and
2386 * the class is marked as new or if rem_undo is true and the class is
2387 * marked as deleted then add the class to the kernel action named by action
2388 * and if successful mark as created.
2389 * RETURNS: IPQOS_CONF_ERR on errors, else IPQOS_CONF_SUCCESS.
2390 */
2391 int
2396 boolean_t rem_undo) {
2403 /* for each class */
2405 /*
2406 * skip class if in normal mode and not new class or
2407 * if doing rollback and class wasn't deleted.
2408 */
2412 }
2414 /* add class to action */
2419 }
2421 /* mark class as created */
2423 }
2426 }
2428 /*
2429 * For each of the actions in actions remove the action if marked as
2430 * such or remove any objects within marked as such.
2431 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
2432 */
2433 static int
2436 boolean_t add_undo)
2437 {
2444 /*
2445 * loop through actions removing any actions, or action contents
2446 * that are marked as such.
2447 */
2452 }
2453 }
2456 }
2458 /*
2459 * Deletes this action if marked for deletion or any of it's contents marked
2460 * for deletion. If the action is marked for deletion any actions referencing
2461 * this action are destroyed first if marked or have their contents destroyed
2462 * if marked. This is recursive.
2463 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
2464 */
2465 static int
2468 boolean_t add_undo)
2469 {
2480 /* return immmediately if previously visited in remove phase */
2485 }
2489 /* if this action is to be deleted */
2495 /* modify parent actions first */
2501 }
2502 }
2504 /* delete this action */
2512 }
2514 /* flag as deleted */
2518 /* if modified action */
2522 /* loop through removing any filters marked for del */
2529 /* do deletion */
2539 }
2541 /* flag deleted */
2544 }
2545 }
2547 /* remove any classes marked for del */
2554 /* do deletion */
2563 }
2565 /* flag deleted */
2568 }
2569 }
2571 /* mark action as having been modified */
2574 }
2577 }
2579 /*
2580 * for each of the actions in parameter actions apply any objects marked as
2581 * modified as a modification to the kernel action represented.
2582 * RETURNS: IPQOS_CONF_ERR on err, else IPQOS_CONF_SUCCESS.
2583 */
2584 static int
2586 {
2596 /* loop through actions in parameter actions */
2600 /* skip unchanged actions */
2604 }
2606 /* apply any parameter mods */
2614 }
2617 }
2619 /* apply any class mods */
2628 }
2630 /* mark modification done */
2632 }
2633 }
2635 /* apply any filter mods */
2643 }
2645 /* mark modification done */
2647 }
2648 }
2650 /* mark action modified */
2653 }
2656 }
2658 /*
2659 * For each of the objects of each of the actions in nactions that are
2660 * marked as having been modified the object modification is done in
2661 * reverse using the same named object from oactions.
2662 * RETURNS: IPQOS_CONF_ERR on error, IPQOS_CONF_SUCCESS otherwise.
2663 */
2664 static int
2668 {
2680 /* loop throught new actions */
2685 /*
2686 * if the action was new then it will be removed and
2687 * any permamanent items that were marked for modify
2688 * will dissappear, so ignore action.
2689 */
2692 }
2694 /* if parameters were modified switch them back */
2703 }
2704 }
2706 /* for each filter in action if filter modified switch back */
2717 }
2718 }
2719 }
2721 /* for each class in action if class modified switch back */
2732 }
2735 }
2736 }
2737 }
2738 }
2740 /*
2741 * Go through the old actions modifying perm filters and classes
2742 * whose action was deleted.
2743 *
2744 */
2749 }
2757 }
2758 }
2759 }
2768 }
2769 }
2771 }
2772 }
2775 }
2778 /*
2779 * causes all changes marked as being done in actions and old_actions
2780 * to be undone.
2781 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
2782 */
2783 static int
2787 {
2793 /* re-add items that were deleted */
2798 }
2800 /* change modified items back how they were */
2805 }
2807 /* remove new items that were added */
2812 }
2815 }
2817 /* ******************************* print config **************************** */
2819 /*
2820 * Prints the username of the user with uid 'uid' to 'fp' if the uid belongs
2821 * to a known user on the system, otherwise just print 'uid'.
2822 */
2823 static void
2826 uid_t uid)
2827 {
2837 }
2838 }
2840 /*
2841 * print either a single value of start to fp (if start equals end), else
2842 * print start'-'end if start is the smaller of the two values, otherwise
2843 * print end'-'start.
2844 */
2845 static void
2850 {
2857 }
2862 }
2864 /*
2865 * print the contents of the array arr to fp in the form:
2866 * {0-6:1;7-12:2;13:3.....} or {0-6:GREEN;7-12:YELLOW:...}
2867 * dependant upon whether this is an integer or enumerated array resectively
2868 * (if enum_nvs isn't set to NULL this is assumed to be an enumerated array);
2869 * where 0-6 is the range of indexes with value 1 (or GREEN), 7-12 the range
2870 * with value 2 (or YELLOW), and so forth. size is the array size and llimit
2871 * and ulimit are the lower and upper limits of the array values printed
2872 * respectively. For enumerated arrays enum_nvs carries the list of name
2873 * and value pairs and ulimit and llimit parameters are ignored and instead
2874 * determined from the enum_nvs list.
2875 */
2876 static void
2885 {
2895 /*
2896 * if an enumeration retrieve value range.
2897 */
2901 /*
2902 * print opening curl.
2903 */
2908 /*
2909 * for each value in range.
2910 */
2915 /*
2916 * scan array and print ranges of indexes with value x.
2917 */
2919 /*
2920 * get first occurence of value for this range.
2921 */
2923 y++;
2928 }
2931 /*
2932 * get last occurence of value for this range.
2933 */
2935 y++;
2938 /*
2939 * print entry delimiter (semi-colon)? It must be
2940 * the first range for this value and this mustn't
2941 * be the first 'ranges:value' entry.
2942 */
2948 }
2950 /*
2951 * print comma (range delimeter) only if there was
2952 * a previous range for this value.
2953 */
2958 }
2960 /*
2961 * print range.
2962 */
2964 }
2965 /*
2966 * only print a colon and value if we found a range with
2967 * this value.
2968 */
2972 /*
2973 * print numeric/symbolic value.
2974 */
2979 }
2980 }
2981 }
2983 /*
2984 * print closing curl.
2985 */
2989 }
2991 /* print the protocol name for proto, or if unknown protocol number proto. */
2992 static void
2996 {
3005 }
3006 }
3008 /*
3009 * prints the name associated with interface with index ifindex to fp.
3010 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
3011 */
3012 static int
3016 {
3029 /* open socket */
3034 }
3036 /* get number of lifreq structs that need to be alloc'd for */
3045 }
3047 /* allocate buffer for SIOGLIFCONF ioctl */
3055 }
3057 /* setup lifconf params for ioctl */
3064 /* do SIOCGLIFCONF ioctl */
3072 }
3075 /*
3076 * for each interface name given in the returned lifreq list get
3077 * it's index and compare with ifindex param. Break if equal.
3078 */
3084 }
3087 }
3088 }
3095 }
3096 /* truncate any logical suffix */
3100 }
3102 /* print interface name */
3106 }
3108 /*
3109 * print to fp the enumeration clause evaluating to the value val using the
3110 * names/values given in enum_nvs.
3111 */
3112 static void
3117 {
3122 /* for each value in enum_nvs if same bit set in val print name */
3131 }
3132 }
3134 }
3135 }
3138 /* prints the service name of port, or if unknown the number to fp. */
3139 static void
3143 {
3152 }
3153 }
3155 /*
3156 * prints tp fp the name and value of all user specifiable parameters in the
3157 * nvlist.
3158 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
3159 */
3160 static int
3168 place_t place)
3169 {
3173 ipqos_nvtype_t type;
3184 /* open stream to types file */
3190 }
3192 }
3195 /* go through list getting param name and type and printing it */
3200 /* get nvpair name */
3204 /* skip ipgpc params that are not explicitly user settable */
3213 }
3217 /*
3218 * get parameter type from types file.
3219 */
3225 }
3227 /*
3228 * for map entries we don't print the map value, only
3229 * the index value it was derived from.
3230 */
3234 }
3236 /*
3237 * the ifindex is converted to the name and printed out
3238 * so print the parameter name as ifname.
3239 */
3243 /*
3244 * we may not print the address due to us instead printing
3245 * the node name in printfilter, therefore we leave the
3246 * printing of the parameter in the addresses switch case code.
3247 */
3252 }
3261 }
3263 boolean_t bl;
3270 }
3277 }
3285 }
3287 uint_t tmp;
3290 uchar_t ftype;
3294 /*
3295 * skip addresses that have node names for
3296 * non printall listings.
3297 */
3304 }
3306 /* we skipped this above */
3314 /* get filter type */
3324 }
3325 /* get mask */
3330 IPGPC_SADDR_MASK,
3334 IPGPC_DADDR_MASK,
3336 }
3338 /* print address/mask to fp */
3344 }
3350 /*
3351 * print list of tokens resulting in val
3352 */
3357 }
3364 }
3371 }
3374 uchar_t u8;
3379 }
3386 }
3393 }
3400 }
3407 }
3417 /*
3418 * read array info from types file.
3419 */
3422 module);
3424 /*
3425 * print array with numbers, or symbols
3426 * if enumerated.
3427 */
3431 tab_inserts);
3434 arr_enum_nvs);
3435 }
3436 }
3438 }
3440 uid_t uid;
3445 }
3446 #ifdef _IPQOS_CONF_DEBUG
3448 /*
3449 * we should have catered for all used data
3450 * types that readtype returns.
3451 */
3453 }
3454 #endif
3455 }
3458 }
3462 }
3464 /*
3465 * print a parameter clause for the parmeters given in params to fp.
3466 * If printall is set, then the originator of the parameter object is printed.
3467 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
3468 */
3469 static int
3476 {
3480 /* print opening clause */
3485 /* print originator name if printall flag set */
3491 }
3493 /* print global stats */
3499 /* print module specific parameters */
3504 }
3510 }
3512 /*
3513 * print the interpreted name of the action_nm parameter if it is a special
3514 * action, else action_nm verbatim to fp parameter.
3515 */
3516 static void
3518 {
3528 }
3529 }
3531 /*
3532 * print a class clause for class to fp. If printall is set the originator
3533 * is printed.
3534 */
3535 static void
3541 {
3543 /* print opening clause */
3549 /* if printall flag print originator name */
3555 }
3557 /* print name, next action and stats enable */
3571 }
3573 /*
3574 * Returns a ptr to the originator name associated with origid. If unknown
3575 * id returns ptr to "unknown".
3576 * RETURNS: ptr to originator name, or if id not known "unknown".
3577 */
3580 {
3584 /* scan originators table for origid */
3589 /* if we've reached end of array due to unknown type return "unknown" */
3593 }
3596 }
3598 /*
3599 * print a filter clause for filter pointed to by filter out to fp. If printall
3600 * is set then the originator is printed, for filters with node names instance
3601 * numbers are printed, and the filter pointer isn't advanced to point at the
3602 * last instance of the printed filter.
3603 * RETURNS: IPQOS_CONF_ERR on errors, else IPQOS_CONF_SUCCESS.
3604 */
3605 static int
3612 {
3616 /* print opening clause */
3621 /* print originator if printall flag set */
3627 }
3629 /* print name and class */
3638 /* print the instance if printall and potential mhomed addresses */
3643 }
3645 /* print node names if any */
3651 }
3656 }
3658 /* print ip_version enumeration if set */
3665 }
3668 }
3670 }
3672 /* print other module specific parameters parameters */
3678 }
3683 /*
3684 * if not printall advance filter parameter to last instance of this
3685 * filter.
3686 */
3694 }
3696 }
3697 }
3700 }
3702 /*
3703 * Returns a pointer to str if no whitespace is present, else it returns
3704 * a pointer to a string with the contents of str enclose in double quotes.
3705 * This returned strings contents may change in subsequent calls so a copy
3706 * should be made of it if the caller wishes to retain it.
3707 */
3710 {
3716 /*
3717 * Just return str if no whitespace.
3718 */
3720 ;
3725 /*
3726 * if first run just allocate buffer of
3727 * strlen(str) + 2 quote characters + NULL terminator.
3728 */
3731 /*
3732 * Not first run, so check if we have a big enough buffer
3733 * and if not reallocate the buffer to a sufficient size.
3734 */
3736 }
3740 /*
3741 * copy string into buffer with quotes.
3742 */
3748 }
3750 /*
3751 * print an action clause for action to fp. If the printall flag is set
3752 * then all filters and classes (regardless of their originator) and
3753 * their originators are displayed.
3754 * RETURNS: IPQOS_CONF_ERR on errors, else IPQOS_CONF_SUCCESS.
3755 */
3756 static int
3762 {
3768 /* print opening clause, module and name */
3778 /* print params clause */
3785 }
3787 /*
3788 * print classes clause for each class if printall is set, else
3789 * just ipqosconf created or permanent classes.
3790 */
3797 }
3798 }
3800 /*
3801 * print filter clause for each filter if printall is set, else
3802 * just ipqosconf created or permanent filters.
3803 */
3813 }
3814 }
3815 }
3821 }
3825 /* *************************************************************** */
3828 static void
3832 {
3836 }
3837 }
3839 static void
3843 {
3846 }
3848 /*
3849 * given mask calculates the number of bits it spans. The mask must be
3850 * continuous.
3851 * RETURNS: number of bits spanned.
3852 */
3853 static int
3857 {
3862 /*
3863 * loop through from lowest byte to highest byte counting the
3864 * number of zero bits till hitting a one bit.
3865 */
3867 /*
3868 * zero byte, so add 8 to zeros.
3869 */
3872 /*
3873 * non-zero byte, add zero count to zeros.
3874 */
3878 }
3879 }
3880 /*
3881 * translate zero bits to 32 or 128 bit mask based on af.
3882 */
3887 }
3890 }
3892 /*
3893 * Sets the first prefix_len bits in the v4 or v6 address (based upon af)
3894 * contained in the v6 address referenced by addr to 1.
3895 */
3896 static void
3898 {
3908 /* zero addr */
3912 /* set which 32bits in *addr are relevant to this af */
3917 /* AF_INET6 */
3920 }
3921 /*
3922 * go through each of the 32bit quantities in 128 bit in6_addr_t
3923 * and set appropriate bits according to prefix_len.
3924 */
3927 /* does the prefix apply to this 32bits? */
3931 /* is this 32bits fully masked? */
3937 }
3943 }
3945 /* translate to NBO */
3947 }
3948 }
3950 /*
3951 * search nvlist for an element with the name specified and return a ptr
3952 * to it if found.
3953 * RETURNS: pointer to nvpair named name if found, else NULL.
3954 */
3957 {
3970 }
3972 }
3975 }
3977 /*
3978 * returns a string containing module_name '.' name.
3979 * RETURNS: IPQOS_CONF_ERR if error, else IPQOS_CONF_SUCCESS.
3980 */
3985 {
3995 }
4002 }
4004 #if 0
4006 /*
4007 * check if element with matching s1 and s2 string is in table table.
4008 * RETURNS: 1 if found else 0.
4009 */
4010 static int
4015 {
4019 /* loop through table till matched or end */
4023 ss++;
4024 }
4028 }
4031 }
4034 /*
4035 * check whether name is a valid action/class/filter name.
4036 * RETURNS: IPQOS_CONF_ERR if invalid name else IPQOS_CONF_SUCCESS.
4037 */
4038 static int
4040 {
4044 /* first char can't be '!' */
4049 }
4051 /* can't exceed IPQOS_CONF_NAME_LEN size */
4056 }
4059 }
4061 /* ********************* string value manip fns ************************** */
4064 /*
4065 * searches through the str_val_nd_t list of string value pairs finding
4066 * the minimum and maximum values for value and places them in the
4067 * integers pointed at by min and max.
4068 */
4069 static void
4074 {
4078 }
4085 }
4086 }
4088 /*
4089 * add an entry with string string and value val to sv_entrys.
4090 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
4091 */
4092 static int
4097 {
4102 val);
4104 /* alloc new node */
4109 }
4111 /* populate node */
4120 }
4123 /* place at start of sv_entrys list */
4129 }
4132 /* frees all the elements of sv_entrys. */
4133 static void
4136 {
4148 }
4149 }
4151 /*
4152 * finds the value associated with string and assigns it to value ref'd by
4153 * val.
4154 * RETURNS: IPQOS_CONF_ERR if string not found, else IPQOS_CONF_SUCCESS.
4155 */
4156 static int
4161 {
4167 /* loop through list and exit when found or list end */
4172 }
4174 }
4176 /* ret error if not found */
4180 }
4186 }
4189 /* ************************ conf file read fns ***************************** */
4191 /*
4192 * Reads a uid or username from string 'str' and assigns either the uid
4193 * or associated uid respectively to storage pointed at by 'uid'. The
4194 * function determines whether to read a uid by checking whether the first
4195 * character of 'str' is numeric, in which case it reads a uid; otherwise it
4196 * assumes a username.
4197 * RETURNS: IPQOS_CONF_ERR if a NULL string pointer is passed, the read uid
4198 * doesn't have an entry on the system, or the read username doesn't have an
4199 * entry on the system.
4200 */
4201 static int
4205 {
4213 /*
4214 * Check if this appears to be a uid, and if so check that a
4215 * corresponding user exists.
4216 */
4218 /*
4219 * Read a 32bit integer and check in doing so that
4220 * we have consumed the whole string.
4221 */
4234 }
4235 }
4237 }
4239 /*
4240 * Reads a range from range_st, either of form 'a-b' or simply 'a'.
4241 * In the former case lower and upper have their values set to a
4242 * and b respectively; in the later lower and upper have both
4243 * their values set to a.
4244 * RETURNS: IPQOS_CONF_ERR if there's a parse error, else IPQOS_CONF_SUCCESS.
4245 */
4246 static int
4251 {
4257 /*
4258 * get range boundarys.
4259 */
4272 }
4281 }
4282 }
4285 }
4287 /*
4288 * Reads the values of an integer array from fp whose format is:
4289 * '{'RANGE[,RANGE[..]]:VALUE[;RANGE:VALUE[..]]'}', creates an array of size
4290 * arr_size, applies the values to it and points arrp at this array.
4291 * RANGE is one set of array indexes over which this value is to
4292 * be applied, and VALUE either an integer within the range
4293 * llimit - ulimit, or if enum_nvs isn't NULL, an enumeration value
4294 * found in the list enum_nvs. Those values which aren't explicity set
4295 * will be set to -1.
4296 *
4297 * RETURNS: IPQOS_CONF_ERR on resource or parse error, else IPQOS_CONF_SUCCESS.
4298 */
4299 static int
4308 {
4327 /*
4328 * read beginning curl.
4329 */
4334 }
4336 /*
4337 * allocate and initialise array for holding read values.
4338 */
4343 }
4346 /*
4347 * read whole array declaration string into buffer.
4348 * this is because readtoken doesn't interpret our
4349 * delimeter values specially and may return them
4350 * within another string.
4351 */
4360 }
4363 }
4366 /*
4367 * loop reading "ranges ':' value;" till end of buffer.
4368 */
4375 }
4379 /*
4380 * get value of number or enumerated symbol.
4381 */
4383 /*
4384 * get rid of surrounding whitespace so as not to
4385 * confuse read_enum_value.
4386 */
4394 tmp++;
4395 }
4396 }
4398 /*
4399 * read enumeration value.
4400 */
4411 }
4414 /*
4415 * check value within valid range.
4416 */
4420 }
4421 }
4423 /*
4424 * loop reading ranges for this value.
4425 */
4438 }
4440 /*
4441 * check range valid for array size.
4442 */
4447 }
4449 /*
4450 * add this value to array indexes within range.
4451 */
4455 /*
4456 * get next range.
4457 */
4459 }
4462 }
4466 array_err:
4471 }
4473 static int
4475 {
4480 }
4482 }
4484 static int
4486 {
4492 }
4495 }
4498 }
4500 static int
4502 {
4507 }
4510 }
4513 }
4515 static int
4517 {
4522 }
4525 }
4528 }
4530 static int
4532 {
4537 }
4540 }
4543 }
4545 static int
4547 {
4552 }
4555 }
4558 }
4560 /*
4561 * retrieves the index associated with the interface named ifname and assigns
4562 * it to the int pointed to by ifindex.
4563 * RETURNS: IPQOS_CONF_ERR on errors, else IPQOS_CONF_SUCCESS.
4564 */
4565 static int
4569 {
4575 /* open socket */
4580 }
4582 /* copy ifname into lifreq */
4586 /* do SIOGLIFINDEX ioctl */
4591 }
4593 /* Warn if a virtual interface is specified */
4597 }
4601 }
4603 /*
4604 * Case insensitively compares the string in str with IPQOS_CONF_TRUE_STR
4605 * and IPQOS_CONF_FALSE_STR and sets boolean pointed to by bool accordingly.
4606 * RETURNS: if failure to match either IPQOS_CONF_ERR, else IPQOS_CONF_SUCCESS.
4607 */
4608 static int
4610 {
4618 }
4621 }
4623 /*
4624 * reads a protocol name/number from proto_str and assigns the number
4625 * to the uint8 ref'd by proto.
4626 * RETURNS: If not a valid name or protocol number IPQOS_CONF_ERR, else
4627 * IPQOS_CONF_SUCCESS.
4628 */
4629 static int
4631 {
4639 /* try name lookup */
4645 /* check valid protocol number */
4650 }
4651 }
4654 }
4656 /*
4657 * reads either a port service, or a port number from port_str and assigns
4658 * the associated port number to short ref'd by port.
4659 * RETURNS: If invalid name and number IPQOS_CONF_ERR, else IPQOS_CONF_SUCCESS.
4660 */
4661 static int
4663 {
4670 /* try service name lookup */
4673 /* failed name lookup so read port number */
4678 }
4682 }
4685 }
4688 /*
4689 * Reads a curly brace, a string enclosed in double quotes, or a whitespace/
4690 * curly brace delimited string. If a double quote enclosed string the
4691 * closing quotes need to be on the same line.
4692 * RETURNS:
4693 * on reading a CURL_BEGIN token it returns IPQOS_CONF_CURL_BEGIN,
4694 * on reading a CURL_END token it returns IPQOS_CONF_CURL_END,
4695 * on reading another valid token it returns IPQOS_CONF_SUCCESS.
4696 * for each of these token is set to point at the read string.
4697 * at EOF it returns IPQOS_CONF_EOF and if errors it returns IPQOS_CONF_ERR.
4698 */
4699 static int
4703 {
4716 /* if first call initialize line buf to default size */
4724 }
4725 }
4727 /* set buffer postition and size to use whole buffer */
4733 /*
4734 * loop reading lines until we've read a line with a non-whitespace
4735 * char.
4736 */
4739 /* if no leftover from previous invocation */
4743 /*
4744 * loop reading into buffer doubling if necessary until
4745 * we have either read a complete line or reached the
4746 * end of file.
4747 */
4753 /* if read error */
4761 /* end of file */
4767 }
4769 /* if read a newline */
4772 lineno++;
4775 /* if read the last line */
4780 /*
4781 * not read a full line so buffer size
4782 * is too small, double it and retry.
4783 */
4794 }
4796 /*
4797 * make parameters to fgets read
4798 * into centre of doubled buffer
4799 * so we retain what we've
4800 * already read.
4801 */
4804 }
4805 }
4806 }
4810 /* previous leftover, assign to st */
4815 }
4817 /* truncate at comment */
4822 }
4824 /* Skip any whitespace */
4827 st++;
4828 }
4833 /* find end of token */
4837 /* if curl advance 1 char */
4840 tmp++;
4843 /* if dbl quote read until matching quote */
4846 quoted++;
4850 tmp++;
4851 }
4857 }
4859 /* normal token */
4861 /* find first whitespace, curl, newline or string end */
4865 tmp++;
4866 }
4867 }
4869 /* copy token to return */
4876 }
4880 /* if just read quoted string remove quote from remaining string */
4883 tmp++;
4884 }
4886 /* if not end of string, store rest for latter parsing */
4890 }
4892 /* for curl_end and curl_begin return special ret codes */
4899 }
4900 }
4903 }
4905 /*
4906 * Reads an enumeration bitmask definition from line. The format is:
4907 * { NAME=VAL, NAME2=VAL2 }. The resulting names and values are returned.
4908 * RETURNS: NULL on error, else ptr to name/values.
4909 */
4912 {
4925 /* read opening brace */
4933 }
4935 /*
4936 * loop reading 'name = value' entrys seperated by comma until
4937 * reach closing brace.
4938 */
4945 }
4947 /*
4948 * read name - read until whitespace, '=', closing curl,
4949 * or string end.
4950 */
4960 /* finished definition, exit loop */
4963 }
4965 /* store name */
4972 }
4977 /* read assignment */
4983 }
4985 /* read value */
4990 cp);
4992 }
4994 /* add name value to set */
5000 }
5004 /* try reading comma */
5010 /* no comma, advance to char past value last read */
5013 }
5014 }
5017 fail:
5022 /* if a parse error */
5027 }
5030 }
5032 /*
5033 * Given mapped_list with is a comma seperated list of map names, and value,
5034 * which is used to index into these maps, the function creates x new entries
5035 * in nvpp, where x is the number of map names specified. Each of these
5036 * entries has the value from the map in the position indexed by value and
5037 * with name module.${MAP_NAME}. The maps are contained in the modules config
5038 * file and have the form:
5039 * map map1 uint32 1,23,32,45,3
5040 * As you can see the map values are uint32, and along with uint8 are the
5041 * only supported types at the moment.
5042 *
5043 * RETURNS: IPQOS_CONF_ERR if one of the maps specified in mapped_list
5044 * doesn't exist, if value is not a valid map position for a map, or if
5045 * there's a resource failure. otherwise IPQOS_CONF_SUCCESS is returned.
5046 */
5047 static int
5054 {
5057 ipqos_nvtype_t type;
5060 place_t place;
5069 /*
5070 * get map info from types file.
5071 */
5077 }
5079 /*
5080 * Just keep browsing the list till we get to the element
5081 * with the index from the value parameter or the end.
5082 */
5090 }
5093 }
5095 }
5098 /*
5099 * create fully qualified parameter name for map value.
5100 */
5104 }
5106 /*
5107 * add map value with fqn to parameter nvlist.
5108 */
5120 }
5122 }
5131 }
5133 }
5140 map_name);
5142 }
5143 }
5147 }
5150 }
5152 /*
5153 * Parses the string info_str into it's components. Its format is:
5154 * SIZE','[ENUM_DEF | RANGE], where SIZE is the size of the array,
5155 * ENUM_DEF is the definition of the enumeration for this array,
5156 * and RANGE is the set of values this array can accept. In
5157 * the event this array has an enumeration definition enum_nvs is
5158 * set to point at a str_val_nd_t structure which stores the names
5159 * and values associated with this enumeration. Otherwise, if this
5160 * is not an enumerated array, lower and upper are set to the lower
5161 * and upper values of RANGE.
5162 * RETURNS: IPQOS_CONF_ERR due to unexpected parse errors, else
5163 * IPQOS_CONF_SUCCESS.
5164 */
5165 static int
5173 {
5185 }
5187 /*
5188 * read size.
5189 */
5196 }
5199 /*
5200 * check we have another string.
5201 */
5206 }
5209 /*
5210 * check if enumeration set or integer set and read enumeration
5211 * definition or integer range respectively.
5212 */
5219 }
5225 }
5226 }
5229 fail:
5233 }
5235 /*
5236 * reads the value of an enumeration parameter from first_token and fp.
5237 * first_token is the first token of the value.
5238 * The format expected is NAME | { NAME1 [, NAME2 ] [, NAME3 ] }.
5239 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
5240 */
5241 static int
5247 {
5258 /* init param val */
5261 /* first token not curl_begin, so lookup its value */
5270 }
5272 /* curl_begin, so read values till curl_end, dicing at ',' */
5275 name_expected++;
5279 /*
5280 * no leftover from pervious iteration so read new
5281 * token. This leftover happens because readtoken
5282 * doesn't interpret comma's as special characters
5283 * and thus could return 'val1,val2' as one token.
5284 * If this happens the val1 will be used in the
5285 * current iteration and what follows saved in lo
5286 * for processing by successive iterations.
5287 */
5298 }
5304 }
5314 }
5316 /*
5317 * check if this token contains a ',' and
5318 * if so store it and what follows for next
5319 * iteration.
5320 */
5328 }
5332 }
5335 /* get name value and add to total val */
5344 }
5347 name_expected--;
5349 /* comma or curl end accepted */
5352 /* we've reached curl_end so break */
5358 /* not curl end and not comma */
5366 }
5368 /*
5369 * store anything after the comma for next
5370 * iteration.
5371 */
5378 }
5380 }
5382 name_expected++;
5383 }
5386 }
5387 }
5392 }
5394 /*
5395 * read the set of permanent classes/filter from the types file ref'd by tfp
5396 * and store them in a string table pointed to by perm_items,
5397 * with *nitems getting set to number of items read. perm_filters is set
5398 * to 1 if we're searching for permanent filters, else 0 for classes.
5399 * RETURNS: IPQOS_CONF_ERR if any errors, else IPQOS_CONF_SUCCESS.
5400 */
5401 static int
5408 {
5422 /* seek to start of types file */
5427 }
5429 /* select which marker were looking for */
5435 }
5437 /* scan file line by line till end */
5441 /*
5442 * if the line is marked as containing a default item name
5443 * read the name, extend the items string array
5444 * and store the string off the array.
5445 */
5457 marker);
5459 }
5461 /* extend items array to accomodate new item */
5469 }
5471 /* copy and store item name */
5477 }
5480 cnt++;
5484 name);
5485 }
5486 }
5492 fail:
5497 }
5499 /*
5500 * Searches types file ref'd by tfp for the parameter named name
5501 * with the place corresponding with place parameter. The format
5502 * of the lines in the file are:
5503 * PLACE NAME TYPE [ ENUM_DEF ] [ DEFAULT_STR ]
5504 * The ENUM_DEF is an enumeration definition and is only present
5505 * for parameters of type enum. DEFAULT_STR is a default value for
5506 * this parameter. If present type is set to the appropriate type
5507 * enumeration and dfltst filled with DEFAULT_STR if one was set.
5508 * Also if the type is enum enum_nvps is made to point at a
5509 * set of name value pairs representing ENUM_DEF.
5510 *
5511 * RETURNS: If any resource errors occur, or a matching parameter
5512 * isn't found IPQOS_CONF_ERR is returned, else IPQOS_CONF_SUCCESS.
5513 */
5514 static int
5522 boolean_t allow_ipgpc_priv,
5524 {
5539 /*
5540 * if allow_ipgpc_priv is true then we allow ipgpc parameters that are
5541 * private between ipqosconf and ipgpc. eg. address masks, port masks.
5542 */
5547 }
5563 }
5566 }
5568 /*
5569 * read upto and including module version line.
5570 */
5575 /*
5576 * loop reading lines of the types file until named parameter
5577 * found or EOF.
5578 */
5581 /*
5582 * check whether blank or commented line; if so skip
5583 */
5587 }
5591 /*
5592 * read place, param, type and if present default str
5593 * from line.
5594 */
5604 module_name);
5607 }
5609 /*
5610 * if the place and name match no need to look any further.
5611 */
5620 found++;
5622 }
5623 }
5624 }
5628 lineno);
5630 }
5632 /*
5633 * set the place parameter to the actual place when the PL_ANY flag
5634 * was set.
5635 */
5643 }
5644 }
5646 /*
5647 * get type enumeration
5648 */
5652 }
5653 }
5654 /*
5655 * check that we have a type corresponding with the one the types
5656 * file specifies.
5657 */
5661 module_name);
5663 }
5666 /*
5667 * if enumeration type get set of name/vals and any default value
5668 */
5673 }
5679 }
5685 }
5688 /*
5689 * Reads a name and a value from file ref'd by cfp into list indirectly
5690 * ref'd by nvlp; If this list is NULL it will be created to accomodate
5691 * the name/value. The name must be either a special token for
5692 * for the place, or be present in the module types file ref'd by tfp.
5693 * *type is set to the enumeration of the type of the parameter and
5694 * nvp to point at the element with the nvlp ref'd list.
5695 * RETURNS: IPQOS_CONF_CURL_END if read CURL_END as name,
5696 * IPQOS_CONF_ERR on errors, else IPQOS_CONF_SUCCESS.
5697 */
5698 static int
5705 place_t place,
5707 {
5718 /*
5719 * read nvpair name
5720 */
5723 /*
5724 * if reached eof, curl end or error encountered return to caller
5725 */
5734 }
5736 /*
5737 * read nvpair value
5738 */
5741 /*
5742 * check we've read a valid value
5743 */
5750 lineno);
5755 }
5757 /*
5758 * check for generic parameters.
5759 */
5780 /*
5781 * get type from types file
5782 */
5788 }
5790 /*
5791 * get full module prefix parameter name
5792 */
5797 }
5799 }
5805 /*
5806 * create nvlist if not present already
5807 */
5815 }
5816 }
5818 /*
5819 * check we haven't already read this parameter
5820 */
5823 lineno);
5825 }
5827 /*
5828 * convert value string to appropriate type and add to nvlist
5829 */
5838 ifidx);
5843 }
5845 /*
5846 * change name to point at the name of the
5847 * new ifindex nvlist entry as name is used
5848 * later in the function.
5849 */
5855 }
5857 }
5859 }
5869 }
5870 }
5872 }
5879 /* add port */
5886 }
5888 /* add appropriate all ones port mask */
5897 }
5902 }
5903 }
5905 }
5913 }
5916 boolean_t b;
5926 }
5927 }
5929 }
5939 }
5940 }
5942 }
5953 }
5954 }
5956 }
5967 }
5968 }
5970 }
5981 }
5982 }
5984 }
5995 }
5996 }
5998 }
6009 }
6012 }
6014 }
6015 /*
6016 * For now the dfltst contains a comma separated list of the
6017 * type we need this parameter to be mapped to.
6018 * read_mapped_values will fill in all the mapped parameters
6019 * and their values in the nvlist.
6020 */
6031 }
6035 }
6040 }
6042 }
6049 /*
6050 * read array info from types file.
6051 */
6056 }
6058 /*
6059 * read array contents from config file and construct
6060 * array with them.
6061 */
6066 }
6068 /*
6069 * add array to nvlist.
6070 */
6075 }
6077 /*
6078 * free uneeded resources.
6079 */
6085 }
6087 uid_t uid;
6096 }
6097 }
6099 }
6100 #ifdef _IPQOS_CONF_DEBUG
6102 /*
6103 * we shouldn't have a type that doesn't have a switch
6104 * entry.
6105 */
6107 }
6108 #endif
6109 }
6114 }
6116 /* set the nvp parameter to point at the newly added nvlist entry */
6125 fail:
6133 }
6135 /*
6136 * read a parameter clause from cfp into *params.
6137 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
6138 */
6139 static int
6145 {
6149 ipqos_nvtype_t type;
6150 boolean_t bl;
6158 /* read beginning curl */
6163 }
6165 /*
6166 * loop reading nvpairs, adding to params nvlist until encounter
6167 * CURL_END.
6168 */
6170 /* read nvpair */
6177 /* we have finished reading params */
6181 }
6183 /*
6184 * read global stats - place into params struct and remove
6185 * from nvlist.
6186 */
6189 /* check we haven't read stats before */
6194 lineno);
6196 }
6197 read_stats++;
6202 IPQOS_CONF_GLOBAL_STATS_STR);
6205 /*
6206 * read action type parameter - add it to list of action refs.
6207 * also, if it's one of continue or drop virtual actions
6208 * change the action name to their special ipp names in
6209 * the action ref list and the nvlist.
6210 */
6213 /* get name and value from nvlist */
6218 /* if virtual action names change to ipp name */
6222 /*
6223 * we copy nm to a seperate buffer as nv_pair
6224 * name above gave us a ptr to internal
6225 * memory which causes strange behaviour
6226 * when we re-value that nvlist element.
6227 */
6232 /* modify nvlist entry and change action */
6242 }
6247 }
6248 }
6250 /* add action reference to params */
6253 }
6254 }
6257 fail:
6262 }
6266 }
6268 }
6270 /* ************************* class manip fns ****************************** */
6274 /*
6275 * make dst point at a dupicate class struct with duplicate elements to src.
6276 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
6277 */
6278 static int
6282 {
6291 }
6293 /* struct copy */
6296 /* we're not interested in the nvlist for a class */
6300 /* copy first action reference */
6306 }
6311 }
6313 /*
6314 * create a zero'd class struct and return a ptr to it.
6315 * RETURNS: ptr to struct on success, NULL otherwise.
6316 */
6319 {
6328 }
6331 }
6333 /* frees up all memory occupied by a filter struct and its contents. */
6334 static void
6336 {
6341 /* free its nvlist if present */
6345 /* free its action refs if present */
6350 /* finally free class itself */
6352 }
6354 /*
6355 * Checks whether there is a class called class_nm in classes list.
6356 * RETURNS: ptr to first matched class, else if not matched NULL.
6357 */
6362 {
6371 }
6372 }
6375 }
6379 /* ************************** filter manip fns **************************** */
6383 /*
6384 * Checks whether there is a filter called filter_nm with instance number
6385 * instance in filters list created by us or permanent. Instance value -1
6386 * is a wildcard.
6387 * RETURNS: ptr to first matched filter, else if not matched NULL.
6388 */
6394 {
6397 instance);
6405 }
6407 }
6409 }
6411 /*
6412 * allocate and zero a filter structure.
6413 * RETURNS: NULL on error, else ptr to filter struct.
6414 */
6417 {
6427 }
6430 }
6432 /* free flt and all it's contents. */
6434 static void
6436 {
6450 }
6452 }
6454 /*
6455 * makes a copy of ofilter and its contents and points nfilter at it. It
6456 * also adds an instance number to the filter and if either saddr or
6457 * daddr are non-null that address to the filters nvlist along with
6458 * an all 1s address mask and the af.
6459 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
6460 */
6461 static int
6470 {
6474 in6_addr_t v6addr;
6475 in6_addr_t all_1s_v6;
6480 /* show src address and dst address if present */
6481 #ifdef _IPQOS_CONF_DEBUG
6489 }
6495 }
6496 }
6499 /* init local v6 address to 0 */
6502 /* create an all 1s address for use as mask */
6505 /* create a new filter */
6510 }
6512 /* struct copy old filter to new */
6515 /* copy src filters nvlist if there is one to copy */
6522 }
6523 }
6525 /* copy src and dst node names if present */
6532 }
6534 }
6540 }
6542 }
6544 /* add filter addresses type */
6551 }
6555 /* add saddr if present */
6561 }
6563 /* add address and all 1's mask */
6571 }
6573 }
6575 /* add daddr if present */
6581 }
6583 /* add address and all 1's mask */
6591 }
6592 }
6594 /* add filter instance */
6600 fail:
6603 }
6607 /* ************************* action manip fns ********************** */
6611 /*
6612 * create and zero action structure and a params structure hung off of it.
6613 * RETURNS: ptr to allocated action on success, else NULL.
6614 */
6617 {
6625 }
6633 }
6638 }
6640 /*
6641 * free all the memory used in all the actions in actions list.
6642 */
6643 static void
6646 {
6654 /* free parameters */
6660 }
6662 }
6664 /* free action nvlist */
6669 /* free filters */
6676 }
6678 /* free classes */
6685 }
6687 /* free permanent classes table */
6690 /* free filters to retry */
6697 }
6699 /* free dependency pointers */
6705 }
6706 }
6708 /*
6709 * Checks whether there is an action called action_name in actions list.
6710 * RETURNS: ptr to first matched action, else if not matched NULL.
6711 *
6712 */
6717 {
6724 }
6726 }
6729 }
6731 /* **************************** act ref manip fns ******************** */
6734 /*
6735 * add an action reference element with parameter field and action
6736 * action_name to arefs.
6737 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
6738 */
6739 static int
6744 {
6750 /* allocate zero'd aref */
6756 }
6759 /* copy parameter name if present */
6764 /* copy action name */
6767 /* place at head of list */
6773 }
6775 /*
6776 * free all the memory used by the action references in arefs.
6777 */
6778 static void
6781 {
6791 }
6792 }
6796 /* *************************************************************** */
6800 /*
6801 * checks whether aname is a valid action name.
6802 * RETURNS: IPQOS_CONF_ERR if invalid, else IPQOS_CONF_SUCCESS.
6803 */
6804 static int
6806 {
6808 /*
6809 * dissallow the use of the name of a virtual action, either
6810 * the ipqosconf name, or the longer ipp names.
6811 */
6817 lineno);
6819 }
6822 }
6824 /*
6825 * Opens a stream to the types file for module module_name (assuming
6826 * that the file path is TYPES_FILE_DIR/module_name.types). if
6827 * a file open failure occurs, *openerr is set to 1.
6828 * RETURNS: NULL on error, else stream ptr to module types file.
6829 */
6834 {
6843 /* create modules type file path */
6850 }
6858 /* open stream to types file */
6863 }
6867 }
6870 /*
6871 * read a class clause from cfp into a class struct and point class at this.
6872 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
6873 */
6874 static int
6881 {
6886 ipqos_nvtype_t type;
6893 /* create and zero class struct */
6898 }
6901 /* get starting line for error reporting */
6904 /* read curl_begin */
6909 }
6911 /* loop reading parameters till read curl_end */
6915 /* read nvpair */
6921 /* reached end of class clause */
6924 }
6926 /*
6927 * catch name and action nv pairs and stats if present
6928 * and place values in class structure.
6929 */
6931 /* name */
6940 }
6942 nm++;
6944 /* next action */
6951 /*
6952 * if next action string continue string set action to
6953 * IPP_ANAME_CONT, else if drop string IPP_ANAME_DROP
6954 */
6959 }
6961 /* add an action reference to action list */
6967 }
6968 act++;
6970 /* class stats enable */
6975 boolean_t bl;
6980 stats++;
6982 /* no other / duplicate parameters allowed */
6988 }
6989 }
6993 lineno);
6995 }
6997 /* change class originator field to permanent if permanent class */
7002 }
7005 fail:
7009 }
7011 /*
7012 * This function assumes either src_nd_name or dst_node_nm are set in filter.
7013 *
7014 * Creates one of more copies of filter according to the ip versions
7015 * requested (or assumed) and the resolution of the src and dst address
7016 * node names if spec'd. If both node names are spec'd then a filter is
7017 * created for each pair of addresses (one from each node name) that is
7018 * compatible with the chosen address family, otherwise a filter copy is
7019 * created for just each address of the single node name that is
7020 * compatible.
7021 * If filter->ip_versions has been set that is used to determine the
7022 * af's we will create filters for, else if a numeric address was
7023 * added the family of that will be used, otherwise we fall back
7024 * to both v4 and v6 addresses.
7025 *
7026 * Any name lookup failures that occur are checked to see whether the failure
7027 * was a soft or hard failure and the nlerr field of filter set accordingly
7028 * before the error is returned.
7029 *
7030 * RETURNS: IPQOS_CONF_ERR on any error, else IPQOS_CONF_SUCCESS.
7031 */
7033 static int
7037 boolean_t last_retry)
7038 {
7058 /* check if we've read an ip_version request to get the versions */
7064 /* otherwise check if we've read a numeric address and get versions */
7069 v6--;
7071 v4--;
7072 }
7073 }
7075 /* read saddrs if src node name */
7079 /* v4 only address */
7082 in32b++;
7086 /* v6 only */
7092 /* v4 and v6 */
7097 }
7099 #ifdef TESTING_RETRY
7103 }
7104 #endif
7106 /*
7107 * if lookup error determine whether it was a soft or hard
7108 * failure and mark as such in filter.
7109 */
7113 "resolve src host name for filter at "
7120 "to resolve src host name for "
7121 "filter at line %u, ignoring "
7123 }
7125 }
7127 }
7128 }
7130 /* read daddrs if dst node name */
7133 /* v4 only address */
7136 in32b++;
7140 /* v6 only */
7146 /* v6 and v4 addresses */
7151 }
7156 "resolve dst host name for filter at "
7163 "to resolve dst host name for "
7164 "filter at line %u, ignoring "
7166 }
7168 }
7170 }
7171 }
7173 /*
7174 * if src and dst node name, create set of filters; one for each
7175 * src and dst address of matching types.
7176 */
7182 /* get saddr family */
7188 }
7193 /* get daddr family */
7199 }
7201 /*
7202 * if saddr and daddr same af duplicate
7203 * filter adding addresses and new instance
7204 * number and add to flist filter list.
7205 */
7213 }
7215 }
7216 }
7217 }
7219 /* if src name only create set of filters, one for each node address */
7226 /* get af */
7232 }
7235 /*
7236 * dup filter adding saddr and new instance num and
7237 * add to flist filter list.
7238 */
7243 }
7247 }
7249 /* if dname only create set of filters, one for each node address */
7255 /* get af */
7261 }
7263 /*
7264 * dup filter adding daddr and new instance num and
7265 * add to flist filter list.
7266 */
7271 }
7274 }
7275 }
7282 fail:
7283 /*
7284 * should really clean up any filters that we have created,
7285 * however, free_actions called from readaction will cleam them up.
7286 */
7292 }
7295 /*
7296 * read a filter clause from cfp into a filter struct and point filter
7297 * at this.
7298 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
7299 */
7300 static int
7308 {
7312 in6_addr_t mask;
7315 in6_addr_t addr;
7320 uchar_t mlen;
7323 ipqos_nvtype_t type;
7326 uchar_t b;
7327 in6_addr_t v6addr;
7332 /* create and zero filter struct */
7337 }
7340 /* get starting line for error reporting */
7343 /* read beginning curl */
7348 }
7351 /*
7352 * loop reading nvpairs onto nvlist until encounter CURL_END
7353 */
7356 /* read nvpair */
7363 /* reached the end of filter definition */
7367 }
7369 /*
7370 * catch name and class and place value into filter
7371 * structure.
7372 */
7374 /* read filter name */
7380 lineno);
7382 }
7387 }
7391 IPQOS_CONF_NAME_STR);
7392 nm++;
7394 /* read class name */
7401 lineno);
7403 }
7408 }
7411 }
7414 IPQOS_CONF_CLASS_STR);
7415 cls++;
7417 /*
7418 * if a src or dst ip node name/address. For those that
7419 * are determined to be addresses we convert them from
7420 * strings here and add to the filter nvlist; for node names
7421 * we add the name to the filter struct for readaction to
7422 * process.
7423 */
7430 sa++;
7431 }
7435 /*
7436 * get the address mask if present.
7437 * make a copy so that the nvlist element that
7438 * it is part of doesn't dissapear and causes probs.
7439 */
7447 }
7450 }
7453 /* if a numeric address */
7458 /* get address */
7466 }
7472 /* determine address type */
7476 v6++;
7477 }
7479 /*
7480 * check any previous addresses have same
7481 * version.
7482 */
7489 "address version line "
7492 }
7493 }
7495 /*
7496 * check that if ip_version spec'd it
7497 * corresponds.
7498 */
7504 "address version line %u"
7507 }
7508 }
7510 /* add the address type */
7519 }
7521 /* add address to list */
7530 }
7533 /*
7534 * add mask entry in list.
7535 */
7548 }
7553 /* no CIDR mask spec'd - use all 1s */
7557 }
7565 }
7567 /* inet_pton returns fail - we assume a node name */
7570 /*
7571 * doesn't make sense to have a mask
7572 * with a node name.
7573 */
7577 "allowed for host names line "
7580 }
7582 /*
7583 * store node name in filter struct for
7584 * later resolution.
7585 */
7590 addr_str);
7595 addr_str);
7596 }
7597 }
7599 /* ip_version enumeration */
7603 /* check we haven't read ip_version before */
7607 lineno);
7609 }
7610 ipv++;
7612 /* get bitmask value */
7617 /*
7618 * check that if either ip address is spec'd it
7619 * corresponds.
7620 */
7626 }
7628 /* remove ip_version from nvlist */
7631 IPQOS_CONF_IP_VERSION);
7632 }
7633 }
7638 }
7645 }
7648 fail:
7657 }
7659 /*
7660 * reads the curl begin token from cfp stream.
7661 * RETURNS: IPQOS_CONF_ERR if not read successfully, else IPQOS_CONF_SUCCES.
7662 */
7663 static int
7665 {
7676 /* if CURL_END or something else */
7681 }
7683 }
7687 }
7689 /*
7690 * This function parses the parameter string version into a version of the
7691 * form "%u.%u" (as a sscanf format string). It then encodes this into an
7692 * int and returns this encoding.
7693 * RETURNS: -1 if an invalid string, else the integer encoding.
7694 */
7695 static int
7698 {
7705 }
7709 }
7711 /*
7712 * This function scans through the stream fp line by line looking for
7713 * a line beginning with version_tag and returns a integer encoding of
7714 * the version following it.
7715 *
7716 * RETURNS: If the version definition isn't found or the version is not
7717 * a valid version (%u.%u) then -1 is returned, else an integer encoding
7718 * of the read version.
7719 */
7720 static int
7725 {
7732 /*
7733 * reset to file start
7734 */
7738 }
7740 /*
7741 * loop reading lines till found the one beginning with version_tag.
7742 */
7749 found++;
7751 }
7752 }
7757 version_tag);
7759 }
7761 /*
7762 * convert version string into int.
7763 */
7768 }
7771 }
7773 /*
7774 * read action clause and params/classes/filters clauses within and
7775 * store in and hang off an action structure, and point action at it.
7776 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
7777 */
7778 static int
7782 {
7792 ipqos_nvtype_t type;
7810 }
7813 /* create action structure */
7818 }
7822 /* get starting line for error reporting */
7825 /* read beginning curl */
7830 }
7832 /* loop till read both action name and module */
7836 /* read nvpair */
7843 /* read curl_end */
7851 }
7852 }
7855 /* store name and module in action structure */
7859 /* read action name */
7865 /* check name is valid */
7870 }
7872 /* store and remove from list */
7875 /* remove name from nvlist */
7877 IPQOS_CONF_NAME_STR);
7879 nm++;
7881 /* read module name */
7885 /*
7886 * check that module has a type file and get
7887 * open stream to it.
7888 */
7896 lineno);
7899 }
7900 }
7902 }
7904 /*
7905 * move module name to action struct
7906 */
7908 IPQOS_CONF_NAME_LEN);
7910 IPQOS_CONF_MODULE_STR);
7911 md++;
7913 /* duplicate/other parameter */
7918 lineno);
7920 }
7924 /*
7925 * check that if the ipgpc action it is named correctly
7926 */
7933 }
7935 /* get list of permanent classes */
7941 }
7943 /* get list of permanent filters */
7949 }
7951 /*
7952 * get types file format version and check its supported.
7953 */
7963 }
7965 /*
7966 * get module version
7967 */
7972 /* read filter/class/params blocks until CURL_END */
7975 /* read token */
7984 /* read CURL_END - end of action definition */
7989 }
7992 /*
7993 * read in either a filter/class or parameter block.
7994 */
7996 /* read filter */
8005 }
8007 /*
8008 * if we read a host name for either src or dst addr
8009 * resolve the hostnames and create the appropriate
8010 * number of filters.
8011 */
8016 B_FALSE);
8017 /*
8018 * if a lookup fails and the filters
8019 * marked as retry we add it to a list
8020 * for another attempt later, otherwise
8021 * it is thrown away.
8022 */
8025 /* if not name lookup problem */
8031 /* name lookup problem */
8033 /*
8034 * if intermitent lookup failure
8035 * add to list of filters to
8036 * retry later.
8037 */
8039 IPQOS_LOOKUP_RETRY) {
8043 filter);
8044 /*
8045 * for non-existing names
8046 * ignore the filter.
8047 */
8050 }
8052 /* creation of new filters successful */
8056 }
8058 /* non-node name filter */
8062 }
8064 /* read class */
8073 }
8077 /* read params */
8086 }
8091 }
8092 readprms++;
8094 /* something unexpected */
8101 }
8102 }
8107 fail:
8113 }
8115 }
8117 /*
8118 * check that each of the actions in actions is uniquely named. If one isn't
8119 * set *name to point at the name of the duplicate action.
8120 * RETURNS: IPQOS_CONF_ERR if a non-unique action, else IPQOS_CONF_SUCCESS.
8121 */
8122 static int
8124 {
8132 }
8134 }
8137 }
8139 /*
8140 * checks whether the action parameter is involved in an action cycle.
8141 * RETURNS: 1 if involved in a cycle, 0 otherwise.
8142 */
8143 static int
8146 {
8154 /* have we visited this action before? */
8159 }
8162 /*
8163 * recurse down the child actions of this action through the
8164 * classes next action and parameter actions.
8165 */
8169 /* skip virtual actions - they can't be in a cycle */
8173 }
8178 }
8179 }
8186 }
8191 }
8192 }
8197 }
8199 /*
8200 * checks that the configuration in actions is a valid whole, that
8201 * all actions are unique, all filters and classes are unique within
8202 * their action, that classes referenced by filters exist and actions
8203 * referenced by classes and params exist. Also checks that there are no root
8204 * actions but ipgpc and that no actions are involved in cycles. As
8205 * a consequence of checking that the actions exist two way pointers
8206 * are created between the dependee and dependant actions.
8207 *
8208 * In the case the the userconf flag is zero only this link creation is
8209 * set as we trust the kernel to return a valid configuration.
8210 *
8211 * RETURNS: IPQOS_CONF_ERR if config isn't valid, else IPQOS_CONF_SUCCESS.
8212 *
8213 */
8215 static int
8219 {
8231 /* check actions are unique */
8235 name);
8237 }
8241 /*
8242 * check filters (for user land configs only).
8243 * check they are unique in this action and their class exists.
8244 */
8248 /* check unique name */
8257 }
8259 /*
8260 * check existence of class and error if
8261 * class doesn't exist and not a perm class
8262 */
8271 "class in filter %s, "
8275 }
8276 }
8277 }
8278 }
8280 /* check classes */
8284 /* check if class name unique (userland only) */
8291 }
8293 /*
8294 * virtual actions always exist so don't check for next
8295 * action.
8296 */
8299 }
8301 /*
8302 * check existance of next action and create link to
8303 * it.
8304 */
8311 }
8313 /* create backwards link - used for deletions */
8319 }
8321 }
8324 /* check actions exist for action type parameters */
8329 /* skip virtuals */
8333 }
8335 /*
8336 * check existance of action in this ref
8337 * and if present create a ptr to it.
8338 */
8346 }
8348 /* create backwards link */
8355 }
8357 }
8358 }
8360 /* for kernel retrieved configs we don't do the following checks. */
8363 }
8365 /* check for cycles in config and orphaned actions other than ipgpc */
8369 /* check if involved in cycle */
8376 }
8378 /* check that this action has a parent (except ipgpc) */
8385 }
8386 }
8389 }
8391 /*
8392 * Read the version from the config file with stream cfp with
8393 * the tag version_tag. The tag-value pair should be the first tokens
8394 * encountered.
8395 *
8396 * RETURNS: -1 if a missing or invalid version or a read error,
8397 * else an integer encoding of the version.
8398 */
8399 static int
8403 {
8410 /*
8411 * read version tag string.
8412 */
8418 }
8422 /*
8423 * read version number string.
8424 */
8428 }
8430 /*
8431 * encode version into int.
8432 */
8435 }
8439 fail:
8445 }
8447 /*
8448 * read the set of actions definitions from the stream cfp and store
8449 * them in a list pointed to by conf.
8450 * RETURNS: IPQOS_CONF_ERR if any errors, else IPQOS_CONF_SUCCESS.
8451 */
8452 static int
8456 {
8467 /*
8468 * get config file format version.
8469 */
8474 /*
8475 * check version is valid
8476 */
8482 }
8483 }
8485 /* loop reading actions adding to conf till EOF */
8490 /* readaction */
8495 }
8497 /* reached eof, finish */
8501 }
8505 /* check if we just read an ipgpc action */
8509 }
8511 /* check that there is one or more actions and that one is ipgpc */
8515 IPGPC_NAME);
8517 }
8520 fail:
8524 }
8526 /* ************************ kernel config retrieval ************************ */
8529 /*
8530 * read the current configuration from the kernel and make *conf a ptr to it.
8531 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8532 */
8533 static int
8535 {
8545 ipqos_actinfo_prm_t ai_prm;
8550 /* initialise conf to NULL */
8553 /* get list of modules currently loaded */
8559 }
8561 /*
8562 * iterate through all loaded modules retrieving their list of actions
8563 * and then retrieving the configuration of each of these
8564 * and attatching it to conf.
8565 */
8568 /* skip actions of modules that we can't open types file of */
8572 /* mem error */
8577 /*
8578 * fopen fail - if we failed because the file didn't
8579 * exist we assume this is an unknown module and
8580 * ignore this module, otherwise error.
8581 */
8588 }
8589 }
8590 }
8593 /* get action list for this module */
8599 }
8601 /* read config of each action of this module */
8607 }
8609 /* copy action name into action struct */
8612 IPQOS_CONF_NAME_LEN);
8614 /* copy module name into action struct */
8617 IPQOS_CONF_NAME_LEN);
8619 /* get action info */
8625 /* was this an ipp error */
8629 }
8631 }
8634 }
8637 }
8641 fail:
8647 }
8649 /*
8650 * This is passed as a parameter to ipp_action_info() in readkaction and
8651 * is called back one for each configuration element within the action
8652 * specified. This results in filters and classes being created and chained
8653 * off of action, and action having its params set.
8654 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
8655 */
8656 static int
8660 {
8671 /* get config type */
8678 /*
8679 * parse the passed filter nvlist
8680 * and add result to action's filter list.
8681 */
8686 }
8693 }
8697 }
8700 /*
8701 * parse the passed class nvlist
8702 * and add result to action's class list.
8703 */
8708 }
8715 }
8719 }
8721 /*
8722 * we don't alloc a params struct as it is created
8723 * as part of an action.
8724 */
8726 /* parse the passed params nvlist */
8729 nvl);
8733 }
8734 }
8735 }
8739 }
8741 /*
8742 * parses a params nvlist returned from the kernel.
8743 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8744 */
8745 int
8752 ipqos_nvtype_t type;
8762 place_t place;
8766 /* get stream to module types file */
8772 }
8774 }
8776 /* make copy of passed in nvlist as it is freed by the caller */
8781 }
8783 /*
8784 * get config originator and remove from nvlist. If no owner we
8785 * assume ownership.
8786 */
8793 }
8795 /* get action stats and remove from nvlist */
8801 }
8803 /*
8804 * loop throught nvlist elements and for those that are actions create
8805 * action ref entrys for them.
8806 */
8815 }
8823 }
8824 }
8827 }
8829 /* assign copied nvlist to params struct */
8835 fail:
8841 }
8843 /*
8844 * parses a classes nvlist returned from the kernel.
8845 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8846 */
8847 static int
8851 {
8859 /* lookup object originator */
8866 }
8868 /* lookup name */
8874 /* lookup next action */
8880 }
8882 /* lookup stats enable */
8887 }
8890 }
8892 /*
8893 * parses a filters nvlist returned from the kernel.
8894 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8895 */
8896 static int
8900 {
8910 /* make copy of passed in nvlist as it is freed by the caller */
8915 }
8917 /* lookup originator */
8925 }
8927 /* lookup filter name */
8933 /* lookup class name */
8939 /* lookup src and dst host names if present */
8950 }
8951 }
8961 }
8962 }
8964 /* lookup ip_version if present */
8976 }
8977 }
8979 /* lookup filter instance if present */
8987 }
8989 /* attach new trimmed nvlist to filter */
8993 }
8996 /*
8997 * determines whether action_name is a virtual action name.
8998 * RETURNS: if virtual action 1, else 0.
8999 */
9000 static int
9002 {
9008 }
9011 }
9013 /*
9014 * remove all the actions within the kernel. If there is a failure
9015 * modified is set to represent whether the attempt to flush modified
9016 * the configuration in any way.
9017 * RETURNS: IPQOS_CONF_ERR if the ipp_* functions return any errors,
9018 * else IPQOS_CONF_SUCCESS.
9019 */
9020 static int
9023 {
9036 /*
9037 * get list of modules currently loaded.
9038 */
9043 }
9045 /*
9046 * iterate through all the modules listing their actions and
9047 * deleting all of them.
9048 */
9057 }
9062 /*
9063 * if fails for reason other than action doesn't
9064 * exist or action has dependency.
9065 */
9071 }
9075 }
9077 }
9081 }
9083 /*
9084 * Trys to flush the configuration. If it fails and nothing has been modified
9085 * and force_flush is false just return an error, otherwise persist trying to
9086 * completion.
9087 * RETURNS: IPQOS_CONF_ERR if flush attempt failed without modifying anything
9088 * and force_flush was set to false, otherwise IPQOS_CONF_SUCCESS.
9089 */
9090 static int
9092 boolean_t force_flush)
9093 {
9098 /*
9099 * attempt first flush of config.
9100 */
9107 }
9109 /*
9110 * failed flush that modified config, or force flush set; loop till
9111 * successful flush.
9112 */
9118 }
9120 x++;
9122 }
9125 }
9127 /*
9128 * Performs a flush of the configuration within a signal blocking region
9129 * so that there's minimal chance of it being killed and the flush only
9130 * partially completing.
9131 * RETURNS: IPQOS_CONF_SUCCESS (for symmetry with the other main functions).
9132 */
9133 static int
9135 {
9138 /*
9139 * make sure that flush is as atomic as possible.
9140 */
9146 /*
9147 * restore signals.
9148 */
9155 }
9158 }
9160 static int
9162 {
9170 }
9171 }
9174 }
9176 /* free the memory occupied by the string table ctable and its contents. */
9177 static void
9179 {
9186 }
9188 }
9189 }
9191 #if 0
9193 /*
9194 * makes a copy of a string table and returns a ptr to it.
9195 * RETURNS: NULL on error or if size was 0, else ptr to copied table.
9196 */
9199 {
9204 /* create char ptr array */
9210 }
9212 /* create copy of each string from stable1 in array */
9222 }
9225 }
9228 }
9231 /*
9232 * retry lookups on filters that soft failed a previous lookup and
9233 * were put on the retry list.
9234 * RETURNS: IPQOS_CONF_ERR on any errors, else IPQOS_CONF_SUCCESS.
9235 */
9236 static int
9239 {
9249 /* store start of new resolved filters */
9252 /*
9253 * do name resolution on retry list adding resolved filters
9254 * to end of actions filters.
9255 */
9259 IPQOS_CONF_SUCCESS) {
9261 /* if resource failure */
9265 }
9266 }
9267 }
9269 /* add the newly resolved filters to the kernel action */
9273 IPQOS_CONF_SUCCESS) {
9275 }
9276 }
9277 }
9280 }
9282 /*
9283 * write the configuration in conf to the file given in dstpath. This
9284 * is done by writing first to a temporary file and then renaming that
9285 * file to dstpath. This assures an atomic write.
9286 * RETURNS: IPQOS_CONF_ERR on any errors, else IPQOS_CONF_SUCCESS.
9287 */
9288 static int
9292 {
9302 /* construct tmp file path so we can use rename() */
9306 /* dstpath in current dir */
9313 }
9316 /* dstpath in root dir */
9323 }
9326 /* not pwd or root */
9335 }
9339 }
9342 /* open tmp file */
9349 }
9351 /* write out format version */
9356 /*
9357 * loop through actions in list writing ipqosconf originated
9358 * ones out to the tmp file.
9359 */
9367 }
9368 }
9369 }
9372 /* rename tmp file to dst file */
9378 }
9382 }
9384 /*
9385 * read the configuration back from the kernel and then write each of the
9386 * actions read to IPQOS_CONF_INIT_PATH.
9387 * RETURNS: IPQOS_CONF_ERR if error, else IPQOS_CONF_SUCCESS.
9388 */
9389 static int
9391 {
9398 /* read the configuration from the kernel */
9403 }
9405 /* dissallow a null config to be stored (we can't read one in) */
9411 }
9413 /* make sure if we create file that perms are 644 */
9417 /* write the configuration to the init file */
9422 }
9428 }
9430 /*
9431 * Called in the event of a failed rollback. It first flushes the
9432 * current configuration, then attempts to apply the oconf (the old
9433 * one), and if that fails flushes again.
9434 *
9435 * RETURNS: IPQOS_CONF_ERR if the application of old config fails,
9436 * else IPQOS_CONF_SUCCESS.
9437 */
9438 static int
9441 {
9446 /*
9447 * flush configuration.
9448 */
9451 /*
9452 * mark all elements of old config for application.
9453 */
9456 /*
9457 * attempt to apply old config.
9458 */
9460 /*
9461 * if failed force flush of config.
9462 */
9466 }
9469 }
9471 /*
9472 * read and apply the configuration contained if file ifile to the kernel.
9473 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
9474 */
9475 static int
9477 {
9488 /* if filename '-' read from stdin */
9499 }
9500 }
9502 /* read in new configuration */
9507 }
9509 /* check configuration is valid */
9514 }
9516 /* read in kernel configuration */
9521 }
9523 /*
9524 * check there are no same named actions in both config file and the
9525 * the kernel that are for a different module. The application
9526 * system can't handle these as we would try to add the new
9527 * action before we deleted the old one and because actions
9528 * in the kernel are indexed solely on their name (their module
9529 * isn't included) the kernel would return an error. We want
9530 * to avoid this error and the resulting rollback.
9531 */
9534 /* found action */
9536 /* different module */
9540 "same name as currently "
9541 "installed action, but is for a "
9545 /* same module - stop search */
9548 }
9549 }
9550 }
9551 }
9554 /* create links between actions for use with deletions etc.. */
9559 }
9561 /* diff conf file against kernel */
9566 }
9568 /* make kernel mods as atomic as possible */
9573 }
9575 /* apply difference to kernel */
9578 #ifdef _IPQOS_CONF_DEBUG
9580 #else
9588 /* system left flushed */
9598 }
9604 }
9606 }
9608 /* retry any soft name lookup failures */
9616 /* system left flushed */
9626 }
9632 }
9635 }
9639 /* re-enable signals */
9646 fail:
9656 }
9660 static int
9662 {
9666 }
9670 }
9672 }
9674 static int
9676 {
9680 }
9682 }
9684 static int
9686 {
9690 }
9692 }
9694 static int
9696 {
9701 /*
9702 * Open the file with O_CREAT|O_EXCL. If it exists already, it
9703 * will fail. If it already exists, check whether it looks like
9704 * the one we created.
9705 */
9710 /* Some other problem. */
9713 IPQOS_CONF_LOCK_FILE);
9715 }
9717 /*
9718 * open() returned an EEXIST error. We don't fail yet
9719 * as it could be a residual from a previous
9720 * execution. However, we need to clear errno here.
9721 * If we don't and print_cmd_buf() is later invoked
9722 * as the result of a parsing error, it
9723 * will assume that the current error is EEXIST and
9724 * that a corresponding error message has already been
9725 * printed, which results in an incomplete error
9726 * message. If errno is zero, print_cmd_buf() will
9727 * assume that it is called as a result of a
9728 * parsing error and will print the appropriate
9729 * error message.
9730 */
9733 /*
9734 * File exists. make sure it is OK. We need to lstat()
9735 * as fstat() stats the file pointed to by the symbolic
9736 * link.
9737 */
9741 IPQOS_CONF_LOCK_FILE);
9743 }
9744 /*
9745 * Check whether it is a regular file and not a symbolic
9746 * link. Its link count should be 1. The owner should be
9747 * root and the file should be empty.
9748 */
9754 IPQOS_CONF_LOCK_FILE);
9756 }
9761 IPQOS_CONF_LOCK_FILE);
9763 }
9765 /* Check whether we opened the file that we lstat()ed. */
9769 IPQOS_CONF_LOCK_FILE);
9771 }
9774 /* File changed after we did the lstat() above */
9776 IPQOS_CONF_LOCK_FILE);
9778 }
9779 }
9783 }
9785 }
9787 /*
9788 * print the current kernel configuration out to stdout. If viewall
9789 * is set this causes more verbose configuration listing including
9790 * showing objects we didn't create, each instance of a mhome filter,
9791 * etc.. see printaction().
9792 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
9793 */
9795 static int
9797 {
9805 /* get kernel configuration */
9810 }
9812 /* write out format version */
9817 }
9819 /* print each of the actions in the kernel config to stdout */
9826 }
9828 }
9833 }
9836 /*
9837 * debug function that reads the config file and prints it out after
9838 * interpreting to stdout.
9839 */
9840 #ifdef _IPQOS_CONF_DEBUG
9841 static int
9843 {
9857 }
9863 }
9865 /* print each of the actions in the kernel config to stdout */
9871 }
9874 }
9880 }
9883 static void
9885 {
9892 }
9894 int
9896 {
9906 /* init global flags */
9909 /* init current line number */
9912 /* setup internationalisation */
9915 #if !defined(TEXT_DOMAIN)
9917 #endif
9920 /* setup syslog parameters */
9925 /* enable debug options */
9927 #ifdef _IPQOS_CONF_DEBUG
9929 #else
9930 #define DBGOPTS
9935 #ifdef _IPQOS_CONF_DEBUG
9942 }
9943 args++;
9946 force_rback++;
9951 args++;
9959 }
9960 args++;
9964 args++;
9968 args++;
9972 viewall++;
9973 args++;
9976 verbose++;
9979 use_syslog++;
9984 }
9985 }
9987 /*
9988 * dissallow non-option args, > 1 cmd args and syslog/verbose flags set
9989 * for anything but apply.
9990 */
9996 }
9998 /* if no cmd option then show config */
10002 }
10004 /* stop concurrent ipqosconf invocations */
10008 }
10011 #ifdef _IPQOS_CONF_DEBUG
10028 }
10034 }