| blob | 9820f7be0d758bd495bd639d74818a68531ae13b |
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 GET_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:
5021 /* if a parse error */
5026 }
5029 }
5031 /*
5032 * Given mapped_list with is a comma seperated list of map names, and value,
5033 * which is used to index into these maps, the function creates x new entries
5034 * in nvpp, where x is the number of map names specified. Each of these
5035 * entries has the value from the map in the position indexed by value and
5036 * with name module.${MAP_NAME}. The maps are contained in the modules config
5037 * file and have the form:
5038 * map map1 uint32 1,23,32,45,3
5039 * As you can see the map values are uint32, and along with uint8 are the
5040 * only supported types at the moment.
5041 *
5042 * RETURNS: IPQOS_CONF_ERR if one of the maps specified in mapped_list
5043 * doesn't exist, if value is not a valid map position for a map, or if
5044 * there's a resource failure. otherwise IPQOS_CONF_SUCCESS is returned.
5045 */
5046 static int
5053 {
5056 ipqos_nvtype_t type;
5059 place_t place;
5068 /*
5069 * get map info from types file.
5070 */
5076 }
5078 /*
5079 * Just keep browsing the list till we get to the element
5080 * with the index from the value parameter or the end.
5081 */
5089 }
5092 }
5094 }
5097 /*
5098 * create fully qualified parameter name for map value.
5099 */
5103 }
5105 /*
5106 * add map value with fqn to parameter nvlist.
5107 */
5119 }
5121 }
5130 }
5132 }
5139 map_name);
5141 }
5142 }
5146 }
5149 }
5151 /*
5152 * Parses the string info_str into it's components. Its format is:
5153 * SIZE','[ENUM_DEF | RANGE], where SIZE is the size of the array,
5154 * ENUM_DEF is the definition of the enumeration for this array,
5155 * and RANGE is the set of values this array can accept. In
5156 * the event this array has an enumeration definition enum_nvs is
5157 * set to point at a str_val_nd_t structure which stores the names
5158 * and values associated with this enumeration. Otherwise, if this
5159 * is not an enumerated array, lower and upper are set to the lower
5160 * and upper values of RANGE.
5161 * RETURNS: IPQOS_CONF_ERR due to unexpected parse errors, else
5162 * IPQOS_CONF_SUCCESS.
5163 */
5164 static int
5172 {
5184 }
5186 /*
5187 * read size.
5188 */
5195 }
5198 /*
5199 * check we have another string.
5200 */
5205 }
5208 /*
5209 * check if enumeration set or integer set and read enumeration
5210 * definition or integer range respectively.
5211 */
5218 }
5224 }
5225 }
5228 fail:
5232 }
5234 /*
5235 * reads the value of an enumeration parameter from first_token and fp.
5236 * first_token is the first token of the value.
5237 * The format expected is NAME | { NAME1 [, NAME2 ] [, NAME3 ] }.
5238 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
5239 */
5240 static int
5246 {
5257 /* init param val */
5260 /* first token not curl_begin, so lookup its value */
5269 }
5271 /* curl_begin, so read values till curl_end, dicing at ',' */
5274 name_expected++;
5278 /*
5279 * no leftover from pervious iteration so read new
5280 * token. This leftover happens because readtoken
5281 * doesn't interpret comma's as special characters
5282 * and thus could return 'val1,val2' as one token.
5283 * If this happens the val1 will be used in the
5284 * current iteration and what follows saved in lo
5285 * for processing by successive iterations.
5286 */
5297 }
5303 }
5313 }
5315 /*
5316 * check if this token contains a ',' and
5317 * if so store it and what follows for next
5318 * iteration.
5319 */
5327 }
5331 }
5334 /* get name value and add to total val */
5343 }
5346 name_expected--;
5348 /* comma or curl end accepted */
5351 /* we've reached curl_end so break */
5357 /* not curl end and not comma */
5365 }
5367 /*
5368 * store anything after the comma for next
5369 * iteration.
5370 */
5377 }
5379 }
5381 name_expected++;
5382 }
5385 }
5386 }
5391 }
5393 /*
5394 * read the set of permanent classes/filter from the types file ref'd by tfp
5395 * and store them in a string table pointed to by perm_items,
5396 * with *nitems getting set to number of items read. perm_filters is set
5397 * to 1 if we're searching for permanent filters, else 0 for classes.
5398 * RETURNS: IPQOS_CONF_ERR if any errors, else IPQOS_CONF_SUCCESS.
5399 */
5400 static int
5407 {
5421 /* seek to start of types file */
5426 }
5428 /* select which marker were looking for */
5434 }
5436 /* scan file line by line till end */
5440 /*
5441 * if the line is marked as containing a default item name
5442 * read the name, extend the items string array
5443 * and store the string off the array.
5444 */
5456 marker);
5458 }
5460 /* extend items array to accomodate new item */
5468 }
5470 /* copy and store item name */
5476 }
5479 cnt++;
5483 name);
5484 }
5485 }
5491 fail:
5496 }
5498 /*
5499 * Searches types file ref'd by tfp for the parameter named name
5500 * with the place corresponding with place parameter. The format
5501 * of the lines in the file are:
5502 * PLACE NAME TYPE [ ENUM_DEF ] [ DEFAULT_STR ]
5503 * The ENUM_DEF is an enumeration definition and is only present
5504 * for parameters of type enum. DEFAULT_STR is a default value for
5505 * this parameter. If present type is set to the appropriate type
5506 * enumeration and dfltst filled with DEFAULT_STR if one was set.
5507 * Also if the type is enum enum_nvps is made to point at a
5508 * set of name value pairs representing ENUM_DEF.
5509 *
5510 * RETURNS: If any resource errors occur, or a matching parameter
5511 * isn't found IPQOS_CONF_ERR is returned, else IPQOS_CONF_SUCCESS.
5512 */
5513 static int
5521 boolean_t allow_ipgpc_priv,
5523 {
5538 /*
5539 * if allow_ipgpc_priv is true then we allow ipgpc parameters that are
5540 * private between ipqosconf and ipgpc. eg. address masks, port masks.
5541 */
5546 }
5562 }
5565 }
5567 /*
5568 * read upto and including module version line.
5569 */
5574 /*
5575 * loop reading lines of the types file until named parameter
5576 * found or EOF.
5577 */
5580 /*
5581 * check whether blank or commented line; if so skip
5582 */
5586 }
5590 /*
5591 * read place, param, type and if present default str
5592 * from line.
5593 */
5603 module_name);
5606 }
5608 /*
5609 * if the place and name match no need to look any further.
5610 */
5619 found++;
5621 }
5622 }
5623 }
5627 lineno);
5629 }
5631 /*
5632 * set the place parameter to the actual place when the PL_ANY flag
5633 * was set.
5634 */
5642 }
5643 }
5645 /*
5646 * get type enumeration
5647 */
5651 }
5652 }
5653 /*
5654 * check that we have a type corresponding with the one the types
5655 * file specifies.
5656 */
5660 module_name);
5662 }
5665 /*
5666 * if enumeration type get set of name/vals and any default value
5667 */
5672 }
5678 }
5684 }
5687 /*
5688 * Reads a name and a value from file ref'd by cfp into list indirectly
5689 * ref'd by nvlp; If this list is NULL it will be created to accomodate
5690 * the name/value. The name must be either a special token for
5691 * for the place, or be present in the module types file ref'd by tfp.
5692 * *type is set to the enumeration of the type of the parameter and
5693 * nvp to point at the element with the nvlp ref'd list.
5694 * RETURNS: IPQOS_CONF_CURL_END if read CURL_END as name,
5695 * IPQOS_CONF_ERR on errors, else IPQOS_CONF_SUCCESS.
5696 */
5697 static int
5704 place_t place,
5706 {
5717 /*
5718 * read nvpair name
5719 */
5722 /*
5723 * if reached eof, curl end or error encountered return to caller
5724 */
5733 }
5735 /*
5736 * read nvpair value
5737 */
5740 /*
5741 * check we've read a valid value
5742 */
5749 lineno);
5754 }
5756 /*
5757 * check for generic parameters.
5758 */
5779 /*
5780 * get type from types file
5781 */
5787 }
5789 /*
5790 * get full module prefix parameter name
5791 */
5796 }
5798 }
5804 /*
5805 * create nvlist if not present already
5806 */
5814 }
5815 }
5817 /*
5818 * check we haven't already read this parameter
5819 */
5822 lineno);
5824 }
5826 /*
5827 * convert value string to appropriate type and add to nvlist
5828 */
5837 ifidx);
5842 }
5844 /*
5845 * change name to point at the name of the
5846 * new ifindex nvlist entry as name is used
5847 * later in the function.
5848 */
5854 }
5856 }
5858 }
5868 }
5869 }
5871 }
5878 /* add port */
5885 }
5887 /* add appropriate all ones port mask */
5896 }
5901 }
5902 }
5904 }
5912 }
5915 boolean_t b;
5925 }
5926 }
5928 }
5938 }
5939 }
5941 }
5952 }
5953 }
5955 }
5966 }
5967 }
5969 }
5980 }
5981 }
5983 }
5994 }
5995 }
5997 }
6008 }
6011 }
6013 }
6014 /*
6015 * For now the dfltst contains a comma separated list of the
6016 * type we need this parameter to be mapped to.
6017 * read_mapped_values will fill in all the mapped parameters
6018 * and their values in the nvlist.
6019 */
6030 }
6034 }
6039 }
6041 }
6048 /*
6049 * read array info from types file.
6050 */
6055 }
6057 /*
6058 * read array contents from config file and construct
6059 * array with them.
6060 */
6065 }
6067 /*
6068 * add array to nvlist.
6069 */
6074 }
6076 /*
6077 * free uneeded resources.
6078 */
6084 }
6086 uid_t uid;
6095 }
6096 }
6098 }
6099 #ifdef _IPQOS_CONF_DEBUG
6101 /*
6102 * we shouldn't have a type that doesn't have a switch
6103 * entry.
6104 */
6106 }
6107 #endif
6108 }
6113 }
6115 /* set the nvp parameter to point at the newly added nvlist entry */
6124 fail:
6130 }
6132 /*
6133 * read a parameter clause from cfp into *params.
6134 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
6135 */
6136 static int
6142 {
6146 ipqos_nvtype_t type;
6147 boolean_t bl;
6155 /* read beginning curl */
6160 }
6162 /*
6163 * loop reading nvpairs, adding to params nvlist until encounter
6164 * CURL_END.
6165 */
6167 /* read nvpair */
6174 /* we have finished reading params */
6178 }
6180 /*
6181 * read global stats - place into params struct and remove
6182 * from nvlist.
6183 */
6186 /* check we haven't read stats before */
6191 lineno);
6193 }
6194 read_stats++;
6199 IPQOS_CONF_GLOBAL_STATS_STR);
6202 /*
6203 * read action type parameter - add it to list of action refs.
6204 * also, if it's one of continue or drop virtual actions
6205 * change the action name to their special ipp names in
6206 * the action ref list and the nvlist.
6207 */
6210 /* get name and value from nvlist */
6215 /* if virtual action names change to ipp name */
6219 /*
6220 * we copy nm to a seperate buffer as nv_pair
6221 * name above gave us a ptr to internal
6222 * memory which causes strange behaviour
6223 * when we re-value that nvlist element.
6224 */
6229 /* modify nvlist entry and change action */
6239 }
6244 }
6245 }
6247 /* add action reference to params */
6250 }
6251 }
6254 fail:
6259 }
6263 }
6265 }
6267 /* ************************* class manip fns ****************************** */
6271 /*
6272 * make dst point at a dupicate class struct with duplicate elements to src.
6273 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
6274 */
6275 static int
6279 {
6288 }
6290 /* struct copy */
6293 /* we're not interested in the nvlist for a class */
6297 /* copy first action reference */
6303 }
6308 }
6310 /*
6311 * create a zero'd class struct and return a ptr to it.
6312 * RETURNS: ptr to struct on success, NULL otherwise.
6313 */
6316 {
6325 }
6328 }
6330 /* frees up all memory occupied by a filter struct and its contents. */
6331 static void
6333 {
6338 /* free its nvlist if present */
6342 /* free its action refs if present */
6347 /* finally free class itself */
6349 }
6351 /*
6352 * Checks whether there is a class called class_nm in classes list.
6353 * RETURNS: ptr to first matched class, else if not matched NULL.
6354 */
6359 {
6368 }
6369 }
6372 }
6376 /* ************************** filter manip fns **************************** */
6380 /*
6381 * Checks whether there is a filter called filter_nm with instance number
6382 * instance in filters list created by us or permanent. Instance value -1
6383 * is a wildcard.
6384 * RETURNS: ptr to first matched filter, else if not matched NULL.
6385 */
6391 {
6394 instance);
6402 }
6404 }
6406 }
6408 /*
6409 * allocate and zero a filter structure.
6410 * RETURNS: NULL on error, else ptr to filter struct.
6411 */
6414 {
6424 }
6427 }
6429 /* free flt and all it's contents. */
6431 static void
6433 {
6445 }
6447 /*
6448 * makes a copy of ofilter and its contents and points nfilter at it. It
6449 * also adds an instance number to the filter and if either saddr or
6450 * daddr are non-null that address to the filters nvlist along with
6451 * an all 1s address mask and the af.
6452 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
6453 */
6454 static int
6463 {
6467 in6_addr_t v6addr;
6468 in6_addr_t all_1s_v6;
6473 /* show src address and dst address if present */
6474 #ifdef _IPQOS_CONF_DEBUG
6482 }
6488 }
6489 }
6492 /* init local v6 address to 0 */
6495 /* create an all 1s address for use as mask */
6498 /* create a new filter */
6503 }
6505 /* struct copy old filter to new */
6508 /* copy src filters nvlist if there is one to copy */
6515 }
6516 }
6518 /* copy src and dst node names if present */
6525 }
6527 }
6533 }
6535 }
6537 /* add filter addresses type */
6544 }
6548 /* add saddr if present */
6554 }
6556 /* add address and all 1's mask */
6564 }
6566 }
6568 /* add daddr if present */
6574 }
6576 /* add address and all 1's mask */
6584 }
6585 }
6587 /* add filter instance */
6593 fail:
6596 }
6600 /* ************************* action manip fns ********************** */
6604 /*
6605 * create and zero action structure and a params structure hung off of it.
6606 * RETURNS: ptr to allocated action on success, else NULL.
6607 */
6610 {
6618 }
6626 }
6631 }
6633 /*
6634 * free all the memory used in all the actions in actions list.
6635 */
6636 static void
6639 {
6647 /* free parameters */
6653 }
6655 /* free action nvlist */
6659 /* free filters */
6666 }
6668 /* free classes */
6675 }
6677 /* free permanent classes table */
6680 /* free filters to retry */
6687 }
6689 /* free dependency pointers */
6695 }
6696 }
6698 /*
6699 * Checks whether there is an action called action_name in actions list.
6700 * RETURNS: ptr to first matched action, else if not matched NULL.
6701 *
6702 */
6707 {
6714 }
6716 }
6719 }
6721 /* **************************** act ref manip fns ******************** */
6724 /*
6725 * add an action reference element with parameter field and action
6726 * action_name to arefs.
6727 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
6728 */
6729 static int
6734 {
6740 /* allocate zero'd aref */
6746 }
6749 /* copy parameter name if present */
6754 /* copy action name */
6757 /* place at head of list */
6763 }
6765 /*
6766 * free all the memory used by the action references in arefs.
6767 */
6768 static void
6771 {
6781 }
6782 }
6786 /* *************************************************************** */
6790 /*
6791 * checks whether aname is a valid action name.
6792 * RETURNS: IPQOS_CONF_ERR if invalid, else IPQOS_CONF_SUCCESS.
6793 */
6794 static int
6796 {
6798 /*
6799 * dissallow the use of the name of a virtual action, either
6800 * the ipqosconf name, or the longer ipp names.
6801 */
6807 lineno);
6809 }
6812 }
6814 /*
6815 * Opens a stream to the types file for module module_name (assuming
6816 * that the file path is TYPES_FILE_DIR/module_name.types). if
6817 * a file open failure occurs, *openerr is set to 1.
6818 * RETURNS: NULL on error, else stream ptr to module types file.
6819 */
6824 {
6833 /* create modules type file path */
6840 }
6848 /* open stream to types file */
6853 }
6857 }
6860 /*
6861 * read a class clause from cfp into a class struct and point class at this.
6862 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
6863 */
6864 static int
6871 {
6876 ipqos_nvtype_t type;
6883 /* create and zero class struct */
6888 }
6891 /* get starting line for error reporting */
6894 /* read curl_begin */
6899 }
6901 /* loop reading parameters till read curl_end */
6905 /* read nvpair */
6911 /* reached end of class clause */
6914 }
6916 /*
6917 * catch name and action nv pairs and stats if present
6918 * and place values in class structure.
6919 */
6921 /* name */
6930 }
6932 nm++;
6934 /* next action */
6941 /*
6942 * if next action string continue string set action to
6943 * IPP_ANAME_CONT, else if drop string IPP_ANAME_DROP
6944 */
6949 }
6951 /* add an action reference to action list */
6957 }
6958 act++;
6960 /* class stats enable */
6965 boolean_t bl;
6970 stats++;
6972 /* no other / duplicate parameters allowed */
6978 }
6979 }
6983 lineno);
6985 }
6987 /* change class originator field to permanent if permanent class */
6992 }
6995 fail:
6999 }
7001 /*
7002 * This function assumes either src_nd_name or dst_node_nm are set in filter.
7003 *
7004 * Creates one of more copies of filter according to the ip versions
7005 * requested (or assumed) and the resolution of the src and dst address
7006 * node names if spec'd. If both node names are spec'd then a filter is
7007 * created for each pair of addresses (one from each node name) that is
7008 * compatible with the chosen address family, otherwise a filter copy is
7009 * created for just each address of the single node name that is
7010 * compatible.
7011 * If filter->ip_versions has been set that is used to determine the
7012 * af's we will create filters for, else if a numeric address was
7013 * added the family of that will be used, otherwise we fall back
7014 * to both v4 and v6 addresses.
7015 *
7016 * Any name lookup failures that occur are checked to see whether the failure
7017 * was a soft or hard failure and the nlerr field of filter set accordingly
7018 * before the error is returned.
7019 *
7020 * RETURNS: IPQOS_CONF_ERR on any error, else IPQOS_CONF_SUCCESS.
7021 */
7023 static int
7027 boolean_t last_retry)
7028 {
7048 /* check if we've read an ip_version request to get the versions */
7054 /* otherwise check if we've read a numeric address and get versions */
7059 v6--;
7061 v4--;
7062 }
7063 }
7065 /* read saddrs if src node name */
7069 /* v4 only address */
7072 in32b++;
7076 /* v6 only */
7082 /* v4 and v6 */
7087 }
7089 #ifdef TESTING_RETRY
7093 }
7094 #endif
7096 /*
7097 * if lookup error determine whether it was a soft or hard
7098 * failure and mark as such in filter.
7099 */
7103 "resolve src host name for filter at "
7110 "to resolve src host name for "
7111 "filter at line %u, ignoring "
7113 }
7115 }
7117 }
7118 }
7120 /* read daddrs if dst node name */
7123 /* v4 only address */
7126 in32b++;
7130 /* v6 only */
7136 /* v6 and v4 addresses */
7141 }
7146 "resolve dst host name for filter at "
7153 "to resolve dst host name for "
7154 "filter at line %u, ignoring "
7156 }
7158 }
7160 }
7161 }
7163 /*
7164 * if src and dst node name, create set of filters; one for each
7165 * src and dst address of matching types.
7166 */
7172 /* get saddr family */
7178 }
7183 /* get daddr family */
7189 }
7191 /*
7192 * if saddr and daddr same af duplicate
7193 * filter adding addresses and new instance
7194 * number and add to flist filter list.
7195 */
7203 }
7205 }
7206 }
7207 }
7209 /* if src name only create set of filters, one for each node address */
7216 /* get af */
7222 }
7225 /*
7226 * dup filter adding saddr and new instance num and
7227 * add to flist filter list.
7228 */
7233 }
7237 }
7239 /* if dname only create set of filters, one for each node address */
7245 /* get af */
7251 }
7253 /*
7254 * dup filter adding daddr and new instance num and
7255 * add to flist filter list.
7256 */
7261 }
7264 }
7265 }
7272 fail:
7273 /*
7274 * should really clean up any filters that we have created,
7275 * however, free_actions called from readaction will cleam them up.
7276 */
7282 }
7285 /*
7286 * read a filter clause from cfp into a filter struct and point filter
7287 * at this.
7288 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
7289 */
7290 static int
7298 {
7302 in6_addr_t mask;
7305 in6_addr_t addr;
7310 uchar_t mlen;
7313 ipqos_nvtype_t type;
7316 uchar_t b;
7317 in6_addr_t v6addr;
7322 /* create and zero filter struct */
7327 }
7330 /* get starting line for error reporting */
7333 /* read beginning curl */
7338 }
7341 /*
7342 * loop reading nvpairs onto nvlist until encounter CURL_END
7343 */
7346 /* read nvpair */
7353 /* reached the end of filter definition */
7357 }
7359 /*
7360 * catch name and class and place value into filter
7361 * structure.
7362 */
7364 /* read filter name */
7370 lineno);
7372 }
7377 }
7381 IPQOS_CONF_NAME_STR);
7382 nm++;
7384 /* read class name */
7391 lineno);
7393 }
7398 }
7401 }
7404 IPQOS_CONF_CLASS_STR);
7405 cls++;
7407 /*
7408 * if a src or dst ip node name/address. For those that
7409 * are determined to be addresses we convert them from
7410 * strings here and add to the filter nvlist; for node names
7411 * we add the name to the filter struct for readaction to
7412 * process.
7413 */
7420 sa++;
7421 }
7425 /*
7426 * get the address mask if present.
7427 * make a copy so that the nvlist element that
7428 * it is part of doesn't dissapear and causes probs.
7429 */
7437 }
7440 }
7443 /* if a numeric address */
7448 /* get address */
7456 }
7462 /* determine address type */
7466 v6++;
7467 }
7469 /*
7470 * check any previous addresses have same
7471 * version.
7472 */
7479 "address version line "
7482 }
7483 }
7485 /*
7486 * check that if ip_version spec'd it
7487 * corresponds.
7488 */
7494 "address version line %u"
7497 }
7498 }
7500 /* add the address type */
7509 }
7511 /* add address to list */
7520 }
7523 /*
7524 * add mask entry in list.
7525 */
7538 }
7543 /* no CIDR mask spec'd - use all 1s */
7547 }
7555 }
7557 /* inet_pton returns fail - we assume a node name */
7560 /*
7561 * doesn't make sense to have a mask
7562 * with a node name.
7563 */
7567 "allowed for host names line "
7570 }
7572 /*
7573 * store node name in filter struct for
7574 * later resolution.
7575 */
7580 addr_str);
7585 addr_str);
7586 }
7587 }
7589 /* ip_version enumeration */
7593 /* check we haven't read ip_version before */
7597 lineno);
7599 }
7600 ipv++;
7602 /* get bitmask value */
7607 /*
7608 * check that if either ip address is spec'd it
7609 * corresponds.
7610 */
7616 }
7618 /* remove ip_version from nvlist */
7621 IPQOS_CONF_IP_VERSION);
7622 }
7623 }
7628 }
7635 }
7638 fail:
7646 }
7648 /*
7649 * reads the curl begin token from cfp stream.
7650 * RETURNS: IPQOS_CONF_ERR if not read successfully, else IPQOS_CONF_SUCCES.
7651 */
7652 static int
7654 {
7665 /* if CURL_END or something else */
7670 }
7672 }
7676 }
7678 /*
7679 * This function parses the parameter string version into a version of the
7680 * form "%u.%u" (as a sscanf format string). It then encodes this into an
7681 * int and returns this encoding.
7682 * RETURNS: -1 if an invalid string, else the integer encoding.
7683 */
7684 static int
7687 {
7694 }
7698 }
7700 /*
7701 * This function scans through the stream fp line by line looking for
7702 * a line beginning with version_tag and returns a integer encoding of
7703 * the version following it.
7704 *
7705 * RETURNS: If the version definition isn't found or the version is not
7706 * a valid version (%u.%u) then -1 is returned, else an integer encoding
7707 * of the read version.
7708 */
7709 static int
7714 {
7721 /*
7722 * reset to file start
7723 */
7727 }
7729 /*
7730 * loop reading lines till found the one beginning with version_tag.
7731 */
7738 found++;
7740 }
7741 }
7746 version_tag);
7748 }
7750 /*
7751 * convert version string into int.
7752 */
7757 }
7760 }
7762 /*
7763 * read action clause and params/classes/filters clauses within and
7764 * store in and hang off an action structure, and point action at it.
7765 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
7766 */
7767 static int
7771 {
7781 ipqos_nvtype_t type;
7799 }
7802 /* create action structure */
7807 }
7811 /* get starting line for error reporting */
7814 /* read beginning curl */
7819 }
7821 /* loop till read both action name and module */
7825 /* read nvpair */
7832 /* read curl_end */
7840 }
7841 }
7844 /* store name and module in action structure */
7848 /* read action name */
7854 /* check name is valid */
7859 }
7861 /* store and remove from list */
7864 /* remove name from nvlist */
7866 IPQOS_CONF_NAME_STR);
7868 nm++;
7870 /* read module name */
7874 /*
7875 * check that module has a type file and get
7876 * open stream to it.
7877 */
7885 lineno);
7888 }
7889 }
7891 }
7893 /*
7894 * move module name to action struct
7895 */
7897 IPQOS_CONF_NAME_LEN);
7899 IPQOS_CONF_MODULE_STR);
7900 md++;
7902 /* duplicate/other parameter */
7907 lineno);
7909 }
7913 /*
7914 * check that if the ipgpc action it is named correctly
7915 */
7922 }
7924 /* get list of permanent classes */
7930 }
7932 /* get list of permanent filters */
7938 }
7940 /*
7941 * get types file format version and check its supported.
7942 */
7952 }
7954 /*
7955 * get module version
7956 */
7961 /* read filter/class/params blocks until CURL_END */
7964 /* read token */
7973 /* read CURL_END - end of action definition */
7978 }
7981 /*
7982 * read in either a filter/class or parameter block.
7983 */
7985 /* read filter */
7994 }
7996 /*
7997 * if we read a host name for either src or dst addr
7998 * resolve the hostnames and create the appropriate
7999 * number of filters.
8000 */
8005 B_FALSE);
8006 /*
8007 * if a lookup fails and the filters
8008 * marked as retry we add it to a list
8009 * for another attempt later, otherwise
8010 * it is thrown away.
8011 */
8014 /* if not name lookup problem */
8020 /* name lookup problem */
8022 /*
8023 * if intermitent lookup failure
8024 * add to list of filters to
8025 * retry later.
8026 */
8028 IPQOS_LOOKUP_RETRY) {
8032 filter);
8033 /*
8034 * for non-existing names
8035 * ignore the filter.
8036 */
8039 }
8041 /* creation of new filters successful */
8045 }
8047 /* non-node name filter */
8051 }
8053 /* read class */
8062 }
8066 /* read params */
8075 }
8080 }
8081 readprms++;
8083 /* something unexpected */
8090 }
8091 }
8096 fail:
8102 }
8104 }
8106 /*
8107 * check that each of the actions in actions is uniquely named. If one isn't
8108 * set *name to point at the name of the duplicate action.
8109 * RETURNS: IPQOS_CONF_ERR if a non-unique action, else IPQOS_CONF_SUCCESS.
8110 */
8111 static int
8113 {
8121 }
8123 }
8126 }
8128 /*
8129 * checks whether the action parameter is involved in an action cycle.
8130 * RETURNS: 1 if involved in a cycle, 0 otherwise.
8131 */
8132 static int
8135 {
8143 /* have we visited this action before? */
8148 }
8151 /*
8152 * recurse down the child actions of this action through the
8153 * classes next action and parameter actions.
8154 */
8158 /* skip virtual actions - they can't be in a cycle */
8162 }
8167 }
8168 }
8175 }
8180 }
8181 }
8186 }
8188 /*
8189 * checks that the configuration in actions is a valid whole, that
8190 * all actions are unique, all filters and classes are unique within
8191 * their action, that classes referenced by filters exist and actions
8192 * referenced by classes and params exist. Also checks that there are no root
8193 * actions but ipgpc and that no actions are involved in cycles. As
8194 * a consequence of checking that the actions exist two way pointers
8195 * are created between the dependee and dependant actions.
8196 *
8197 * In the case the the userconf flag is zero only this link creation is
8198 * set as we trust the kernel to return a valid configuration.
8199 *
8200 * RETURNS: IPQOS_CONF_ERR if config isn't valid, else IPQOS_CONF_SUCCESS.
8201 *
8202 */
8204 static int
8208 {
8220 /* check actions are unique */
8224 name);
8226 }
8230 /*
8231 * check filters (for user land configs only).
8232 * check they are unique in this action and their class exists.
8233 */
8237 /* check unique name */
8246 }
8248 /*
8249 * check existence of class and error if
8250 * class doesn't exist and not a perm class
8251 */
8260 "class in filter %s, "
8264 }
8265 }
8266 }
8267 }
8269 /* check classes */
8273 /* check if class name unique (userland only) */
8280 }
8282 /*
8283 * virtual actions always exist so don't check for next
8284 * action.
8285 */
8288 }
8290 /*
8291 * check existance of next action and create link to
8292 * it.
8293 */
8300 }
8302 /* create backwards link - used for deletions */
8308 }
8310 }
8313 /* check actions exist for action type parameters */
8318 /* skip virtuals */
8322 }
8324 /*
8325 * check existance of action in this ref
8326 * and if present create a ptr to it.
8327 */
8335 }
8337 /* create backwards link */
8344 }
8346 }
8347 }
8349 /* for kernel retrieved configs we don't do the following checks. */
8352 }
8354 /* check for cycles in config and orphaned actions other than ipgpc */
8358 /* check if involved in cycle */
8365 }
8367 /* check that this action has a parent (except ipgpc) */
8374 }
8375 }
8378 }
8380 /*
8381 * Read the version from the config file with stream cfp with
8382 * the tag version_tag. The tag-value pair should be the first tokens
8383 * encountered.
8384 *
8385 * RETURNS: -1 if a missing or invalid version or a read error,
8386 * else an integer encoding of the version.
8387 */
8388 static int
8392 {
8399 /*
8400 * read version tag string.
8401 */
8407 }
8411 /*
8412 * read version number string.
8413 */
8417 }
8419 /*
8420 * encode version into int.
8421 */
8424 }
8428 fail:
8433 }
8435 /*
8436 * read the set of actions definitions from the stream cfp and store
8437 * them in a list pointed to by conf.
8438 * RETURNS: IPQOS_CONF_ERR if any errors, else IPQOS_CONF_SUCCESS.
8439 */
8440 static int
8444 {
8455 /*
8456 * get config file format version.
8457 */
8462 /*
8463 * check version is valid
8464 */
8470 }
8471 }
8473 /* loop reading actions adding to conf till EOF */
8478 /* readaction */
8483 }
8485 /* reached eof, finish */
8489 }
8493 /* check if we just read an ipgpc action */
8497 }
8499 /* check that there is one or more actions and that one is ipgpc */
8503 IPGPC_NAME);
8505 }
8508 fail:
8512 }
8514 /* ************************ kernel config retrieval ************************ */
8517 /*
8518 * read the current configuration from the kernel and make *conf a ptr to it.
8519 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8520 */
8521 static int
8523 {
8533 ipqos_actinfo_prm_t ai_prm;
8538 /* initialise conf to NULL */
8541 /* get list of modules currently loaded */
8547 }
8549 /*
8550 * iterate through all loaded modules retrieving their list of actions
8551 * and then retrieving the configuration of each of these
8552 * and attatching it to conf.
8553 */
8556 /* skip actions of modules that we can't open types file of */
8560 /* mem error */
8565 /*
8566 * fopen fail - if we failed because the file didn't
8567 * exist we assume this is an unknown module and
8568 * ignore this module, otherwise error.
8569 */
8576 }
8577 }
8578 }
8581 /* get action list for this module */
8587 }
8589 /* read config of each action of this module */
8595 }
8597 /* copy action name into action struct */
8600 IPQOS_CONF_NAME_LEN);
8602 /* copy module name into action struct */
8605 IPQOS_CONF_NAME_LEN);
8607 /* get action info */
8613 /* was this an ipp error */
8617 }
8619 }
8622 }
8625 }
8629 fail:
8635 }
8637 /*
8638 * This is passed as a parameter to ipp_action_info() in readkaction and
8639 * is called back one for each configuration element within the action
8640 * specified. This results in filters and classes being created and chained
8641 * off of action, and action having its params set.
8642 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCESS.
8643 */
8644 static int
8648 {
8659 /* get config type */
8666 /*
8667 * parse the passed filter nvlist
8668 * and add result to action's filter list.
8669 */
8674 }
8681 }
8685 }
8688 /*
8689 * parse the passed class nvlist
8690 * and add result to action's class list.
8691 */
8696 }
8703 }
8707 }
8709 /*
8710 * we don't alloc a params struct as it is created
8711 * as part of an action.
8712 */
8714 /* parse the passed params nvlist */
8717 nvl);
8721 }
8722 }
8723 }
8727 }
8729 /*
8730 * parses a params nvlist returned from the kernel.
8731 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8732 */
8733 int
8740 ipqos_nvtype_t type;
8750 place_t place;
8754 /* get stream to module types file */
8760 }
8762 }
8764 /* make copy of passed in nvlist as it is freed by the caller */
8769 }
8771 /*
8772 * get config originator and remove from nvlist. If no owner we
8773 * assume ownership.
8774 */
8781 }
8783 /* get action stats and remove from nvlist */
8789 }
8791 /*
8792 * loop throught nvlist elements and for those that are actions create
8793 * action ref entrys for them.
8794 */
8803 }
8811 }
8812 }
8815 }
8817 /* assign copied nvlist to params struct */
8823 fail:
8829 }
8831 /*
8832 * parses a classes nvlist returned from the kernel.
8833 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8834 */
8835 static int
8839 {
8847 /* lookup object originator */
8854 }
8856 /* lookup name */
8862 /* lookup next action */
8868 }
8870 /* lookup stats enable */
8875 }
8878 }
8880 /*
8881 * parses a filters nvlist returned from the kernel.
8882 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
8883 */
8884 static int
8888 {
8898 /* make copy of passed in nvlist as it is freed by the caller */
8903 }
8905 /* lookup originator */
8913 }
8915 /* lookup filter name */
8921 /* lookup class name */
8927 /* lookup src and dst host names if present */
8938 }
8939 }
8949 }
8950 }
8952 /* lookup ip_version if present */
8964 }
8965 }
8967 /* lookup filter instance if present */
8975 }
8977 /* attach new trimmed nvlist to filter */
8981 }
8984 /*
8985 * determines whether action_name is a virtual action name.
8986 * RETURNS: if virtual action 1, else 0.
8987 */
8988 static int
8990 {
8996 }
8999 }
9001 /*
9002 * remove all the actions within the kernel. If there is a failure
9003 * modified is set to represent whether the attempt to flush modified
9004 * the configuration in any way.
9005 * RETURNS: IPQOS_CONF_ERR if the ipp_* functions return any errors,
9006 * else IPQOS_CONF_SUCCESS.
9007 */
9008 static int
9011 {
9024 /*
9025 * get list of modules currently loaded.
9026 */
9031 }
9033 /*
9034 * iterate through all the modules listing their actions and
9035 * deleting all of them.
9036 */
9045 }
9050 /*
9051 * if fails for reason other than action doesn't
9052 * exist or action has dependency.
9053 */
9059 }
9063 }
9065 }
9069 }
9071 /*
9072 * Trys to flush the configuration. If it fails and nothing has been modified
9073 * and force_flush is false just return an error, otherwise persist trying to
9074 * completion.
9075 * RETURNS: IPQOS_CONF_ERR if flush attempt failed without modifying anything
9076 * and force_flush was set to false, otherwise IPQOS_CONF_SUCCESS.
9077 */
9078 static int
9080 boolean_t force_flush)
9081 {
9086 /*
9087 * attempt first flush of config.
9088 */
9095 }
9097 /*
9098 * failed flush that modified config, or force flush set; loop till
9099 * successful flush.
9100 */
9106 }
9108 x++;
9110 }
9113 }
9115 /*
9116 * Performs a flush of the configuration within a signal blocking region
9117 * so that there's minimal chance of it being killed and the flush only
9118 * partially completing.
9119 * RETURNS: IPQOS_CONF_SUCCESS (for symmetry with the other main functions).
9120 */
9121 static int
9123 {
9126 /*
9127 * make sure that flush is as atomic as possible.
9128 */
9134 /*
9135 * restore signals.
9136 */
9143 }
9146 }
9148 static int
9150 {
9158 }
9159 }
9162 }
9164 /* free the memory occupied by the string table ctable and its contents. */
9165 static void
9167 {
9174 }
9176 }
9177 }
9179 #if 0
9181 /*
9182 * makes a copy of a string table and returns a ptr to it.
9183 * RETURNS: NULL on error or if size was 0, else ptr to copied table.
9184 */
9187 {
9192 /* create char ptr array */
9198 }
9200 /* create copy of each string from stable1 in array */
9210 }
9213 }
9216 }
9219 /*
9220 * retry lookups on filters that soft failed a previous lookup and
9221 * were put on the retry list.
9222 * RETURNS: IPQOS_CONF_ERR on any errors, else IPQOS_CONF_SUCCESS.
9223 */
9224 static int
9227 {
9237 /* store start of new resolved filters */
9240 /*
9241 * do name resolution on retry list adding resolved filters
9242 * to end of actions filters.
9243 */
9247 IPQOS_CONF_SUCCESS) {
9249 /* if resource failure */
9253 }
9254 }
9255 }
9257 /* add the newly resolved filters to the kernel action */
9261 IPQOS_CONF_SUCCESS) {
9263 }
9264 }
9265 }
9268 }
9270 /*
9271 * write the configuration in conf to the file given in dstpath. This
9272 * is done by writing first to a temporary file and then renaming that
9273 * file to dstpath. This assures an atomic write.
9274 * RETURNS: IPQOS_CONF_ERR on any errors, else IPQOS_CONF_SUCCESS.
9275 */
9276 static int
9280 {
9290 /* construct tmp file path so we can use rename() */
9294 /* dstpath in current dir */
9301 }
9304 /* dstpath in root dir */
9311 }
9314 /* not pwd or root */
9323 }
9327 }
9330 /* open tmp file */
9337 }
9339 /* write out format version */
9344 /*
9345 * loop through actions in list writing ipqosconf originated
9346 * ones out to the tmp file.
9347 */
9355 }
9356 }
9357 }
9360 /* rename tmp file to dst file */
9366 }
9370 }
9372 /*
9373 * read the configuration back from the kernel and then write each of the
9374 * actions read to IPQOS_CONF_INIT_PATH.
9375 * RETURNS: IPQOS_CONF_ERR if error, else IPQOS_CONF_SUCCESS.
9376 */
9377 static int
9379 {
9386 /* read the configuration from the kernel */
9391 }
9393 /* dissallow a null config to be stored (we can't read one in) */
9399 }
9401 /* make sure if we create file that perms are 644 */
9405 /* write the configuration to the init file */
9410 }
9416 }
9418 /*
9419 * Called in the event of a failed rollback. It first flushes the
9420 * current configuration, then attempts to apply the oconf (the old
9421 * one), and if that fails flushes again.
9422 *
9423 * RETURNS: IPQOS_CONF_ERR if the application of old config fails,
9424 * else IPQOS_CONF_SUCCESS.
9425 */
9426 static int
9429 {
9434 /*
9435 * flush configuration.
9436 */
9439 /*
9440 * mark all elements of old config for application.
9441 */
9444 /*
9445 * attempt to apply old config.
9446 */
9448 /*
9449 * if failed force flush of config.
9450 */
9454 }
9457 }
9459 /*
9460 * read and apply the configuration contained if file ifile to the kernel.
9461 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
9462 */
9463 static int
9465 {
9476 /* if filename '-' read from stdin */
9487 }
9488 }
9490 /* read in new configuration */
9495 }
9497 /* check configuration is valid */
9502 }
9504 /* read in kernel configuration */
9509 }
9511 /*
9512 * check there are no same named actions in both config file and the
9513 * the kernel that are for a different module. The application
9514 * system can't handle these as we would try to add the new
9515 * action before we deleted the old one and because actions
9516 * in the kernel are indexed solely on their name (their module
9517 * isn't included) the kernel would return an error. We want
9518 * to avoid this error and the resulting rollback.
9519 */
9522 /* found action */
9524 /* different module */
9528 "same name as currently "
9529 "installed action, but is for a "
9533 /* same module - stop search */
9536 }
9537 }
9538 }
9539 }
9542 /* create links between actions for use with deletions etc.. */
9547 }
9549 /* diff conf file against kernel */
9554 }
9556 /* make kernel mods as atomic as possible */
9561 }
9563 /* apply difference to kernel */
9566 #ifdef _IPQOS_CONF_DEBUG
9568 #else
9576 /* system left flushed */
9586 }
9592 }
9594 }
9596 /* retry any soft name lookup failures */
9604 /* system left flushed */
9614 }
9620 }
9623 }
9627 /* re-enable signals */
9634 fail:
9644 }
9648 static int
9650 {
9654 }
9658 }
9660 }
9662 static int
9664 {
9668 }
9670 }
9672 static int
9674 {
9678 }
9680 }
9682 static int
9684 {
9689 /*
9690 * Open the file with O_CREAT|O_EXCL. If it exists already, it
9691 * will fail. If it already exists, check whether it looks like
9692 * the one we created.
9693 */
9698 /* Some other problem. */
9701 IPQOS_CONF_LOCK_FILE);
9703 }
9705 /*
9706 * open() returned an EEXIST error. We don't fail yet
9707 * as it could be a residual from a previous
9708 * execution. However, we need to clear errno here.
9709 * If we don't and print_cmd_buf() is later invoked
9710 * as the result of a parsing error, it
9711 * will assume that the current error is EEXIST and
9712 * that a corresponding error message has already been
9713 * printed, which results in an incomplete error
9714 * message. If errno is zero, print_cmd_buf() will
9715 * assume that it is called as a result of a
9716 * parsing error and will print the appropriate
9717 * error message.
9718 */
9721 /*
9722 * File exists. make sure it is OK. We need to lstat()
9723 * as fstat() stats the file pointed to by the symbolic
9724 * link.
9725 */
9729 IPQOS_CONF_LOCK_FILE);
9731 }
9732 /*
9733 * Check whether it is a regular file and not a symbolic
9734 * link. Its link count should be 1. The owner should be
9735 * root and the file should be empty.
9736 */
9742 IPQOS_CONF_LOCK_FILE);
9744 }
9749 IPQOS_CONF_LOCK_FILE);
9751 }
9753 /* Check whether we opened the file that we lstat()ed. */
9757 IPQOS_CONF_LOCK_FILE);
9759 }
9762 /* File changed after we did the lstat() above */
9764 IPQOS_CONF_LOCK_FILE);
9766 }
9767 }
9771 }
9773 }
9775 /*
9776 * print the current kernel configuration out to stdout. If viewall
9777 * is set this causes more verbose configuration listing including
9778 * showing objects we didn't create, each instance of a mhome filter,
9779 * etc.. see printaction().
9780 * RETURNS: IPQOS_CONF_ERR on error, else IPQOS_CONF_SUCCES.
9781 */
9783 static int
9785 {
9793 /* get kernel configuration */
9798 }
9800 /* write out format version */
9805 }
9807 /* print each of the actions in the kernel config to stdout */
9814 }
9816 }
9821 }
9824 /*
9825 * debug function that reads the config file and prints it out after
9826 * interpreting to stdout.
9827 */
9828 #ifdef _IPQOS_CONF_DEBUG
9829 static int
9831 {
9845 }
9851 }
9853 /* print each of the actions in the kernel config to stdout */
9859 }
9862 }
9868 }
9871 static void
9873 {
9880 }
9882 int
9884 {
9894 /* init global flags */
9897 /* init current line number */
9900 /* setup internationalisation */
9903 #if !defined(TEXT_DOMAIN)
9905 #endif
9908 /* setup syslog parameters */
9913 /* enable debug options */
9915 #ifdef _IPQOS_CONF_DEBUG
9917 #else
9918 #define DBGOPTS
9923 #ifdef _IPQOS_CONF_DEBUG
9930 }
9931 args++;
9934 force_rback++;
9939 args++;
9947 }
9948 args++;
9952 args++;
9956 args++;
9960 viewall++;
9961 args++;
9964 verbose++;
9967 use_syslog++;
9972 }
9973 }
9975 /*
9976 * dissallow non-option args, > 1 cmd args and syslog/verbose flags set
9977 * for anything but apply.
9978 */
9984 }
9986 /* if no cmd option then show config */
9990 }
9992 /* stop concurrent ipqosconf invocations */
9996 }
9999 #ifdef _IPQOS_CONF_DEBUG
10016 }
10022 }