1 /* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by the University of 17 * California, Berkeley and its contributors. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #ifndef lint 36 static const char copyright[] = 37 "@(#) Copyright (c) 1983, 1993\n\ 38 The Regents of the University of California. All rights reserved.\n"; 39 #endif /* not lint */ 40 41 #ifndef lint 42 #if 0 43 static char sccsid[] = "@(#)lpc.c 8.3 (Berkeley) 4/28/95"; 44 #endif 45 static const char rcsid[] = 46 "$FreeBSD$"; 47 #endif /* not lint */ 48 49 #include <sys/param.h> 50 51 #include <ctype.h> 52 #include <dirent.h> 53 #include <err.h> 54 #include <grp.h> 55 #include <setjmp.h> 56 #include <signal.h> 57 #include <stdio.h> 58 #include <stdlib.h> 59 #include <syslog.h> 60 #include <string.h> 61 #include <unistd.h> 62 #include <histedit.h> 63 64 #include "lp.h" 65 #include "lpc.h" 66 #include "extern.h" 67 68 #ifndef LPR_OPER 69 #define LPR_OPER "operator" /* group name of lpr operators */ 70 #endif 71 72 /* 73 * lpc -- line printer control program 74 */ 75 76 #define MAX_CMDLINE 200 77 #define MAX_MARGV 20 78 static int fromatty; 79 80 static char cmdline[MAX_CMDLINE]; 81 static int margc; 82 static char *margv[MAX_MARGV]; 83 uid_t uid, euid; 84 85 int main(int _argc, char *_argv[]); 86 static void cmdscanner(void); 87 static struct cmd *getcmd(const char *_name); 88 static void intr(int _signo); 89 static void makeargv(void); 90 static int ingroup(const char *_grname); 91 92 int 93 main(int argc, char *argv[]) 94 { 95 register struct cmd *c; 96 97 euid = geteuid(); 98 uid = getuid(); 99 seteuid(uid); 100 progname = argv[0]; 101 openlog("lpd", 0, LOG_LPR); 102 103 if (--argc > 0) { 104 c = getcmd(*++argv); 105 if (c == (struct cmd *)-1) { 106 printf("?Ambiguous command\n"); 107 exit(1); 108 } 109 if (c == 0) { 110 printf("?Invalid command\n"); 111 exit(1); 112 } 113 if ((c->c_opts & LPC_PRIVCMD) && getuid() && 114 ingroup(LPR_OPER) == 0) { 115 printf("?Privileged command\n"); 116 exit(1); 117 } 118 if (c->c_generic != 0) 119 generic(c->c_generic, c->c_opts, c->c_handler, 120 argc, argv); 121 else 122 (*c->c_handler)(argc, argv); 123 exit(0); 124 } 125 fromatty = isatty(fileno(stdin)); 126 if (!fromatty) 127 signal(SIGINT, intr); 128 for (;;) { 129 cmdscanner(); 130 } 131 } 132 133 static void 134 intr(int signo __unused) 135 { 136 /* (the '__unused' is just to avoid a compile-time warning) */ 137 exit(0); 138 } 139 140 static const char * 141 lpc_prompt(void) 142 { 143 return ("lpc> "); 144 } 145 146 /* 147 * Command parser. 148 */ 149 static void 150 cmdscanner(void) 151 { 152 register struct cmd *c; 153 static EditLine *el; 154 static History *hist; 155 HistEvent he; 156 size_t len; 157 int num; 158 const char *bp; 159 160 num = 0; 161 bp = NULL; 162 el = NULL; 163 hist = NULL; 164 for (;;) { 165 if (fromatty) { 166 if (!el) { 167 el = el_init("lpc", stdin, stdout, stderr); 168 hist = history_init(); 169 history(hist, &he, H_EVENT, 100); 170 el_set(el, EL_HIST, history, hist); 171 el_set(el, EL_EDITOR, "emacs"); 172 el_set(el, EL_PROMPT, lpc_prompt); 173 el_set(el, EL_SIGNAL, 1); 174 el_source(el, NULL); 175 /* 176 * EditLine init may call 'cgetset()' to set a 177 * capability-db meant for termcap (eg: to set 178 * terminal type 'xterm'). Reset that now, or 179 * that same db-information will be used for 180 * printcap (giving us an "xterm" printer, with 181 * all kinds of invalid capabilities...). 182 */ 183 cgetset(NULL); 184 } 185 if ((bp = el_gets(el, &num)) == NULL || num == 0) 186 quit(0, NULL); 187 188 len = (num > MAX_CMDLINE) ? MAX_CMDLINE : num; 189 memcpy(cmdline, bp, len); 190 cmdline[len] = 0; 191 history(hist, &he, H_ENTER, bp); 192 193 } else { 194 if (fgets(cmdline, MAX_CMDLINE, stdin) == 0) 195 quit(0, NULL); 196 if (cmdline[0] == 0 || cmdline[0] == '\n') 197 break; 198 } 199 200 makeargv(); 201 if (margc == 0) 202 continue; 203 if (el_parse(el, margc, margv) != -1) 204 continue; 205 206 c = getcmd(margv[0]); 207 if (c == (struct cmd *)-1) { 208 printf("?Ambiguous command\n"); 209 continue; 210 } 211 if (c == 0) { 212 printf("?Invalid command\n"); 213 continue; 214 } 215 if ((c->c_opts & LPC_PRIVCMD) && getuid() && 216 ingroup(LPR_OPER) == 0) { 217 printf("?Privileged command\n"); 218 continue; 219 } 220 221 /* 222 * Two different commands might have the same generic rtn 223 * (eg: "clean" and "tclean"), and just use different 224 * handler routines for distinct command-setup. The handler 225 * routine might also be set on a generic routine for 226 * initial parameter processing. 227 */ 228 if (c->c_generic != 0) 229 generic(c->c_generic, c->c_opts, c->c_handler, 230 margc, margv); 231 else 232 (*c->c_handler)(margc, margv); 233 } 234 } 235 236 static struct cmd * 237 getcmd(const char *name) 238 { 239 register const char *p, *q; 240 register struct cmd *c, *found; 241 register int nmatches, longest; 242 243 longest = 0; 244 nmatches = 0; 245 found = 0; 246 for (c = cmdtab; (p = c->c_name); c++) { 247 for (q = name; *q == *p++; q++) 248 if (*q == 0) /* exact match? */ 249 return(c); 250 if (!*q) { /* the name was a prefix */ 251 if (q - name > longest) { 252 longest = q - name; 253 nmatches = 1; 254 found = c; 255 } else if (q - name == longest) 256 nmatches++; 257 } 258 } 259 if (nmatches > 1) 260 return((struct cmd *)-1); 261 return(found); 262 } 263 264 /* 265 * Slice a string up into argc/argv. 266 */ 267 static void 268 makeargv(void) 269 { 270 register char *cp; 271 register char **argp = margv; 272 register int n = 0; 273 274 margc = 0; 275 for (cp = cmdline; *cp && (size_t)(cp - cmdline) < sizeof(cmdline) && 276 n < MAX_MARGV; n++) { 277 while (isspace(*cp)) 278 cp++; 279 if (*cp == '\0') 280 break; 281 *argp++ = cp; 282 margc += 1; 283 while (*cp != '\0' && !isspace(*cp)) 284 cp++; 285 if (*cp == '\0') 286 break; 287 *cp++ = '\0'; 288 } 289 *argp++ = 0; 290 } 291 292 #define HELPINDENT (sizeof ("directory")) 293 294 /* 295 * Help command. 296 */ 297 void 298 help(int argc, char *argv[]) 299 { 300 register struct cmd *c; 301 302 if (argc == 1) { 303 register int i, j, w; 304 int columns, width = 0, lines; 305 306 printf("Commands may be abbreviated. Commands are:\n\n"); 307 for (c = cmdtab; c->c_name; c++) { 308 int len = strlen(c->c_name); 309 310 if (len > width) 311 width = len; 312 } 313 width = (width + 8) &~ 7; 314 columns = 80 / width; 315 if (columns == 0) 316 columns = 1; 317 lines = (NCMDS + columns - 1) / columns; 318 for (i = 0; i < lines; i++) { 319 for (j = 0; j < columns; j++) { 320 c = cmdtab + j * lines + i; 321 if (c->c_name) 322 printf("%s", c->c_name); 323 if (c + lines >= &cmdtab[NCMDS]) { 324 printf("\n"); 325 break; 326 } 327 w = strlen(c->c_name); 328 while (w < width) { 329 w = (w + 8) &~ 7; 330 putchar('\t'); 331 } 332 } 333 } 334 return; 335 } 336 while (--argc > 0) { 337 register char *arg; 338 arg = *++argv; 339 c = getcmd(arg); 340 if (c == (struct cmd *)-1) 341 printf("?Ambiguous help command %s\n", arg); 342 else if (c == (struct cmd *)0) 343 printf("?Invalid help command %s\n", arg); 344 else 345 printf("%-*s\t%s\n", (int) HELPINDENT, 346 c->c_name, c->c_help); 347 } 348 } 349 350 /* 351 * return non-zero if the user is a member of the given group 352 */ 353 static int 354 ingroup(const char *grname) 355 { 356 static struct group *gptr=NULL; 357 static int ngroups = 0; 358 static gid_t groups[NGROUPS]; 359 register gid_t gid; 360 register int i; 361 362 if (gptr == NULL) { 363 if ((gptr = getgrnam(grname)) == NULL) { 364 warnx("warning: unknown group '%s'", grname); 365 return(0); 366 } 367 ngroups = getgroups(NGROUPS, groups); 368 if (ngroups < 0) 369 err(1, "getgroups"); 370 } 371 gid = gptr->gr_gid; 372 for (i = 0; i < ngroups; i++) 373 if (gid == groups[i]) 374 return(1); 375 return(0); 376 } 377