1 /* 2 * Copyright (c) 1994 University of Maryland 3 * All Rights Reserved. 4 * 5 * Permission to use, copy, modify, distribute, and sell this software and its 6 * documentation for any purpose is hereby granted without fee, provided that 7 * the above copyright notice appear in all copies and that both that 8 * copyright notice and this permission notice appear in supporting 9 * documentation, and that the name of U.M. not be used in advertising or 10 * publicity pertaining to distribution of the software without specific, 11 * written prior permission. U.M. makes no representations about the 12 * suitability of this software for any purpose. It is provided "as is" 13 * without express or implied warranty. 14 * 15 * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M. 17 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 18 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 19 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 21 * 22 * Author: James da Silva, Systems Design and Analysis Group 23 * Computer Science Department 24 * University of Maryland at College Park 25 */ 26 /*- 27 * SPDX-License-Identifier: BSD-2-Clause 28 * 29 * Copyright 2020 Alex Richardson <arichardson@FreeBSD.org> 30 * 31 * This software was developed by SRI International and the University of 32 * Cambridge Computer Laboratory (Department of Computer Science and 33 * Technology) under DARPA contract HR0011-18-C-0016 ("ECATS"), as part of the 34 * DARPA SSITH research programme. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * 2. Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in the 43 * documentation and/or other materials provided with the distribution. 44 * 45 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 46 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 47 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 48 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 49 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 50 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 51 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 52 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 53 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 54 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 55 * SUCH DAMAGE. 56 * 57 */ 58 /* 59 * crunched_main.c - main program for crunched binaries, it branches to a 60 * particular subprogram based on the value of argv[0]. Also included 61 * is a little program invoked when the crunched binary is called via 62 * its EXECNAME. This one prints out the list of compiled-in binaries, 63 * or calls one of them based on argv[1]. This allows the testing of 64 * the crunched binary without creating all the links. 65 */ 66 67 #include <sys/param.h> 68 #include <sys/auxv.h> 69 #include <sys/sysctl.h> 70 71 #include <err.h> 72 #include <stdio.h> 73 #include <stdlib.h> 74 #include <string.h> 75 76 typedef int crunched_stub_t(int, char **, char **); 77 78 struct stub { 79 const char *name; 80 crunched_stub_t *f; 81 }; 82 83 extern const char *__progname; 84 extern struct stub entry_points[]; 85 86 static void crunched_usage(void); 87 88 crunched_stub_t crunched_main; 89 90 static struct stub * 91 find_entry_point(const char *basename) 92 { 93 struct stub *ep = NULL; 94 95 for (ep = entry_points; ep->name != NULL; ep++) 96 if (!strcmp(basename, ep->name)) 97 return (ep); 98 99 return (NULL); 100 } 101 102 static const char * 103 get_basename(const char *exe_path) 104 { 105 const char *slash = strrchr(exe_path, '/'); 106 return (slash ? slash + 1 : exe_path); 107 } 108 109 int 110 main(int argc, char **argv, char **envp) 111 { 112 struct stub *ep = NULL; 113 const char *basename = NULL; 114 char buf[MAXPATHLEN]; 115 116 /* 117 * Look at __progname first (this will be set if the crunched binary is 118 * invoked directly). 119 */ 120 if (__progname) { 121 basename = get_basename(__progname); 122 ep = find_entry_point(basename); 123 } 124 125 /* 126 * Otherwise try to find entry point based on argv[0] (this works for 127 * both symlinks as well as hardlinks). However, it does not work when 128 * su invokes a crunched shell because it sets argv[0] to _su when 129 * invoking the shell. In that case we look at AT_EXECPATH as a 130 * fallback. 131 */ 132 if (ep == NULL) { 133 basename = get_basename(argv[0]); 134 ep = find_entry_point(basename); 135 } 136 137 /* 138 * If we didn't find the entry point based on __progname or argv[0], 139 * try AT_EXECPATH to get the actual binary that was executed. 140 */ 141 if (ep == NULL) { 142 int error = elf_aux_info(AT_EXECPATH, &buf, sizeof(buf)); 143 144 if (error == 0) { 145 const char *exe_name = get_basename(buf); 146 /* 147 * Keep using argv[0] if AT_EXECPATH is the crunched 148 * binary so that symlinks to the crunched binary report 149 * "not compiled in" instead of invoking 150 * crunched_main(). 151 */ 152 if (strcmp(exe_name, EXECNAME) != 0) { 153 basename = exe_name; 154 ep = find_entry_point(basename); 155 } 156 } else { 157 warnc(error, "elf_aux_info(AT_EXECPATH) failed"); 158 } 159 } 160 161 if (basename == NULL || *basename == '\0') 162 crunched_usage(); 163 164 if (ep != NULL) { 165 return ep->f(argc, argv, envp); 166 } else { 167 fprintf(stderr, "%s: %s not compiled in\n", EXECNAME, basename); 168 crunched_usage(); 169 } 170 } 171 172 int 173 crunched_main(int argc, char **argv, char **envp) 174 { 175 if (argc <= 1) 176 crunched_usage(); 177 178 __progname = get_basename(argv[1]); 179 return main(--argc, ++argv, envp); 180 } 181 182 static void 183 crunched_usage(void) 184 { 185 int columns, len; 186 struct stub *ep; 187 188 fprintf(stderr, 189 "usage: %s <prog> <args> ..., where <prog> is one of:\n", EXECNAME); 190 columns = 0; 191 for (ep = entry_points; ep->name != NULL; ep++) { 192 len = strlen(ep->name) + 1; 193 if (columns + len < 80) 194 columns += len; 195 else { 196 fprintf(stderr, "\n"); 197 columns = len; 198 } 199 fprintf(stderr, " %s", ep->name); 200 } 201 fprintf(stderr, "\n"); 202 exit(1); 203 } 204 205 /* end of crunched_main.c */ 206