1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <ipsec_util.h>
29 #include <stdlib.h>
30 #include <strings.h>
31 #include <netdb.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <libintl.h>
35 #include <errno.h>
36 
37 static char *preamble =
38 "# /etc/inet/ipsecalgs output from ipsecalgs(1m)\n"
39 "#\n"
40 "# DO NOT EDIT OR PARSE THIS FILE!\n"
41 "#\n"
42 "# Use the ipsecalgs(1m) command to change the contents of this file.\n"
43 "# The algorithm descriptions contained in this file are synchronised to the\n"
44 "# kernel with ipsecalgs -s, the kernel validates the entries at this point."
45 "\n\n"
46 "# PROTO|protocol-id|protocol-name|exec-mode\n"
47 "##  NOTE:  Some protocol numbers are well-known and defined in <netdb.h>\n\n"
48 "# ALG|protocol-id|alg-id|name,name,...|ef-id| \n"
49 "#        {default/}{key,key..}or{key-key,inc}|block_size or MAC-size|\n"
50 "#        [parameter,parameter..]|[flags]\n\n"
51 "#\n"
52 "## Note:   Parameters and flags only apply to certain algorithms.\n\n";
53 
54 #define	CFG_PERMS S_IRUSR | S_IRGRP | S_IROTH	/* Perms 0444. */
55 #define	CFG_OWNER 0	/* root */
56 #define	CFG_GROUP 1	/* "other" */
57 
58 /*
59  * write_new_algfile() helper macros to check for write errors.
60  */
61 
62 #define	FPRINTF_ERR(fcall) if ((fcall) < 0) {	\
63 	rc = LIBIPSEC_ALGS_DIAG_ALGSFILEWRITE;	\
64 	goto bail;				\
65 }
66 
67 #define	FPUT_ERR(fcall) if ((fcall) == EOF) {	\
68 	rc = LIBIPSEC_ALGS_DIAG_ALGSFILEWRITE;	\
69 	goto bail;				\
70 }
71 
72 /*
73  * Helper macros to start and finish a list of entries that were added
74  * as part of a package installation.
75  */
76 
77 #define	PKG_SEC_START(pkgname, doing_pkg, cur_pkg) {		\
78 	(void) strcpy((cur_pkg), (pkgname));			\
79 	FPRINTF_ERR(fprintf(f, "%s%s\n",			\
80 	    LIBIPSEC_ALGS_LINE_PKGSTART, (cur_pkg)));		\
81 	(doing_pkg) = B_TRUE;					\
82 }
83 
84 #define	PKG_SEC_END(doing_pkg, cur_pkg) {			\
85 	if (doing_pkg) {					\
86 		FPRINTF_ERR(fprintf(f, "%s%s\n",		\
87 		    LIBIPSEC_ALGS_LINE_PKGEND, (cur_pkg)));	\
88 		(doing_pkg) = B_FALSE;				\
89 	}							\
90 }
91 
92 /*
93  * Take a zero-terminated int array and print int1,int2...,intN.
94  * If zero-only, then print a single '0'.
95  * Returns 0 on success, -1 if an error occurred while writing to
96  * the specified file.
97  */
98 int
list_ints(FILE * f,int * floater)99 list_ints(FILE *f, int *floater)
100 {
101 	boolean_t executed = B_FALSE;
102 
103 	while (*floater != 0) {
104 		executed = B_TRUE;
105 		if (fprintf(f, "%d", *floater) < 0)
106 			return (-1);
107 		if (*(++floater) != 0)
108 			if (fputc(',', f) == EOF)
109 				return (-1);
110 	}
111 
112 	if (!executed)
113 		if (fputc('0', f) == EOF)
114 			return (-1);
115 
116 	return (0);
117 }
118 
119 /*
120  * If the specified algorithm was defined within a package section, i.e.
121  * between the lines "# Start <pkgname>" and "# End <pkgname>", returns
122  * the value of <pkgname>.
123  */
124 static char *
alg_has_pkg(ipsec_proto_t * proto,struct ipsecalgent * alg)125 alg_has_pkg(ipsec_proto_t *proto, struct ipsecalgent *alg)
126 {
127 	int i;
128 
129 	if (proto->proto_algs_pkgs == NULL)
130 		return (NULL);
131 
132 	for (i = 0; i < proto->proto_algs_npkgs; i++)
133 		if (proto->proto_algs_pkgs[i].alg_num == alg->a_alg_num)
134 			return (proto->proto_algs_pkgs[i].pkg_name);
135 
136 	return (NULL);
137 }
138 
139 /*
140  * Writes the package start/end delimiters according to the package
141  * name associated with the current protocol or algorithm, and
142  * the state of the packaging information already written to the file.
143  * Called by write_new_algfile(). Returns 0 on success, one of the
144  * LIBIPSEC_DIAG codes on failure.
145  */
146 static int
pkg_section(FILE * f,char * pkg_name,boolean_t * doing_pkg,char * cur_pkg)147 pkg_section(FILE *f, char *pkg_name, boolean_t *doing_pkg, char *cur_pkg)
148 {
149 	int rc = 0;
150 
151 	if (pkg_name != NULL) {
152 		/* protocol or algorithm is associated with a package */
153 		if (!*doing_pkg) {
154 			/* start of a new package section */
155 			PKG_SEC_START(pkg_name, *doing_pkg, cur_pkg);
156 		} else {
157 			/* already in a package section */
158 			if (strcmp(pkg_name, cur_pkg) != 0) {
159 				/* different package name */
160 				PKG_SEC_END(*doing_pkg, cur_pkg);
161 				PKG_SEC_START(pkg_name, *doing_pkg, cur_pkg);
162 			}
163 		}
164 	} else if (*doing_pkg) {
165 		/* in a package section when the entry isn't */
166 		PKG_SEC_END(*doing_pkg, cur_pkg);
167 	}
168 bail:
169 	return (rc);
170 }
171 
172 /*
173  * Given a list of protocols and number, write them to a new algorithm file.
174  * This function takes num_protos + num_protos * dois-per-alg operations.
175  * Also free the protocol structure.
176  *
177  * Note that no locking spans the read/update/write phases that can be
178  * used by callers of this routine. This could cause this function to suffer
179  * from the "lost update" problem. Since updates to the IPsec protocols
180  * and algorithm tables are very infrequent, this should not be a issue in
181  * practice.
182  */
183 static int
write_new_algfile(ipsec_proto_t * protos,int num_protos)184 write_new_algfile(ipsec_proto_t *protos, int num_protos)
185 {
186 	FILE *f;
187 	int fd, i, j, k;
188 	int rc = 0;
189 	struct ipsecalgent *alg;
190 	char cur_pkg[1024];
191 	boolean_t doing_pkg = B_FALSE;
192 	char *alg_pkg;
193 	char tmp_name_template[] = INET_IPSECALGSPATH "ipsecalgsXXXXXX";
194 	char *tmp_name;
195 
196 	/*
197 	 * In order to avoid potentially corrupting the configuration
198 	 * file on file system failure, write the new configuration info
199 	 * to a temporary file which is then renamed to the configuration
200 	 * file (INET_IPSECALGSFILE.)
201 	 */
202 	tmp_name = mktemp(tmp_name_template);
203 
204 	fd = open(tmp_name, O_WRONLY|O_CREAT|O_EXCL, CFG_PERMS);
205 	if (fd == -1) {
206 		rc = LIBIPSEC_ALGS_DIAG_ALGSFILEOPEN;
207 		goto bail;
208 	}
209 
210 	f = fdopen(fd, "w");
211 	if (f == NULL) {
212 		(void) close(fd);
213 		rc = LIBIPSEC_ALGS_DIAG_ALGSFILEFDOPEN;
214 		goto bail;
215 	}
216 
217 	FPUT_ERR(fputs(preamble, f));
218 
219 	/* Write protocol entries. */
220 	for (i = 0; i < num_protos; i++) {
221 
222 		/* add package section delimiters if needed */
223 		rc = pkg_section(f, protos[i].proto_pkg, &doing_pkg, cur_pkg);
224 		if (rc != 0)
225 			goto bail;
226 
227 		FPRINTF_ERR(fprintf(f, "%s%d|%s|",
228 		    LIBIPSEC_ALGS_LINE_PROTO,
229 		    protos[i].proto_num, protos[i].proto_name));
230 		switch (protos[i].proto_exec_mode) {
231 		case LIBIPSEC_ALGS_EXEC_SYNC:
232 			FPRINTF_ERR(fprintf(f, "sync\n"));
233 			break;
234 		case LIBIPSEC_ALGS_EXEC_ASYNC:
235 			FPRINTF_ERR(fprintf(f, "async\n"));
236 			break;
237 		}
238 	}
239 
240 	/* terminate the package section for the protocols if needed */
241 	PKG_SEC_END(doing_pkg, cur_pkg);
242 
243 	FPUT_ERR(fputs("\n", f));
244 
245 	/* Write algorithm entries. */
246 
247 	for (i = 0; i < num_protos; i++) {
248 		for (j = 0; j < protos[i].proto_numalgs; j++) {
249 			alg = protos[i].proto_algs[j];
250 
251 			/* add package section delimiters if needed */
252 			alg_pkg = alg_has_pkg(&protos[i], alg);
253 			rc = pkg_section(f, alg_pkg, &doing_pkg, cur_pkg);
254 			if (rc != 0)
255 				goto bail;
256 
257 			/* protocol and algorithm numbers */
258 			FPRINTF_ERR(fprintf(f, "%s%d|%d|",
259 			    LIBIPSEC_ALGS_LINE_ALG,
260 			    alg->a_proto_num, alg->a_alg_num));
261 
262 			/* algorithm names */
263 			for (k = 0; alg->a_names[k] != NULL; k++) {
264 				FPRINTF_ERR(fprintf(f, "%s", alg->a_names[k]));
265 				if (alg->a_names[k+1] != NULL)
266 					FPRINTF_ERR(fprintf(f, ","));
267 			}
268 
269 			/* mechanism name */
270 			FPRINTF_ERR(fprintf(f, "|%s|", alg->a_mech_name));
271 
272 			/* key sizes */
273 			if (alg->a_key_increment == 0) {
274 				/* key sizes defined by enumeration */
275 				if (list_ints(f, alg->a_key_sizes) == -1) {
276 					rc = LIBIPSEC_ALGS_DIAG_ALGSFILEWRITE;
277 					goto bail;
278 				}
279 			} else {
280 				/* key sizes defined by range */
281 				FPRINTF_ERR(fprintf(f, "%d/%d-%d,%d",
282 				    alg->a_key_sizes[0], alg->a_key_sizes[1],
283 				    alg->a_key_sizes[2], alg->a_key_increment));
284 			}
285 			FPUT_ERR(fputc('|', f));
286 
287 			/* block sizes */
288 			if (list_ints(f, alg->a_block_sizes) == -1) {
289 				rc = LIBIPSEC_ALGS_DIAG_ALGSFILEWRITE;
290 				goto bail;
291 			}
292 			FPUT_ERR(fputc('|', f));
293 
294 			/*
295 			 * Some algorithms require extra parameters, these
296 			 * are stored in an array. For algorithms that don't
297 			 * need these parameters, or flags (below), these
298 			 * extra fields in the ipsecalgs file must contain a
299 			 * zero. This fuction will get called if a algorithm
300 			 * entry is added, at this point the extra fields will
301 			 * be added to the file.
302 			 */
303 			if (list_ints(f, alg->a_mech_params) == -1) {
304 				rc = LIBIPSEC_ALGS_DIAG_ALGSFILEWRITE;
305 				goto bail;
306 			}
307 			/* flags */
308 			FPRINTF_ERR(fprintf(f, "|%d\n", alg->a_alg_flags));
309 		}
310 	}
311 
312 	/* terminate the package section for the algorithms if needed */
313 	PKG_SEC_END(doing_pkg, cur_pkg);
314 
315 	if (fchmod(fd, CFG_PERMS) == -1) {
316 		rc = LIBIPSEC_ALGS_DIAG_ALGSFILECHMOD;
317 		goto bail;
318 	}
319 	if (fchown(fd, CFG_OWNER, CFG_GROUP) == -1) {
320 		rc = LIBIPSEC_ALGS_DIAG_ALGSFILECHOWN;
321 		goto bail;
322 	}
323 	if (fclose(f) == EOF) {
324 		rc = LIBIPSEC_ALGS_DIAG_ALGSFILECLOSE;
325 		goto bail;
326 	}
327 
328 	if (rename(tmp_name, INET_IPSECALGSFILE) == -1)
329 		rc = LIBIPSEC_ALGS_DIAG_ALGSFILERENAME;
330 
331 bail:
332 	_clean_trash(protos, num_protos);
333 	return (rc);
334 }
335 
336 /*
337  * Return a pointer to the protocol entry corresponding to the specified
338  * protocol num proto_num. Also builds the list of currently defined
339  * protocols.
340  */
341 static ipsec_proto_t *
proto_setup(ipsec_proto_t ** protos,int * num_protos,int proto_num,boolean_t cleanup)342 proto_setup(ipsec_proto_t **protos, int *num_protos, int proto_num,
343     boolean_t cleanup)
344 {
345 	int i;
346 	ipsec_proto_t *current_proto, *ret_proto = NULL;
347 
348 	_build_internal_algs(protos, num_protos);
349 
350 	if (*protos == NULL)
351 		return (NULL);
352 
353 	for (i = 0; i < *num_protos; i++) {
354 		current_proto = (*protos) + i;
355 		if (current_proto->proto_num == proto_num) {
356 			ret_proto = current_proto;
357 			break;
358 		}
359 	}
360 
361 	if (ret_proto == NULL) {
362 		if (cleanup)
363 			_clean_trash(*protos, *num_protos);
364 		/* else caller wants parsed /etc/inet/ipsecalgs anyway */
365 	}
366 
367 	return (ret_proto);
368 }
369 
370 /*
371  * Delete the first found algorithm of the specified protocol which
372  * has the same name as the one specified by alg_name. Deletion of
373  * the entry takes place only if the delete_it flag is set. If an
374  * entry was found, return B_TRUE, otherwise return B_FALSE.
375  */
376 static boolean_t
delipsecalgbyname_common(const char * name,ipsec_proto_t * proto,boolean_t delete_it)377 delipsecalgbyname_common(const char *name, ipsec_proto_t *proto,
378     boolean_t delete_it)
379 {
380 	int i;
381 	char **name_check;
382 	boolean_t found_match = B_FALSE;
383 
384 	for (i = 0; i < proto->proto_numalgs; i++) {
385 		if (!found_match) {
386 			for (name_check =
387 			    proto->proto_algs[i]->a_names;
388 			    *name_check != NULL; name_check++) {
389 				/*
390 				 * Can use strcmp because the algorithm names
391 				 * are bound.
392 				 */
393 				if (strcmp(*name_check, name) == 0) {
394 					found_match = B_TRUE;
395 					if (!delete_it)
396 						return (found_match);
397 					freeipsecalgent(proto->proto_algs[i]);
398 					break;
399 				}
400 			}
401 		} else {
402 			proto->proto_algs[i - 1] = proto->proto_algs[i];
403 		}
404 	}
405 
406 	if (found_match)
407 		proto->proto_numalgs--;
408 
409 	return (found_match);
410 }
411 
412 /*
413  * Returns B_TRUE if the specified 0-terminated lists of key or
414  * block sizes match, B_FALSE otherwise.
415  */
416 static boolean_t
sizes_match(int * a1,int * a2)417 sizes_match(int *a1, int *a2)
418 {
419 	int i;
420 
421 	for (i = 0; (a1[i] != 0) && (a2[i] != 0); i++) {
422 		if (a1[i] != a2[i])
423 			return (B_FALSE);
424 	}
425 	if ((a1[i] != 0) || (a2[i] != 0))
426 		return (B_FALSE);
427 
428 	return (B_TRUE);
429 }
430 
431 /*
432  * Returns B_TRUE if an _exact_ equivalent of the specified algorithm
433  * already exists, B_FALSE otherwise.
434  */
435 static boolean_t
ipsecalg_exists(struct ipsecalgent * newbie,ipsec_proto_t * proto)436 ipsecalg_exists(struct ipsecalgent *newbie, ipsec_proto_t *proto)
437 {
438 	struct ipsecalgent *curalg;
439 	char **curname, **newbiename;
440 	int i;
441 	boolean_t match;
442 
443 	for (i = 0; i < proto->proto_numalgs; i++) {
444 		curalg = proto->proto_algs[i];
445 
446 		if (curalg->a_alg_num != newbie->a_alg_num)
447 			continue;
448 
449 		if (curalg->a_key_increment != newbie->a_key_increment)
450 			continue;
451 
452 		if (strcmp(curalg->a_mech_name, newbie->a_mech_name) != 0)
453 			continue;
454 
455 		curname = curalg->a_names;
456 		newbiename = newbie->a_names;
457 		match = B_TRUE;
458 		while ((*curname != NULL) && (*newbiename != NULL) && match) {
459 			match = (strcmp(*curname, *newbiename) == 0);
460 			curname++;
461 			newbiename++;
462 		}
463 		if (!match || (*curname != NULL) || (*newbiename != NULL))
464 			continue;
465 
466 		if (!sizes_match(curalg->a_block_sizes, newbie->a_block_sizes))
467 			continue;
468 
469 		if (!sizes_match(curalg->a_key_sizes, newbie->a_key_sizes))
470 			continue;
471 
472 		/* we found an exact match */
473 		return (B_TRUE);
474 	}
475 
476 	return (B_FALSE);
477 }
478 
479 /*
480  * Add a new algorithm to the /etc/inet/ipsecalgs file.  Caller must free
481  * or otherwise address "newbie".
482  */
483 int
addipsecalg(struct ipsecalgent * newbie,uint_t flags)484 addipsecalg(struct ipsecalgent *newbie, uint_t flags)
485 {
486 	ipsec_proto_t *protos, *current_proto;
487 	struct ipsecalgent *clone, **holder;
488 	int num_protos, i;
489 	char **name_check;
490 	boolean_t forced_add = (flags & LIBIPSEC_ALGS_ADD_FORCE) != 0;
491 	boolean_t found_match;
492 
493 	if ((current_proto = proto_setup(&protos, &num_protos,
494 	    newbie->a_proto_num, B_TRUE)) == NULL)
495 		return (LIBIPSEC_ALGS_DIAG_UNKN_PROTO);
496 
497 	/*
498 	 * If an algorithm that matches _exactly_ the new algorithm
499 	 * already exists, we're done.
500 	 */
501 	if (ipsecalg_exists(newbie, current_proto))
502 		return (0);
503 
504 	/*
505 	 * We don't allow a new algorithm to be created if one of
506 	 * its names is already defined for an existing algorithm,
507 	 * unless the operation is forced, in which case existing
508 	 * algorithm entries that conflict with the new one are
509 	 * deleted.
510 	 */
511 	for (name_check = newbie->a_names; *name_check != NULL; name_check++) {
512 		found_match = delipsecalgbyname_common(*name_check,
513 		    current_proto, forced_add);
514 		if (found_match && !forced_add) {
515 			/*
516 			 * Duplicate entry found, but the addition was
517 			 * not forced.
518 			 */
519 			_clean_trash(protos, num_protos);
520 			return (LIBIPSEC_ALGS_DIAG_ALG_EXISTS);
521 		}
522 	}
523 
524 	for (i = 0; i < current_proto->proto_numalgs; i++) {
525 		if (current_proto->proto_algs[i]->a_alg_num ==
526 		    newbie->a_alg_num) {
527 			/*
528 			 * An algorithm with the same protocol number
529 			 * and algorithm number already exists. Fail
530 			 * addition unless the operation is forced.
531 			 */
532 			if (flags & LIBIPSEC_ALGS_ADD_FORCE) {
533 				clone = _duplicate_alg(newbie);
534 				if (clone != NULL) {
535 					freeipsecalgent(
536 					    current_proto->proto_algs[i]);
537 					current_proto->proto_algs[i] = clone;
538 					return (write_new_algfile(protos,
539 					    num_protos));
540 				} else {
541 					_clean_trash(protos, num_protos);
542 					return (LIBIPSEC_ALGS_DIAG_NOMEM);
543 				}
544 			} else {
545 				_clean_trash(protos, num_protos);
546 				return (LIBIPSEC_ALGS_DIAG_ALG_EXISTS);
547 			}
548 		}
549 	}
550 
551 	/* append the new algorithm */
552 	holder = realloc(current_proto->proto_algs,
553 	    sizeof (struct ipsecalgent *) * (i + 1));
554 	if (holder == NULL) {
555 		_clean_trash(protos, num_protos);
556 		return (LIBIPSEC_ALGS_DIAG_NOMEM);
557 	}
558 	clone = _duplicate_alg(newbie);
559 	if (clone == NULL) {
560 		free(holder);
561 		_clean_trash(protos, num_protos);
562 		return (LIBIPSEC_ALGS_DIAG_NOMEM);
563 	}
564 	current_proto->proto_numalgs++;
565 	current_proto->proto_algs = holder;
566 	current_proto->proto_algs[i] = clone;
567 	return (write_new_algfile(protos, num_protos));
568 }
569 
570 /*
571  * Delete an algorithm by name & protocol number from /etc/inet/ipsecalgs.
572  * Only deletes the first encountered instance.
573  */
574 int
delipsecalgbyname(const char * name,int proto_num)575 delipsecalgbyname(const char *name, int proto_num)
576 {
577 	ipsec_proto_t *protos, *current_proto;
578 	int num_protos;
579 
580 	if ((current_proto = proto_setup(&protos, &num_protos, proto_num,
581 	    B_TRUE)) == NULL)
582 		return (LIBIPSEC_ALGS_DIAG_UNKN_PROTO);
583 
584 	if (delipsecalgbyname_common(name, current_proto, B_TRUE))
585 		return (write_new_algfile(protos, num_protos));
586 
587 	_clean_trash(protos, num_protos);
588 	return (LIBIPSEC_ALGS_DIAG_UNKN_ALG);
589 }
590 
591 /*
592  * Delete an algorithm by num + protocol num from /etc/inet/ipsecalgs.
593  */
594 int
delipsecalgbynum(int alg_num,int proto_num)595 delipsecalgbynum(int alg_num, int proto_num)
596 {
597 	ipsec_proto_t *protos, *current_proto;
598 	int i, num_protos;
599 	boolean_t found_match = B_FALSE;
600 
601 	if ((current_proto = proto_setup(&protos, &num_protos, proto_num,
602 	    B_TRUE)) == NULL)
603 		return (LIBIPSEC_ALGS_DIAG_UNKN_PROTO);
604 
605 	for (i = 0; i < current_proto->proto_numalgs; i++) {
606 		if (!found_match) {
607 			if (current_proto->proto_algs[i]->a_alg_num ==
608 			    alg_num) {
609 				found_match = B_TRUE;
610 				freeipsecalgent(current_proto->proto_algs[i]);
611 			}
612 		} else {
613 			current_proto->proto_algs[i - 1] =
614 			    current_proto->proto_algs[i];
615 		}
616 	}
617 
618 	if (found_match) {
619 		current_proto->proto_numalgs--;
620 		return (write_new_algfile(protos, num_protos));
621 	}
622 
623 	_clean_trash(protos, num_protos);
624 	return (LIBIPSEC_ALGS_DIAG_UNKN_ALG);
625 }
626 
627 /*
628  * Remove the specified protocol entry from the list of protocols.
629  */
630 static void
delipsecproto_common(ipsec_proto_t * protos,int num_protos,ipsec_proto_t * proto)631 delipsecproto_common(ipsec_proto_t *protos, int num_protos,
632     ipsec_proto_t *proto)
633 {
634 	int i;
635 
636 	/* free protocol storage */
637 	free(proto->proto_name);
638 	for (i = 0; i < proto->proto_numalgs; i++)
639 		freeipsecalgent(proto->proto_algs[i]);
640 
641 	/* remove from list of prototocols */
642 	for (i = (proto - protos + 1); i < num_protos; i++)
643 		protos[i - 1] = protos[i];
644 }
645 
646 /*
647  * Add an IPsec protocol to /etc/inet/ipsecalgs.
648  */
649 int
addipsecproto(const char * proto_name,int proto_num,ipsecalgs_exec_mode_t proto_exec_mode,uint_t flags)650 addipsecproto(const char *proto_name, int proto_num,
651     ipsecalgs_exec_mode_t proto_exec_mode, uint_t flags)
652 {
653 	ipsec_proto_t *protos, *current_proto, *new_proto;
654 	int i, num_protos;
655 
656 	/*
657 	 * NOTE:If build_internal_algs returns NULL for any
658 	 *	reason, we will end up clobbering /etc/inet/ipsecalgs!
659 	 */
660 
661 	current_proto = proto_setup(&protos, &num_protos, proto_num, B_FALSE);
662 
663 	/* check for protocol with duplicate id */
664 	if (current_proto != NULL) {
665 		if ((strcmp(proto_name, current_proto->proto_name) == 0) &&
666 		    (proto_exec_mode == current_proto->proto_exec_mode)) {
667 			/*
668 			 * The current protocol being added matches
669 			 * exactly an existing protocol, we're done.
670 			 */
671 			return (0);
672 		}
673 		if (!(flags & LIBIPSEC_ALGS_ADD_FORCE))
674 			return (LIBIPSEC_ALGS_DIAG_PROTO_EXISTS);
675 		delipsecproto_common(protos, num_protos--, current_proto);
676 	}
677 
678 	/* check for protocol with duplicate name */
679 	for (i = 0; i < num_protos; i++) {
680 		if (strcmp(protos[i].proto_name, proto_name) == 0) {
681 			if (!(flags & LIBIPSEC_ALGS_ADD_FORCE))
682 				return (LIBIPSEC_ALGS_DIAG_PROTO_EXISTS);
683 			delipsecproto_common(protos, num_protos--, &protos[i]);
684 			break;
685 		}
686 	}
687 
688 	/* add new protocol */
689 	num_protos++;
690 	new_proto = realloc(protos, num_protos *
691 	    sizeof (ipsec_proto_t));
692 	if (new_proto == NULL) {
693 		_clean_trash(protos, num_protos - 1);
694 		return (LIBIPSEC_ALGS_DIAG_NOMEM);
695 	}
696 	protos = new_proto;
697 	new_proto += (num_protos - 1);
698 
699 	/* initialize protocol entry */
700 	new_proto->proto_num = proto_num;
701 	new_proto->proto_numalgs = 0;
702 	new_proto->proto_algs = NULL;
703 	new_proto->proto_name = strdup(proto_name);
704 	if (new_proto->proto_name == NULL) {
705 		_clean_trash(protos, num_protos);
706 		return (LIBIPSEC_ALGS_DIAG_NOMEM);
707 	}
708 	new_proto->proto_pkg = NULL;
709 	new_proto->proto_algs_pkgs = NULL;
710 	new_proto->proto_algs_npkgs = 0;
711 	new_proto->proto_exec_mode = proto_exec_mode;
712 
713 	return (write_new_algfile(protos, num_protos));
714 }
715 
716 /*
717  * Delete an IPsec protocol entry from /etc/inet/ipsecalgs.  This also
718  * nukes the associated algorithms.
719  */
720 int
delipsecprotobynum(int proto_num)721 delipsecprotobynum(int proto_num)
722 {
723 	ipsec_proto_t *protos, *current_proto;
724 	int num_protos;
725 
726 	if ((current_proto = proto_setup(&protos, &num_protos, proto_num,
727 	    B_TRUE)) == NULL)
728 		return (LIBIPSEC_ALGS_DIAG_UNKN_PROTO);
729 
730 	delipsecproto_common(protos, num_protos--, current_proto);
731 
732 	return (write_new_algfile(protos, num_protos));
733 }
734 
735 int
delipsecprotobyname(const char * proto_name)736 delipsecprotobyname(const char *proto_name)
737 {
738 	int proto_num;
739 
740 	proto_num = getipsecprotobyname(proto_name);
741 	if (proto_num == -1)
742 		return (LIBIPSEC_ALGS_DIAG_UNKN_PROTO);
743 
744 	return (delipsecprotobynum(proto_num));
745 }
746 
747 /*
748  * Implement these in libnsl since these are read-only operations.
749  */
750 int *
getipsecprotos(int * nentries)751 getipsecprotos(int *nentries)
752 {
753 	return (_real_getipsecprotos(nentries));
754 }
755 
756 int *
getipsecalgs(int * nentries,int proto_num)757 getipsecalgs(int *nentries, int proto_num)
758 {
759 	return (_real_getipsecalgs(nentries, proto_num));
760 }
761 
762 const char *
ipsecalgs_diag(int diag)763 ipsecalgs_diag(int diag)
764 {
765 	switch (diag) {
766 	case LIBIPSEC_ALGS_DIAG_ALG_EXISTS:
767 		return (dgettext(TEXT_DOMAIN, "Algorithm already exists"));
768 	case LIBIPSEC_ALGS_DIAG_PROTO_EXISTS:
769 		return (dgettext(TEXT_DOMAIN, "Protocol already exists"));
770 	case LIBIPSEC_ALGS_DIAG_UNKN_PROTO:
771 		return (dgettext(TEXT_DOMAIN, "Unknown protocol"));
772 	case LIBIPSEC_ALGS_DIAG_UNKN_ALG:
773 		return (dgettext(TEXT_DOMAIN, "Unknown algorithm"));
774 	case LIBIPSEC_ALGS_DIAG_NOMEM:
775 		return (dgettext(TEXT_DOMAIN, "Out of memory"));
776 	case LIBIPSEC_ALGS_DIAG_ALGSFILEOPEN:
777 		return (dgettext(TEXT_DOMAIN, "open() failed"));
778 	case LIBIPSEC_ALGS_DIAG_ALGSFILEFDOPEN:
779 		return (dgettext(TEXT_DOMAIN, "fdopen() failed"));
780 	case LIBIPSEC_ALGS_DIAG_ALGSFILELOCK:
781 		return (dgettext(TEXT_DOMAIN, "lockf() failed"));
782 	case LIBIPSEC_ALGS_DIAG_ALGSFILERENAME:
783 		return (dgettext(TEXT_DOMAIN, "rename() failed"));
784 	case LIBIPSEC_ALGS_DIAG_ALGSFILEWRITE:
785 		return (dgettext(TEXT_DOMAIN, "write to file failed"));
786 	case LIBIPSEC_ALGS_DIAG_ALGSFILECHMOD:
787 		return (dgettext(TEXT_DOMAIN, "chmod() failed"));
788 	case LIBIPSEC_ALGS_DIAG_ALGSFILECHOWN:
789 		return (dgettext(TEXT_DOMAIN, "chown() failed"));
790 	case LIBIPSEC_ALGS_DIAG_ALGSFILECLOSE:
791 		return (dgettext(TEXT_DOMAIN, "close() failed"));
792 	default:
793 		return (dgettext(TEXT_DOMAIN, "failed"));
794 	}
795 }
796 
797 /*
798  * Get the execution mode corresponding to the specified protocol.
799  * Returns 0 on success, one of the LIBIPSEC_ALGS_DIAG_* values on
800  * failure.
801  */
802 int
ipsecproto_get_exec_mode(int proto_num,ipsecalgs_exec_mode_t * exec_mode)803 ipsecproto_get_exec_mode(int proto_num, ipsecalgs_exec_mode_t *exec_mode)
804 {
805 	ipsec_proto_t *protos, *current_proto;
806 	int num_protos;
807 
808 	if ((current_proto = proto_setup(&protos, &num_protos, proto_num,
809 	    B_TRUE)) == NULL)
810 		return (LIBIPSEC_ALGS_DIAG_UNKN_PROTO);
811 
812 	*exec_mode = current_proto->proto_exec_mode;
813 
814 	_clean_trash(protos, num_protos);
815 	return (0);
816 }
817 
818 /*
819  * Set the execution mode of the specified protocol. Returns 0 on success,
820  * or one of the LIBIPSEC_ALGS_DIAG_* values on failure.
821  */
822 int
ipsecproto_set_exec_mode(int proto_num,ipsecalgs_exec_mode_t exec_mode)823 ipsecproto_set_exec_mode(int proto_num, ipsecalgs_exec_mode_t exec_mode)
824 {
825 	ipsec_proto_t *protos, *current_proto;
826 	int num_protos;
827 
828 	if ((current_proto = proto_setup(&protos, &num_protos, proto_num,
829 	    B_TRUE)) == NULL)
830 		return (LIBIPSEC_ALGS_DIAG_UNKN_PROTO);
831 
832 	current_proto->proto_exec_mode = exec_mode;
833 
834 	return (write_new_algfile(protos, num_protos));
835 }
836