applets/applets.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Utility routines.
   4  *
   5  * Copyright (C) tons of folks.  Tracking down who wrote what
   6  * isn't something I'm going to worry about...  If you wrote something
   7  * here, please feel free to acknowledge your work.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  *
  23  * Based in part on code from sash, Copyright (c) 1999 by David I. Bell
  24  * Permission has been granted to redistribute this code under the GPL.
  25  *
  26  */
  27
  28 #include <unistd.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include "busybox.h"
  33
  34 #undef APPLET
  35 #undef APPLET_NOUSAGE
  36 #undef PROTOTYPES
  37 #include "applets.h"
  38
  39 struct BB_applet *applet_using;
  40
  41 /* The -1 arises because of the {0,NULL,0,-1} entry above. */
  42 const size_t NUM_APPLETS = (sizeof (applets) / sizeof (struct BB_applet) - 1);
  43
  44
  45 #ifdef CONFIG_FEATURE_SUID
  46
  47 static void check_suid ( struct BB_applet *app );
  48
  49 #ifdef CONFIG_FEATURE_SUID_CONFIG
  50
  51 #include <sys/stat.h>
  52 #include <ctype.h>
  53 #include "pwd_.h"
  54 #include "grp_.h"
  55
  56 static int parse_config_file ( void );
  57
  58 static int config_ok;
  59
  60 #define CONFIG_FILE "/etc/busybox.conf"
  61
  62 /* applets [] is const, so we have to define this "override" structure */
  63 struct BB_suid_config {
  64         struct BB_applet *m_applet;
  65
  66         uid_t  m_uid;
  67         gid_t  m_gid;
  68         mode_t m_mode;
  69
  70         struct BB_suid_config *m_next;
  71 };
  72
  73 static struct BB_suid_config *suid_config;
  74
  75 #endif /* CONFIG_FEATURE_SUID_CONFIG */
  76
  77 #endif /* CONFIG_FEATURE_SUID */
  78
  79
  80
  81 extern void show_usage(void)
  82 {
  83         const char *format_string;
  84         const char *usage_string = usage_messages;
  85         int i;
  86
  87         for (i = applet_using - applets; i > 0; ) {
  88                 if (!*usage_string++) {
  89                         --i;
  90                 }
  91         }
  92         format_string = "%s\n\nUsage: %s %s\n\n";
  93         if(*usage_string == 0)
  94                 format_string = "%s\n\nNo help available.\n\n";
  95         fprintf(stderr, format_string,
  96                         full_version, applet_using->name, usage_string);
  97         exit(EXIT_FAILURE);
  98 }
  99
 100 static int applet_name_compare(const void *x, const void *y)
 101 {
 102         const char *name = x;
 103         const struct BB_applet *applet = y;
 104
 105         return strcmp(name, applet->name);
 106 }
 107
 108 extern const size_t NUM_APPLETS;
 109
 110 struct BB_applet *find_applet_by_name(const char *name)
 111 {
 112         return bsearch(name, applets, NUM_APPLETS, sizeof(struct BB_applet),
 113                         applet_name_compare);
 114 }
 115
 116 void run_applet_by_name(const char *name, int argc, char **argv)
 117 {
 118         static int recurse_level = 0;
 119         extern int been_there_done_that; /* From busybox.c */
 120
 121 #ifdef CONFIG_FEATURE_SUID_CONFIG
 122         if ( recurse_level == 0 )
 123                 config_ok = parse_config_file ( );
 124 #endif
 125
 126         recurse_level++;
 127         /* Do a binary search to find the applet entry given the name. */
 128         if ((applet_using = find_applet_by_name(name)) != NULL) {
 129                 applet_name = applet_using->name;
 130                 if (argv[1] && strcmp(argv[1], "--help") == 0) {
 131                         if (strcmp(applet_using->name, "busybox")==0) {
 132                                 if(argv[2])
 133                                   applet_using = find_applet_by_name(argv[2]);
 134                                  else
 135                                   applet_using = NULL;
 136                         }
 137                         if(applet_using)
 138                                 show_usage();
 139                         been_there_done_that=1;
 140                         busybox_main(0, NULL);
 141                 }
 142 #ifdef CONFIG_FEATURE_SUID
 143                 check_suid ( applet_using );
 144 #endif
 145
 146                 exit((*(applet_using->main)) (argc, argv));
 147         }
 148         /* Just in case they have renamed busybox - Check argv[1] */
 149         if (recurse_level == 1) {
 150                 run_applet_by_name("busybox", argc, argv);
 151         }
 152         recurse_level--;
 153 }
 154
 155
 156 #ifdef CONFIG_FEATURE_SUID
 157
 158 #ifdef CONFIG_FEATURE_SUID_CONFIG
 159
 160 /* check if u is member of group g */
 161 static int ingroup ( uid_t u, gid_t g )
 162 {
 163         struct group *grp = getgrgid ( g );
 164
 165         if ( grp ) {
 166                 char **mem;
 167
 168                 for ( mem = grp-> gr_mem; *mem; mem++ ) {
 169                         struct passwd *pwd = getpwnam ( *mem );
 170
 171                         if ( pwd && ( pwd-> pw_uid == u ))
 172                                 return 1;
 173                 }
 174         }
 175         return 0;
 176 }
 177
 178 #endif
 179
 180
 181 void check_suid ( struct BB_applet *applet )
 182 {
 183         uid_t ruid = getuid ( ); /* real [ug]id */
 184         uid_t rgid = getgid ( );
 185
 186 #ifdef CONFIG_FEATURE_SUID_CONFIG
 187         if ( config_ok ) {
 188                 struct BB_suid_config *sct;
 189
 190                 for ( sct = suid_config; sct; sct = sct-> m_next ) {
 191                         if ( sct-> m_applet == applet )
 192                                 break;
 193                 }
 194                 if ( sct ) {
 195                         mode_t m = sct-> m_mode;
 196
 197                         if ( sct-> m_uid == ruid ) /* same uid */
 198                                 m >>= 6;
 199                         else if (( sct-> m_gid == rgid ) || ingroup ( ruid, sct-> m_gid )) /* same group / in group */
 200                                 m >>= 3;
 201
 202                         if (!( m & S_IXOTH ))   /* is x bit not set ? */
 203                                 error_msg_and_die ( "You have no permission to run this applet!" );
 204
 205                         if (( sct-> m_mode & ( S_ISGID | S_IXGRP )) == ( S_ISGID | S_IXGRP )) { /* *both* have to be set for sgid */
 206                                 if ( setegid ( sct-> m_gid ))
 207                                         error_msg_and_die ( "BusyBox binary has insufficient rights to set proper GID for applet!" );
 208                         }
 209                         else
 210                                 setgid ( rgid ); /* no sgid -> drop */
 211
 212                         if ( sct-> m_mode & S_ISUID ) {
 213                                 if ( seteuid ( sct-> m_uid ))
 214                                         error_msg_and_die ( "BusyBox binary has insufficient rights to set proper UID for applet!" );
 215                         }
 216                         else
 217                                 setuid ( ruid ); /* no suid -> drop */
 218                 }
 219                 else { /* default: drop all priviledges */
 220                         setgid ( rgid );
 221                         setuid ( ruid );
 222                 }
 223                 return;
 224         }
 225         else {
 226 #ifndef CONFIG_FEATURE_SUID_CONFIG_QUIET
 227                 static int onetime = 0;
 228
 229                 if ( !onetime ) {
 230                         onetime = 1;
 231                         fprintf ( stderr, "Using fallback suid method\n" );
 232                 }
 233 #endif
 234         }
 235 #endif
 236
 237         if ( applet-> need_suid == _BB_SUID_ALWAYS ) {
 238                 if ( geteuid ( ) != 0 )
 239                         error_msg_and_die ( "This applet requires root priviledges!" );
 240         }
 241         else if ( applet-> need_suid == _BB_SUID_NEVER ) {
 242                 setgid ( rgid ); /* drop all priviledges */
 243                 setuid ( ruid );
 244         }
 245 }
 246
 247 #ifdef CONFIG_FEATURE_SUID_CONFIG
 248
 249
 250 #define parse_error(x)  { err=x; goto pe_label; }
 251
 252
 253 int parse_config_file ( void )
 254 {
 255         struct stat st;
 256         char *err = 0;
 257         FILE *f = 0;
 258         int lc = 0;
 259
 260         suid_config = 0;
 261
 262         /* is there a config file ? */
 263         if ( stat ( CONFIG_FILE, &st ) == 0 ) {
 264                 /* is it owned by root with no write perm. for group and others ? */
 265                 if ( S_ISREG( st. st_mode ) && ( st. st_uid == 0 )      && (!( st. st_mode & ( S_IWGRP | S_IWOTH )))) {
 266                         /* that's ok .. then try to open it */
 267                         f = fopen ( CONFIG_FILE, "r" );
 268
 269                         if ( f ) {
 270                                 char buffer [256];
 271                                 int section = 0;
 272
 273                                 while ( fgets ( buffer, sizeof( buffer ) - 1, f )) {
 274                                         char c = buffer [0];
 275                                         char *p;
 276
 277                                         lc++;
 278
 279                                         p = strchr ( buffer, '#' );
 280                                         if ( p )
 281                                                 *p = 0;
 282                                         p = buffer + xstrlen ( buffer );
 283                                         while (( p > buffer ) && isspace ( *--p ))
 284                                                 *p = 0;
 285
 286                                         if ( p == buffer )
 287                                                 continue;
 288
 289                                         if ( c == '[' ) {
 290                                                 p = strchr ( buffer, ']' );
 291
 292                                                 if ( !p || ( p == ( buffer + 1 )))  /* no matching ] or empty [] */
 293                                                         parse_error ( "malformed section header" );
 294
 295                                                 *p = 0;
 296
 297                                                 if ( strcasecmp ( buffer + 1, "SUID" ) == 0 )
 298                                                         section = 1;
 299                                                 else
 300                                                         section = -1; /* unknown section - just skip */
 301                                         }
 302                                         else if ( section ) {
 303                                                 switch ( section ) {
 304                                                         case 1: { /* SUID */
 305                                                                 int l;
 306                                                                 struct BB_applet *applet;
 307
 308                                                                 p = strchr ( buffer, '=' ); /* <key>[::space::]*=[::space::]*<value> */
 309
 310                                                                 if ( !p || ( p == ( buffer + 1 ))) /* no = or key is empty */
 311                                                                         parse_error ( "malformed keyword" );
 312
 313                                                                 l = p - buffer;
 314                                                                 while ( isspace ( buffer [--l] )) { } /* skip whitespace */
 315
 316                                                                 buffer [l+1] = 0;
 317
 318                                                                 if (( applet = find_applet_by_name ( buffer ))) {
 319                                                                         struct BB_suid_config *sct = xmalloc ( sizeof( struct BB_suid_config ));
 320
 321                                                                         sct-> m_applet = applet;
 322                                                                         sct-> m_next = suid_config;
 323                                                                         suid_config = sct;
 324
 325                                                                         while ( isspace ( *++p )) { } /* skip whitespace */
 326
 327                                                                         sct-> m_mode = 0;
 328
 329                                                                         switch ( *p++ ) {
 330                                                                                 case 'S': sct-> m_mode |= S_ISUID; break;
 331                                                                                 case 's': sct-> m_mode |= S_ISUID; /* no break */
 332                                                                                 case 'x': sct-> m_mode |= S_IXUSR; break;
 333                                                                                 case '-': break;
 334                                                                                 default : parse_error ( "invalid user mode" );
 335                                                                         }
 336
 337                                                                         switch ( *p++ ) {
 338                                                                                 case 's': sct-> m_mode |= S_ISGID; /* no break */
 339                                                                                 case 'x': sct-> m_mode |= S_IXGRP; break;
 340                                                                                 case 'S': break;
 341                                                                                 case '-': break;
 342                                                                                 default : parse_error ( "invalid group mode" );
 343                                                                         }
 344
 345                                                                         switch ( *p ) {
 346                                                                                 case 't':
 347                                                                                 case 'x': sct-> m_mode |= S_IXOTH; break;
 348                                                                                 case 'T':
 349                                                                                 case '-': break;
 350                                                                                 default : parse_error ( "invalid other mode" );
 351                                                                         }
 352
 353                                                                         while ( isspace ( *++p )) { } /* skip whitespace */
 354
 355                                                                         if ( isdigit ( *p )) {
 356                                                                                 sct-> m_uid = strtol ( p, &p, 10 );
 357                                                                                 if ( *p++ != '.' )
 358                                                                                         parse_error ( "parsing <uid>.<gid>" );
 359                                                                         }
 360                                                                         else {
 361                                                                                 struct passwd *pwd;
 362                                                                                 char *p2 = strchr ( p, '.' );
 363
 364                                                                                 if ( !p2 )
 365                                                                                         parse_error ( "parsing <uid>.<gid>" );
 366
 367                                                                                 *p2 = 0;
 368                                                                                 pwd = getpwnam ( p );
 369
 370                                                                                 if ( !pwd )
 371                                                                                         parse_error ( "invalid user name" );
 372
 373                                                                                 sct-> m_uid = pwd-> pw_uid;
 374                                                                                 p = p2 + 1;
 375                                                                         }
 376                                                                         if ( isdigit ( *p ))
 377                                                                                 sct-> m_gid = strtol ( p, &p, 10 );
 378                                                                         else {
 379                                                                                 struct group *grp = getgrnam ( p );
 380
 381                                                                                 if ( !grp )
 382                                                                                         parse_error ( "invalid group name" );
 383
 384                                                                                 sct-> m_gid = grp-> gr_gid;
 385                                                                         }
 386                                                                 }
 387                                                                 break;
 388                                                         }
 389                                                         default: /* unknown - skip */
 390                                                                 break;
 391                                                 }
 392                                         }
 393                                         else
 394                                                 parse_error ( "keyword not within section" );
 395                                 }
 396                                 fclose ( f );
 397                                 return 1;
 398                         }
 399                 }
 400         }
 401         return 0; /* no config file or not readable (not an error) */
 402
 403 pe_label:
 404         fprintf ( stderr, "Parse error in %s, line %d: %s\n", CONFIG_FILE, lc, err );
 405
 406         if ( f )
 407                 fclose ( f );
 408         return 0;
 409 }
 410
 411 #endif
 412
 413 #endif
 414
 415 /* END CODE */
 416 /*
 417 Local Variables:
 418 c-file-style: "linux"
 419 c-basic-offset: 4
 420 tab-width: 4
 421 End:
 422 */