sysadmin.c

   1 /*
   2  *
   3  *      CARNet System Admin Utility v1.26, 2003-12-05
   4  *
   5  *      v1.00, 24 Jun 1996, first release
   6  *      v1.10, 17 Oct 1996, directories with ownership of specific group can be created and
   7  *                          deleted, accounts 'srce' & 'admin' can be added (only)
   8  *      v1.15, 30 Oct 1996, admin program is now setuid!!! it gives off privileges
   9  *                          when not needed
  10  *      v1.20, 30 Nov 1996, name changed, logging incorporated, access list, tty checking
  11  *      v1.21, 17 Dec 1996, shutdown asks for message and grace period, fixed all
  12  *                          relative paths (security!), main menu slightly rearranged
  13  *      v1.22, 25 Feb 1997, Digital Unix 4.0 only: use user{add,del}(), fix checking for console
  14  *      v1.23, 10 Mar 1997, Again problems with OSF/DU and console checking
  15  *      v1.24, 12 Mar 1997, Rewritten code for console checking (I *hate* bloody Digital!!!)
  16  *      v1.25, 2002-04-28, Initial port to Debian GNU/Linux, limited functionality
  17  *  v1.26, 2003-12-05, quota for Linux.  Only new style quotactl() on i386.
  18  *  v1.27, 2009-05-20, x86_64 version
  19  *
  20  *      Written by Zlatko Calusic
  21  *      Linux port Zoran Dzelajlija
  22  *      Linux amd64 port Ivan Rako
  23  *
  24  *      SRCE, University Computing Centre, Croatia
  25  *      CARNet, Croatian Academic and Research Network
  26  *
  27  */
  28
  29 /* prototypes */
  30
  31 #include "sysadmin.h"
  32
  33 /* globals */
  34
  35 char loginname[MAXLOGIN], group[MAXGROUP], username[MAXNAME], string[MAXSTR];
  36 char directory[MAXDIR], command[MAXCOMMAND], message[MAXMESS];
  37 int saveduid, grace;
  38 FILE *logfile;
  39 int conscheck = 1;
  40
  41 char *authdir, *group_fallback_dir;
  42
  43
  44 /* body */
  45
  46 void logger(char *fmt, ...)
  47 {
  48     char *cptr, *whenptr;
  49     va_list arg;
  50     time_t when;
  51
  52     time(&when);
  53     whenptr = ctime(&when);
  54     if ((cptr = strchr(whenptr, '\n')))
  55         *cptr = 0;
  56     fprintf(logfile, "%s  ", whenptr);
  57     va_start(arg, fmt);
  58     while (*fmt)
  59     {
  60         while (*fmt && *fmt != '%')
  61             fputc(*fmt++, logfile);
  62         fmt++;
  63         switch(*fmt++)
  64         {
  65         case 's':
  66             fprintf(logfile, "%s", va_arg(arg, char *));
  67             break;
  68         case 'd':
  69             fprintf(logfile, "%d", va_arg(arg, int));
  70             break;
  71         default:
  72             goto donefmt;
  73         }
  74     }
  75 donefmt:
  76     va_end(arg);
  77     fputc('\n', logfile);
  78     fflush(logfile);
  79     return;
  80 }
  81
  82 void priv(int pvar)
  83 {
  84     int retval;
  85
  86     switch (pvar)
  87     {
  88     case ON:
  89         retval = seteuid(0);
  90         break;
  91     case OFF:
  92     default:
  93         retval = seteuid(saveduid);
  94     }
  95     if (retval < 0)
  96     {
  97         fputs("\nInterna greska, izlazak iz programa!\n", stderr);
  98         waitkey();
  99         exit(0);
 100     }
 101     return;
 102 }
 103
 104 int lockpw(void)
 105 {
 106 #if defined(ultrix)
 107     if (!system("/bin/sh /etc/lockpw"))
 108         return OK;
 109     else
 110         return ERROR;
 111 #elif defined(__osf__)
 112     if (!mkdir("/etc/ptmp", 0700))
 113         return OK;
 114     else
 115         return ERROR;
 116 #endif
 117     return OK;
 118 }
 119
 120 void unlockpw(void)
 121 {
 122 #if defined(ultrix)
 123     system("/bin/sh /etc/unlockpw");
 124 #elif defined(__osf__)
 125     rmdir("/etc/ptmp");
 126 #endif
 127     return;
 128 }
 129
 130 void consexit(void)
 131 {
 132     fputs("\nProgram se moze pokrenuti samo s konzole.\nIzlazak iz programa!\n", stderr);
 133     exit(1);
 134 }
 135
 136 int getch(void)
 137 {
 138     int ch = getchar();
 139
 140     if (ch != EOF && ch != '\n')
 141         getchar();
 142     return ch;
 143 }
 144
 145 void clear(void)
 146 {
 147 #if defined(__SVR4) || defined(__osf__) || defined(__linux__)
 148     system("/usr/bin/clear");
 149 #elif defined(ultrix)
 150     system("/usr/ucb/clear");
 151 #endif
 152     return;
 153 }
 154
 155 void waitkey(void)
 156 {
 157     printf("\nPritisnite <RETURN> za nastavak...");
 158     while (getch() != '\n');
 159     return;
 160 }
 161
 162 void enter(char *var, int size)
 163 {
 164     char *ptr;
 165
 166     fgets(var, size, stdin);
 167     if ((ptr = strchr(var, '\n')))
 168         *ptr = 0;
 169     putchar('\n');
 170     return;
 171 }
 172
 173 void getuser(char *text)
 174 {
 175     printf("%s\n\nUnesite korisnicko ime (login) > ", text);
 176     enter(loginname, MAXLOGIN);
 177     return;
 178 }
 179
 180 void getgroup(char *text)
 181 {
 182     if (*text)
 183         printf("%s\n\n", text);
 184     printf("Unesite ime grupe > ");
 185     enter(group, MAXGROUP);
 186     return;
 187 }
 188
 189 int getname(void)
 190 {
 191     int count = 0;
 192
 193     printf("Unesite ime i prezime korisnika > ");
 194     enter(username, MAXNAME);
 195     do
 196     {
 197         if (!isalnum(username[count]) && username[count] != ' ' && username[count] != '.' && username[count] != '-')
 198         {
 199             fputs("Unijeli ste nedozvoljene znakove u imenu korisnika!\n", stderr);
 200             return ERROR;
 201         }
 202         count++;
 203     }
 204     while (username[count]);
 205     return OK;
 206 }
 207
 208 int getdir(void)
 209 {
 210     int len;
 211     printf("Unesite puni put do direktorija > ");
 212     enter(directory, MAXDIR);
 213     if (strchr(directory, '.') || strstr(directory, "//"))
 214     {
 215         fputs("Unijeli ste nedozvoljene znakove!\n", stderr);
 216         return ERROR;
 217     }
 218     len = strlen(directory);
 219     if (strstr(directory, group_fallback_dir) != directory
 220             || !strcmp(directory, group_fallback_dir))
 221     {
 222         fprintf(stderr, "Direktorij mora biti podredjen %s direktoriju.\n",
 223                 group_fallback_dir);
 224         return ERROR;
 225     }
 226     if (directory[len] == '/')
 227         directory[len] = 0;
 228     return OK;
 229 }
 230
 231 int getquota(int *soft, int *hard)
 232 {
 233     printf("Unesite donji limit (soft) u KB > ");
 234     enter(string, MAXSTR);
 235     *soft = atoi(string);
 236     if (*soft < 0 || *soft > MAXQUOTA)
 237         goto error;
 238     if (!*soft)
 239     {
 240         *hard = 0;
 241         return OK;
 242     }
 243     printf("Unesite gornji limit (hard) u KB > ");
 244     enter(string, MAXSTR);
 245     *hard = atoi(string);
 246     if (*hard >= 0 && *hard <= MAXQUOTA)
 247         return OK;
 248 error:
 249     fputs("Unijeli ste nedozvoljenu vrijednost!\n", stderr);
 250     return ERROR;
 251 }
 252
 253 int testuser(int flag)
 254 {
 255 #if defined(__linux__)
 256     char *forbidden[] = { "root", "daemon", "bin", "sys", "sync", "games", "man",
 257                           "lp", "mail", "news", "uucp", "proxy", "majordom",
 258                           "postgres",/* "www-data",*/ "backup", "msql", "operator",
 259                           "list", "irc", "gnats", "nobody", "snort", "ntop",
 260                           "mysql", "telnetd", "gdm", "freerad", "" };
 261 #elif defined(__SVR4)
 262     char *forbidden[] = { "root", "daemon", "bin", "sys", "adm", "lp",
 263                           "smtp", "uucp", "nuucp", "listen", "nobody", "noaccess", "ftp",
 264                           "gopher", "http", "" };
 265 #elif defined(__osf__)
 266     char *forbidden[] = { "root", "nobody", "nobodyV", "daemon", "bin",
 267                           "uucp", "uucpa", "auth", "cron", "lp", "tcb", "adm", "ris", "ftp",
 268                           "gopher", "http", "" };
 269 #elif defined(ultrix)
 270     char *forbidden[] = { "root", "field", "nobody", "operator", "ris",
 271                           "daemon", "sys", "bin", "uucp", "uucpa", "sso", "news", "sccs",
 272                           "ingres", "ftp", "gopher", "http", "" };
 273 #endif
 274     int count = 0;
 275
 276     if (!*loginname)
 277         return ERROR;
 278     if ((int) strlen(loginname) > 8)
 279     {
 280         fputs("Maksimalna duzina korisnickog imena je 8 znakova!\n", stderr);
 281         return ERROR;
 282     }
 283     do
 284     {
 285         if (!islower(loginname[count]) && !isdigit(loginname[count]))
 286         {
 287             fputs("Unijeli ste nedozvoljene znakove u korisnickom imenu!\n", stderr);
 288             return ERROR;
 289         }
 290         count++;
 291     }
 292     while (loginname[count]);
 293     count = 0;
 294     if (flag == ALL && (!strcmp(loginname, "srce") || !strcmp(loginname, "admin")))
 295         goto fuckoff;
 296     if (authdir)
 297     {
 298         struct passwd *pwd;
 299         pwd = getpwnam(loginname);
 300         if (pwd && pwd->pw_dir)
 301             if (strstr(pwd->pw_dir, authdir) != pwd->pw_dir)
 302                 goto fuckoff;
 303     }
 304     while (*forbidden[count])
 305     {
 306         if (!strcmp(forbidden[count], loginname))
 307         {
 308 fuckoff:
 309             fputs("Nemate ovlasti za unesenog korisnika!\n", stderr);
 310             return ERROR;
 311         }
 312         count++;
 313     }
 314     return OK;
 315 }
 316
 317 int testgroup(void)
 318 {
 319 #if defined(__linux__)
 320     char *forbidden[] = {"root", "daemon", "bin", "sys", "adm", "tty",
 321                          "disk", "lp", "mail", "news", "uucp", "proxy",
 322                          "kmem", "dialout", "fax", "voice", "cdrom", "tape",
 323                          "sudo", "audio", "dip", "majordom", "postgres",
 324                          "backup", "msql", "operator", "list", "irc",
 325                          "gnats", "shadow", "utmp", "video", "games",
 326                          "nogroup", "snort", "mysql", "telnetd", "gdm",
 327                          "freerad", "viruser", "" };
 328 #elif defined(__SVR4)
 329     char *forbidden[] = { "root", "other", "bin", "sys", "adm", "uucp",
 330                           "mail", "tty", "lp", "nuucp", "staff", "daemon", "sysadmin",
 331                           "nobody", "noaccess", "wheel", "viruser", "" };
 332 #elif defined(__osf__)
 333     char *forbidden[] = { "system", "daemon", "uucp", "mem", "kmem", "bin",
 334                           "sec", "mail", "terminal", "tty", "news", "opr", "auth", "lp", "lpr",
 335                           "backup", "cron", "sysadmin", "tape", "tcb", "adm", "operator",
 336                           "ris", "nobody", "nogroup", "wheel", "" };
 337 #elif defined(ultrix)
 338     char *forbidden[] = { "system", "daemon", "uucp", "rsrv3", "bin", "tty",
 339                           "kmem", "authread", "news", "rsrv9", "staff", "ris", "guest",
 340                           "operator", "admin", "nobody", "wheel", "" };
 341 #endif
 342     int count = 0;
 343
 344     if (!*group)
 345         return ERROR;
 346     if ((int) strlen(group) > 8)
 347     {
 348         fputs("Maksimalna duzina imena grupe je 8 znakova!\n", stderr);
 349         return ERROR;
 350     }
 351     do
 352     {
 353         if (!islower(group[count]))
 354         {
 355             fputs("Unijeli ste nedozvoljene znakove u imenu grupe!\n", stderr);
 356             return ERROR;
 357         }
 358         count++;
 359     }
 360     while (group[count]);
 361     count = 0;
 362     while (*forbidden[count])
 363     {
 364         if (!strcmp(forbidden[count], group))
 365         {
 366             fputs("Nemate ovlasti za unesenu grupu!\n", stderr);
 367             return ERROR;
 368         }
 369         count++;
 370     }
 371     if (authdir)
 372     {
 373         struct group *grp = getgrnam(group);
 374         if (grp && grp->gr_mem)
 375         {
 376             struct passwd *pwd;
 377             for (; *grp->gr_mem; grp->gr_mem++)
 378             {
 379                 pwd = getpwnam(*grp->gr_mem);
 380                 if (pwd && pwd->pw_dir)
 381                 {
 382                     if (strstr(pwd->pw_dir, authdir) != pwd->pw_dir)
 383                     {
 384                         fputs("Nemate ovlasti za unesenu grupu!\n", stderr);
 385                         return ERROR;
 386                     }
 387                     else
 388                         break;
 389                 }
 390             }
 391         }
 392     }
 393     return OK;
 394 }
 395
 396 int system_default_shell_check(void)
 397 {
 398 #ifndef __linux__
 399     return 0;
 400 #endif
 401
 402     struct stat statp;
 403     statp.st_mode = 0;
 404
 405     (void) stat("/etc/default/useradd", &statp);
 406     /* regular file? */
 407     if (! statp.st_mode) return 0;
 408     if (S_ISREG(statp.st_mode))
 409     {
 410         /* XXX maybe check file contents */
 411         return 1;
 412     }
 413     else
 414     {
 415         return 0;
 416     }
 417 }
 418
 419 void adduser(void)
 420 {
 421     char fullhm[200];
 422     char *shellopt="";
 423     int l;
 424     getuser("Dodavanje korisnika:");
 425     if (testuser(NOTALL) == OK && getname() == OK)
 426     {
 427         strncpy(fullhm, authdir ? authdir : HM, 199);
 428         l = strlen(fullhm);
 429         if (fullhm[l - 1] != '/')
 430         {
 431             fullhm[l] = '/';
 432             fullhm[l + 1] = '\0';
 433         }
 434         strncat(fullhm, loginname, 199);
 435         logger("USER ADD: user %s, fullname %s", loginname, username);
 436 #if defined(__SVR4) || defined (__linux__)
 437         if (!system_default_shell_check())
 438         {
 439             shellopt = "-s " DEFAULTSHELL;
 440         }
 441         sprintf(command, "/usr/sbin/useradd -m -d %s %s" \
 442                 " -c \"%s\" %s", fullhm, shellopt, username, loginname);
 443         printf("%s\n", command);
 444         priv(ON);
 445         if (!system(command))
 446         {
 447             priv(OFF);
 448 #if defined (__linux__)
 449             /* Avoid race */
 450             sync();
 451 #endif /* __linux__ */
 452             sprintf(command, "/usr/bin/passwd %s", loginname);
 453             priv(ON);
 454             system(command);
 455         }
 456 #elif defined(__osf__)
 457 #if defined(DU4)
 458         sprintf(command, "/usr/sbin/useradd -m -s " DEFAULTSHELL \
 459                 " -c \"%s\" %s", username, loginname);
 460         priv(ON);
 461         if (!system(command))
 462         {
 463             struct pr_passwd *pr;
 464
 465             if (!(pr = getprpwnam(loginname)))
 466             {
 467                 perror("getprpwnam");
 468                 goto problems;
 469             }
 470             pr->uflg.fg_lock = 1;
 471             pr->uflg.fg_min = 1;
 472             pr->ufld.fd_min = 0;
 473             pr->uflg.fg_expire = 1;
 474             pr->ufld.fd_expire = 0;
 475             pr->uflg.fg_lifetime = 1;
 476             pr->ufld.fd_lifetime = 0;
 477             pr->uflg.fg_max_tries = 1;
 478             pr->ufld.fd_max_tries = 0;
 479             if (!putprpwnam(loginname, pr))
 480             {
 481                 perror("putprpwnam");
 482                 goto problems;
 483             }
 484             sprintf(command, "/usr/bin/passwd %s", loginname);
 485             system(command);
 486         }
 487 #else
 488         sprintf(command, "/usr/sbin/sysadm.adduser %s \"%s\"", loginname, username);
 489         priv(ON);
 490         system(command);
 491 #endif /* DU4 */
 492 #elif defined(ultrix)
 493         sprintf(command, "/usr/etc/sysadm.adduser %s \"%s\"", loginname, username);
 494         priv(ON);
 495         system(command);
 496 #endif
 497 #if defined(DU4)
 498 problems:
 499 #endif
 500         priv(OFF);
 501     }
 502     waitkey();
 503     return;
 504 }
 505
 506 void rmuser(void)
 507 {
 508     getuser("Brisanje korisnika:");
 509     if (testuser(ALL) == OK)
 510     {
 511         logger("USER REMOVE: user %s", loginname);
 512 #if defined(__SVR4) || defined(__linux__)
 513         sprintf(command, "/usr/sbin/userdel -r %s", loginname);
 514 #elif defined(__osf__)
 515 #if defined(DU4)
 516         sprintf(command, "/usr/sbin/userdel -r %s", loginname);
 517 #else
 518         sprintf(command, "/usr/sbin/sysadm.removeuser %s", loginname);
 519 #endif
 520 #elif defined(ultrix)
 521         sprintf(command, "/usr/etc/sysadm.removeuser %s", loginname);
 522 #endif
 523         priv(ON);
 524         system(command);
 525         priv(OFF);
 526     }
 527     waitkey();
 528     return;
 529 }
 530
 531 void chpass(void)
 532 {
 533     getuser("Promjena korisnicke lozinke:");
 534     if (testuser(NOTALL) == OK)
 535     {
 536         logger("PASSWD CHANGE: user %s", loginname);
 537         sprintf(command, "/usr/bin/passwd %s", loginname);
 538         priv(ON);
 539         system(command);
 540         priv(OFF);
 541     }
 542     waitkey();
 543     return;
 544 }
 545
 546 void chquota(void)
 547 {
 548     int soft, hard;
 549     struct passwd *pwd;
 550 #if defined(__SVR4)
 551     struct dqblk qval;
 552     struct quotctl qstr;
 553     struct stat statbuf;
 554 #elif defined(ultrix)
 555     struct dqblk qval;
 556     struct stat statbuf;
 557 #elif defined(__linux__)
 558 #if defined(__i386__) || defined(__x86_64__)
 559     struct if_dqblk qval; /* sys/quota.h is wrong for 2.4.23/i386 */
 560 #elif defined(__sparc__)
 561     struct dqblk qval;    /* 2.4.23/sparc is different */
 562 #endif
 563     struct stat statbuf;
 564     struct mntent *mntp;
 565     FILE *fp;
 566     int dev;
 567     char devname[MAXDIR], mountpoint[MAXDIR], greska[MAXDIR];
 568     time_t now;
 569     devname[0] = '\0';
 570 #endif
 571
 572     getuser("Promjena korisnicke quote:");
 573     if (testuser(ALL) != OK)
 574     {
 575         priv(OFF);
 576         waitkey();
 577         return;
 578     }
 579
 580     if (!(pwd = getpwnam(loginname)))
 581     {
 582         fputs("Ne postoji uneseni korisnik!\n", stderr);
 583         waitkey();
 584         return;
 585     }
 586
 587 #if defined(__linux__)
 588     priv(ON);
 589     if (stat(pwd->pw_dir, &statbuf) < 0)
 590     {
 591         priv(OFF);
 592         fputs("Korisnik nema maticni direktorij!\n", stderr);
 593         waitkey();
 594         return;
 595     }
 596     else
 597     {
 598         priv(OFF);
 599         dev = statbuf.st_dev;
 600     }
 601
 602     priv(ON);
 603     if (!(fp = setmntent("/etc/mtab", "r")))
 604     {
 605         priv(OFF);
 606         perror("setmntent");
 607         waitkey();
 608         return;
 609     }
 610     while (feof(fp) == 0)
 611     {
 612         mntp = getmntent(fp);
 613         if (!mntp) break;
 614         /* ignore special fs' like proc, devfs... */
 615         if (strncmp(mntp->mnt_fsname, "/dev", 4))
 616             continue;
 617         if (stat(mntp->mnt_fsname, &statbuf) < 0)
 618         {
 619             priv(OFF);
 620             perror("stat");
 621             endmntent(fp);
 622             waitkey();
 623             return;
 624         }
 625         if (statbuf.st_rdev == dev)
 626         {
 627             strncpy(devname, mntp->mnt_fsname, MAXDIR);
 628             strncpy(mountpoint, mntp->mnt_dir, MAXDIR);
 629             break;
 630         }
 631     }
 632     endmntent(fp);
 633     priv(OFF);
 634
 635     if(! strlen(devname))
 636     {
 637         fputs("Nije pronadjen device na kojem je korisnikov direktorij!\n", stderr);
 638         waitkey();
 639         return;
 640     }
 641
 642 #ifdef __i386__
 643     /* get previous quota values and update times */
 644     priv(ON);
 645     if (!quotactl(QCMD(Q_GETQUOTA, USRQUOTA), devname, pwd->pw_uid, (caddr_t) &qval))
 646     {
 647         priv(OFF);
 648         time(&now);
 649         if (qval.dqb_bsoftlimit && (
 650 #if defined(__i386__) || defined(__x86_64__)
 651                     qval.dqb_curspace
 652 #elif defined(__sparc__)
 653                     qval.dqb_curblocks
 654 #endif
 655                     /1024) >= qval.dqb_bsoftlimit)
 656         {
 657             if (!qval.dqb_btime)
 658                 qval.dqb_btime = now + MAX_DQ_TIME;
 659         }
 660         else
 661             qval.dqb_btime = 0;
 662         if (qval.dqb_isoftlimit && qval.dqb_curinodes >= qval.dqb_isoftlimit)
 663         {
 664             if (!qval.dqb_itime)
 665                 qval.dqb_itime = now + MAX_DQ_TIME;
 666         }
 667         else
 668             qval.dqb_itime = 0;
 669     }
 670     else
 671     {
 672         priv(OFF);
 673         fputs("Ne mogu utvrditi trenutne vrijednosti quote!\n", stderr);
 674         waitkey();
 675         return;
 676     }
 677 #endif
 678
 679 #ifdef __x86_64__
 680     /* get previous quota values and update times */
 681     priv(ON);
 682     if (!quotactl(QCMD(Q_GETQUOTA, USRQUOTA), devname, pwd->pw_uid, (caddr_t) &qval))
 683     {
 684         priv(OFF);
 685         time(&now);
 686         if (qval.dqb_bsoftlimit && (
 687 #if defined(__i386__) || defined(__x86_64__)
 688                     qval.dqb_curspace
 689 #elif defined(__sparc__)
 690                     qval.dqb_curblocks
 691 #endif
 692                     /1024) >= qval.dqb_bsoftlimit)
 693         {
 694             if (!qval.dqb_btime)
 695                 qval.dqb_btime = now + MAX_DQ_TIME;
 696         }
 697         else
 698             qval.dqb_btime = 0;
 699         if (qval.dqb_isoftlimit && qval.dqb_curinodes >= qval.dqb_isoftlimit)
 700         {
 701             if (!qval.dqb_itime)
 702                 qval.dqb_itime = now + MAX_DQ_TIME;
 703         }
 704         else
 705             qval.dqb_itime = 0;
 706     }
 707     else
 708     {
 709         priv(OFF);
 710         fputs("Ne mogu utvrditi trenutne vrijednosti quote!\n", stderr);
 711         waitkey();
 712         return;
 713     }
 714 #endif
 715 #endif
 716
 717     if (getquota(&soft, &hard) == OK)
 718     {
 719         logger("QUOTA CHANGE: user %s, soft %d, hard %d", loginname, soft, hard);
 720 #ifdef __SVR4
 721         int i, count, fd;
 722 #endif
 723         if (!soft)
 724             fputs("Korisnik ce imati neogranicen pristup diskovnom prostoru!\n", stderr);
 725 #if defined(__linux__)
 726 #if defined(__i386__) || defined(__x86_64__)
 727         /* Actually most of these are u_int64_t. */
 728         qval.dqb_bsoftlimit = (u_int32_t) soft;
 729         qval.dqb_bhardlimit = (u_int32_t) hard;
 730         qval.dqb_isoftlimit = qval.dqb_ihardlimit = (u_int32_t) 0;
 731         qval.dqb_btime = (time_t) now + MAX_DQ_TIME;
 732         qval.dqb_itime = (time_t) now + MAX_IQ_TIME;
 733 #if defined(__i386__) || defined(__x86_64__)
 734         /* Set limits and times */
 735         qval.dqb_valid = QIF_LIMITS | QIF_TIMES;
 736 #endif
 737         priv(ON);
 738         if (!
 739 #if defined(__i386__) || defined(__x86_64__)
 740                 quotactl(QCMD(Q_SETQUOTA, USRQUOTA), devname, pwd->pw_uid, (caddr_t) &qval)
 741 #elif defined (__sparc__)
 742                 quotactl(QCMD(Q_SETQLIM, USRQUOTA), devname, pwd->pw_uid, (caddr_t) &qval)
 743 #endif
 744            )
 745 #elif defined (__sparc__)
 746         sprintf(command, "/usr/sbin/setquota %s -T %d %d %s", \
 747                 loginname, MAX_DQ_TIME, MAX_IQ_TIME, mountpoint);
 748         printf("%s\n", command);
 749         priv(ON);
 750         if (!system(command))
 751         {
 752             priv(OFF);
 753             /* fputs("Vremensko ogranicenje quote postavljeno.\n", stderr); */
 754         }
 755         else
 756         {
 757             priv(OFF);
 758             fputs("Nije uspjelo postavljanje vremenskog ogranicenja quote!\n", stderr);
 759             waitkey();
 760             return;
 761         }
 762         sprintf(command, "/usr/sbin/setquota %s %d %d %d %d %s", \
 763                 loginname, soft, hard, 0, 0, mountpoint);
 764         printf("%s\n", command);
 765         priv(ON);
 766         if (!system(command))
 767 #endif /* __sparc__ */
 768         {
 769             priv(OFF);
 770             fputs("Quota uspjesno promijenjena.\n", stderr);
 771         }
 772         else
 773         {
 774             priv(OFF);
 775             if (errno == 3)
 776             {
 777                 sprintf(greska, "Quota nije ukljucena na filesystemu %s!\n", devname);
 778                 fputs(greska, stderr);
 779             }
 780             else
 781             {
 782                 perror("quotactl");
 783             }
 784         }
 785 #elif defined(__SVR4)
 786         qstr.uid = pwd->pw_uid;
 787         for (count = 1; ; count++)
 788         {
 789             char *ptr;
 790
 791             strcpy(string, pwd->pw_dir);
 792             for (i = 0; i < count; i++)
 793             {
 794                 ptr = strrchr(string, '/');
 795                 if (ptr)
 796                     *ptr = 0;
 797                 else
 798                     goto noquota;
 799             }
 800             strcat(string, "/quotas");
 801             priv(ON);
 802             if (!stat(string, &statbuf) && (fd = open(string, O_RDWR)) > 0)
 803                 goto success;
 804             priv(OFF);
 805         }
 806 noquota:
 807         fputs("Nema quote na ovom sistemu!\n", stderr);
 808         waitkey();
 809         return;
 810 success:
 811         priv(OFF);
 812         qval.dqb_bsoftlimit = (u_long) soft << 1;
 813         qval.dqb_bhardlimit = (u_long) hard << 1;
 814         qval.dqb_fsoftlimit = qval.dqb_fhardlimit = (u_long) 0;
 815         qval.dqb_btimelimit = (u_long) DQ_BTIMELIMIT;
 816         qval.dqb_ftimelimit = (u_long) DQ_FTIMELIMIT;
 817         qstr.addr = (caddr_t) &qval;
 818         qstr.op = Q_SETQLIM;
 819         priv(ON);
 820         if (!ioctl(fd, Q_QUOTACTL, &qstr))
 821             fputs("Quota uspjesno promijenjena.\n", stderr);
 822         else
 823             perror("quotactl");
 824 #elif defined(__osf__)
 825         qval.dqb_bsoftlimit = (u_long) soft << 1;
 826         qval.dqb_bhardlimit = (u_long) hard << 1;
 827         qval.dqb_isoftlimit = qval.dqb_ihardlimit = (u_int) 0;
 828         qval.dqb_btime = (time_t) MAX_DQ_TIME;
 829         qval.dqb_itime = (time_t) MAX_IQ_TIME;
 830         priv(ON);
 831         if (!quotactl(pwd->pw_dir, QCMD(Q_SETQUOTA, USRQUOTA), pwd->pw_uid, (char *) &qval))
 832             fputs("Quota uspjesno promijenjena.\n", stderr);
 833         else
 834             perror("quotactl");
 835 #elif defined(ultrix)
 836         priv(ON);
 837         if (stat(pwd->pw_dir, &statbuf) < 0)
 838         {
 839             priv(OFF);
 840             fputs("Korisnik nema maticni direktorij!\n", stderr);
 841             waitkey();
 842             return;
 843         }
 844         priv(OFF);
 845         qval.dqb_bsoftlimit = (u_long) soft << 1;
 846         qval.dqb_bhardlimit = (u_long) hard << 1;
 847         qval.dqb_isoftlimit = qval.dqb_ihardlimit = (u_short) 0;
 848         qval.dqb_bwarn = (u_char) MAX_DQ_WARN;
 849         qval.dqb_iwarn = (u_char) MAX_IQ_WARN;
 850         qval.dqb_curblocks = (u_long) 0;
 851         qval.dqb_curinodes = (u_short) 0;
 852         priv(ON);
 853         if (!quota(Q_SETDLIM, pwd->pw_uid, statbuf.st_dev, (caddr_t) &qval))
 854             fputs("Quota uspjesno promijenjena.\n", stderr);
 855         else
 856             perror("quota");
 857 #endif
 858     }
 859     priv(OFF);
 860     waitkey();
 861     return;
 862 }
 863
 864 void opgroup(void)
 865 {
 866     char ch;
 867     int oldumask;
 868
 869     for (;;)
 870     {
 871         priv(OFF);
 872         banner();
 873         puts("Operacije nad grupama korisnika:\n");
 874         puts("1 -- Kreiranje nove grupe");
 875         puts("2 -- Dodavanje korisnika u grupu");
 876         puts("3 -- Brisanje korisnika iz grupe");
 877         puts("4 -- Brisanje grupe");
 878         puts("5 -- Kreiranje direktorija (u koji grupa moze pisati)");
 879         puts("6 -- Brisanje direktorija\n");
 880         puts("7 -- Povratak u osnovni izbornik\n");
 881         printf("Unesite odabir > ");
 882         ch = getch();
 883         clear();
 884         switch(ch)
 885         {
 886         case '1':
 887             getgroup("Kreiranje nove grupe:");
 888             if (testgroup() == OK)
 889             {
 890                 logger("GROUP CREATE: group %s", group);
 891 #if defined(__SVR4) || defined(__linux__)
 892                 sprintf(command, "/usr/sbin/groupadd %s", group);
 893 #elif defined(__osf__)
 894                 sprintf(command, "/usr/sbin/sysadm.addgroup %s", group);
 895 #elif defined(ultrix)
 896                 sprintf(command, "/usr/etc/sysadm.addgroup %s", group);
 897 #endif
 898                 priv(ON);
 899                 system(command);
 900                 priv(OFF);
 901             }
 902             waitkey();
 903             break;
 904         case '2':
 905             getuser("Dodavanje korisnika u grupu:");
 906             if (testuser(ALL) == OK)
 907             {
 908                 if (getpwnam(loginname))
 909                 {
 910                     getgroup("");
 911                     if (testgroup() == OK)
 912                     {
 913                         FILE *readfp, *writefp;
 914                         char line[2048];
 915                         int found = 0;
 916                         struct stat fl;
 917
 918                         logger("ADD USER TO GROUP: user %s, group %s", loginname, group);
 919                         priv(ON);
 920                         if (lockpw() == ERROR)
 921                         {
 922                             priv(OFF);
 923 #ifdef __osf__
 924                             fputs("Probajte malo kasnije, /etc/group je u upotrebi!\n", stderr);
 925 #endif
 926                             goto getout;
 927                         }
 928                         if (!(readfp = fopen(GROUPFILE, "rt")))
 929                         {
 930                             priv(OFF);
 931                             fputs("Ne mogu otvoriti /etc/group datoteku!\n", stderr);
 932                             goto getout;
 933                         }
 934                         if (stat(GROUPFILE, &fl) == -1)
 935                         {
 936                             priv(OFF);
 937                             fputs("Ne mogu pogledati dozvole na /etc/group datoteci!\n", stderr);
 938                             goto getout;
 939                         }
 940                         unlink(GROUPTMPFILE);
 941                         if (!(writefp = fopen(GROUPTMPFILE, "wt")))
 942                         {
 943                             fclose(readfp);
 944                             priv(OFF);
 945                             fputs("Ne mogu otvoriti privremenu datoteku!\n", stderr);
 946                             goto getout;
 947                         }
 948                         while (fgets(line, 2048, readfp))
 949                         {
 950                             if (strstr(line, group) == line && line[strlen(group)] == ':')
 951                             {
 952                                 char *ptr, left, right;
 953
 954                                 if ((ptr = strstr(line + strlen(group) + 1, loginname)))
 955                                 {
 956                                     left = *(ptr - 1);
 957                                     right = *(ptr + strlen(loginname));
 958                                     if ((left == ':' || left == ',') &&
 959                                             (right == ',' || right == '\n'))
 960                                     {
 961                                         fclose(readfp);
 962                                         fclose(writefp);
 963                                         unlink(GROUPTMPFILE);
 964                                         priv(OFF);
 965                                         fputs("Korisnik je vec u unesenoj grupi!\n", stderr);
 966                                         goto getout;
 967                                     }
 968                                 }
 969                                 if ((ptr = strrchr(line, '\n')))
 970                                     *ptr = 0;
 971                                 else
 972                                 {
 973                                     fclose(readfp);
 974                                     fclose(writefp);
 975                                     unlink(GROUPTMPFILE);
 976                                     priv(OFF);
 977                                     fputs("Problem s datotekom /etc/group!\n", stderr);
 978                                     goto getout;
 979                                 }
 980                                 if (*(ptr - 1) != ':')
 981                                     strcat(line, ",");
 982                                 strcat(line, loginname);
 983                                 strcat(line, "\n");
 984                                 found = 1;
 985                             }
 986                             fputs(line, writefp);
 987                             if (ferror(writefp))
 988                             {
 989                                 fclose(readfp);
 990                                 fclose(writefp);
 991                                 unlink(GROUPTMPFILE);
 992                                 priv(OFF);
 993                                 fputs("Problem prilikom pisanja privremene datoteke!\n", stderr);
 994                                 goto getout;
 995                             }
 996                         }
 997                         fclose(readfp);
 998                         fclose(writefp);
 999                         if (found)
1000                         {
1001                             system("/bin/mv /tmp/group /etc/group");
1002                             chmod(GROUPFILE, fl.st_mode);
1003                             chown(GROUPFILE, fl.st_uid, fl.st_gid);
1004                             priv(OFF);
1005                             fputs("Korisnik uspjesno dodan u grupu.\n", stderr);
1006                         }
1007                         else
1008                         {
1009                             unlink(GROUPTMPFILE);
1010                             priv(OFF);
1011                             fputs("Ne postoji unesena grupa!\n", stderr);
1012                         }
1013                     }
1014                 }
1015                 else
1016                     fputs("Ne postoji uneseni korisnik!\n", stderr);
1017             }
1018 getout:
1019             priv(ON);
1020             unlockpw();
1021             priv(OFF);
1022             waitkey();
1023             break;
1024         case '3':
1025             getuser("Brisanje korisnika iz grupe:");
1026             if (testuser(ALL) == OK)
1027             {
1028                 if (getpwnam(loginname))
1029                 {
1030                     getgroup("");
1031                     if (testgroup() == OK)
1032                     {
1033                         FILE *readfp, *writefp;
1034                         char line[2048];
1035                         int found = 0, empty = 0;
1036                         struct stat fl;
1037
1038                         logger("REMOVE USER FROM GROUP: user %s, group %s", loginname, group);
1039                         priv(ON);
1040                         if (lockpw() == ERROR)
1041                         {
1042                             priv(OFF);
1043 #ifdef __osf__
1044                             fputs("Probajte malo kasnije, /etc/group je u upotrebi!\n", stderr);
1045 #endif
1046                             goto getout1;
1047                         }
1048                         if (!(readfp = fopen(GROUPFILE, "rt")))
1049                         {
1050                             priv(OFF);
1051                             fputs("Ne mogu otvoriti /etc/group datoteku!\n", stderr);
1052                             goto getout1;
1053                         }
1054                         if (stat(GROUPFILE, &fl) == -1)
1055                         {
1056                             priv(OFF);
1057                             fputs("Ne mogu pogledati dozvole na /etc/group datoteci!\n", stderr);
1058                             goto getout;
1059                         }
1060                         unlink(GROUPTMPFILE);
1061                         if (!(writefp = fopen(GROUPTMPFILE, "wt")))
1062                         {
1063                             fclose(readfp);
1064                             priv(OFF);
1065                             fputs("Ne mogu otvoriti privremenu datoteku!\n", stderr);
1066                             goto getout1;
1067                         }
1068                         while (fgets(line, 2048, readfp))
1069                         {
1070                             if (strstr(line, group) == line && line[strlen(group)] == ':')
1071                             {
1072                                 char *ptr, left, right;
1073
1074                                 if ((ptr = strstr(line + strlen(group) + 1, loginname)))
1075                                 {
1076                                     left = *(ptr - 1);
1077                                     right = *(ptr + strlen(loginname));
1078                                     if ((left == ':' || left == ',') &&
1079                                             (right == ',' || right == '\n'))
1080                                         goto ok;
1081
1082                                 }
1083                                 fclose(readfp);
1084                                 fclose(writefp);
1085                                 unlink(GROUPTMPFILE);
1086                                 priv(OFF);
1087                                 fputs("Korisnik nije u unesenoj grupi!\n", stderr);
1088                                 goto getout1;
1089 ok:
1090                                 if (right != '\n')
1091                                     strcpy(ptr, ptr + strlen(loginname) + 1);
1092                                 else if (left != ':')
1093                                     strcpy(ptr - 1, "\n");
1094                                 else
1095                                 {
1096                                     empty = 1;
1097                                     strcpy(ptr, "\n");
1098                                 }
1099                                 found = 1;
1100                             }
1101                             fputs(line, writefp);
1102                             if (ferror(writefp))
1103                             {
1104                                 fclose(readfp);
1105                                 fclose(writefp);
1106                                 unlink(GROUPTMPFILE);
1107                                 priv(OFF);
1108                                 fputs("Problem prilikom pisanja privremene datoteke!\n", stderr);
1109                                 goto getout1;
1110                             }
1111                         }
1112                         fclose(readfp);
1113                         fclose(writefp);
1114                         if (found)
1115                         {
1116                             system("/bin/mv /tmp/group /etc/group");
1117                             chmod(GROUPFILE, fl.st_mode);
1118                             chown(GROUPFILE, fl.st_uid, fl.st_gid);
1119                             priv(OFF);
1120                             fputs("Korisnik uspjesno obrisan iz grupe.\n", stderr);
1121                             if (empty)
1122                                 fputs("U grupi nema vise ni jednog korisnika.\n", stderr);
1123                         }
1124                         else
1125                         {
1126                             unlink(GROUPTMPFILE);
1127                             priv(OFF);
1128                             fputs("Ne postoji unesena grupa!\n", stderr);
1129                         }
1130                     }
1131                 }
1132                 else
1133                     fputs("Ne postoji uneseni korisnik!\n", stderr);
1134             }
1135 getout1:
1136             priv(ON);
1137             unlockpw();
1138             priv(OFF);
1139             waitkey();
1140             break;
1141         case '4':
1142             getgroup("Brisanje grupe:");
1143             if (testgroup() == OK)
1144             {
1145                 logger("GROUP REMOVE: group %s", group);
1146 #if defined(__SVR4) || defined(__linux__)
1147                 sprintf(command, "/usr/sbin/groupdel %s", group);
1148 #elif defined(__osf__)
1149                 sprintf(command, "/usr/sbin/sysadm.removegroup %s", group);
1150 #elif defined(ultrix)
1151                 sprintf(command, "/usr/etc/sysadm.removegroup %s", group);
1152 #endif
1153                 priv(ON);
1154                 system(command);
1155                 priv(OFF);
1156             }
1157             waitkey();
1158             break;
1159         case '5':
1160             oldumask = umask(002);
1161             if (getdir() == OK)
1162             {
1163                 getgroup("Grupa u cije vlasnistvo zelite staviti direktorij:");
1164                 if (testgroup() == OK)
1165                 {
1166                     struct group *grpptr;
1167                     int i, status;
1168
1169                     grpptr = getgrnam(group);
1170                     if (!grpptr)
1171                     {
1172                         fputs("Trazena grupa ne postoji!\n", stderr);
1173                         goto donedir;
1174                     }
1175                     logger("DIRECTORY CREATE: directory %s, group %s", directory, group);
1176                     for (i = 1;;i++)
1177                     {
1178                         while (directory[i] && directory[i] != '/')
1179                             i++;
1180                         if (directory[i])
1181                         {
1182                             directory[i] = 0;
1183                             priv(ON);
1184                             status = mkdir(directory, 0755);
1185                             if (status < 0 && errno != EEXIST)
1186                             {
1187                                 priv(OFF);
1188                                 perror("mkdir");
1189                                 goto donedir;
1190                             }
1191                             priv(OFF);
1192                             directory[i] = '/';
1193                         }
1194                         else
1195                         {
1196                             priv(ON);
1197                             status = mkdir(directory, 0775);
1198                             if (status < 0 && errno != EEXIST)
1199                             {
1200                                 perror("mkdir");
1201                                 goto donedir;
1202                             }
1203                             errno = 0;
1204                             if (chown(directory, (uid_t) -1, grpptr->gr_gid) < 0)
1205                                 perror("chown");
1206                             else
1207                                 fputs("Direktorij uspjesno kreiran.\n", stderr);
1208                             goto donedir;
1209                         }
1210                     }
1211                 }
1212             }
1213 donedir:
1214             priv(OFF);
1215             umask(oldumask);
1216             waitkey();
1217             break;
1218         case '6':
1219             if (getdir() == OK)
1220             {
1221                 logger("DIRECTORY REMOVE: directory %s", directory);
1222                 priv(ON);
1223                 if (rmdir(directory) < 0)
1224                     perror("rmdir");
1225                 else
1226                     fputs("Direktorij uspjesno obrisan.\n", stderr);
1227                 priv(OFF);
1228             }
1229             waitkey();
1230             break;
1231         case '7':
1232         case 'Q':
1233         case 'q':
1234             return;
1235         default:
1236             break;
1237         }
1238     }
1239 }
1240
1241 void shutdown(void)
1242 {
1243     int count = 0;
1244
1245     printf("Unesite poruku za korisnike > ");
1246     enter(message, MAXMESS);
1247     do
1248     {
1249         if (!isalpha(message[count]) && !isspace(message[count]) && !isdigit(message[count]) && message[count] != '.' && message[count] != ',' && message[count] != '_' && message[count] != '-' && message[count] != '=')
1250         {
1251             priv(OFF);
1252             fputs("Unijeli ste nedozvoljene znakove u poruci!\n", stderr);
1253             waitkey();
1254             return;
1255         }
1256         count++;
1257     }
1258     while (message[count]);
1259     printf("\nUnesite vrijeme kroz koje ce se racunalo zaustaviti (1 - 60 min) > ");
1260     enter(string, MAXSTR);
1261     grace = atoi(string);
1262     if (grace < MINGRACE || grace > MAXGRACE)
1263     {
1264         priv(OFF);
1265         fprintf(stderr, "Unijeli ste vrijeme koje je nula, negativno ili preveliko!\n");
1266         waitkey();
1267         return;
1268     }
1269 #if defined(__SVR4)
1270     grace *= 60;
1271 #endif
1272     puts("Pokrenuta je procedura za zaustavljanje racunala!\n");
1273     logger("SHUTDOWN!");
1274 #if defined(__SVR4)
1275     sprintf(command, "/usr/sbin/shutdown -i0 -y -g%d \"%s\"", grace, message);
1276 #elif defined(__osf__) || defined (__linux__)
1277     sprintf(command, "/sbin/shutdown -h +%d %s", grace, message);
1278 #elif defined(ultrix)
1279     sprintf(command, "/bin/shutdown -h +%d %s", grace, message);
1280 #endif
1281     priv(ON);
1282     system(command);
1283     priv(OFF);
1284 loop:
1285     sleep(10);
1286     goto loop;
1287     waitkey();
1288     return;
1289 }
1290
1291 void manual(void)
1292 {
1293     FILE* manual;
1294     char line[256];
1295     int count = 0;
1296
1297     logger("MANUAL READ");
1298     priv(ON);
1299     if (!(manual = fopen(MANFILE, "rt")))
1300     {
1301         priv(OFF);
1302         fputs("Uputstva nisu instalirana!\n", stderr);
1303         waitkey();
1304         return;
1305     }
1306     priv(OFF);
1307     while (fgets(line, 256, manual))
1308     {
1309         fputs(line, stdout);
1310         if (count++ == 21)
1311         {
1312             waitkey();
1313             clear();
1314             count = 0;
1315         }
1316     }
1317     fclose(manual);
1318     waitkey();
1319     return;
1320 }
1321
1322 void banner(void)
1323 {
1324     clear();
1325     puts(VERSION);
1326     return;
1327 }
1328
1329 void console_check(char *name)
1330 {
1331     char *cptr;
1332     int oncon = 0;
1333     struct stat statbuf;
1334     struct utmp entry;
1335     FILE *fp;
1336
1337     priv(OFF);
1338     if (isatty(0))
1339         cptr = ttyname(0);
1340     else
1341     {
1342         fprintf(stderr, "\nProblem s terminalom.\nIzlazak iz programa!\n");
1343         exit(1);
1344     }
1345     if (!cptr || strcmp(cptr, CONSOLE))
1346     {
1347         if (stat(CONSOLE, &statbuf) < 0)
1348         {
1349             fprintf(stderr, "\nNe mogu provjeriti vlasnistvo /dev/console.\nIzlazak iz programa!\n");
1350             exit(1);
1351         }
1352         if (statbuf.st_uid == saveduid)
1353             return;
1354 #if defined(__SVR4)
1355         else
1356             consexit();
1357 #endif
1358
1359 #if defined(__osf__) || defined(ultrix) || defined(__linux__)
1360         if (strstr(cptr, "/dev/") == cptr)
1361             strcpy(cptr, cptr + 5);
1362         fp = fopen(UTMP_FILE, "r");
1363         if (!fp)
1364         {
1365             priv(OFF);
1366             fprintf(stderr, "\nNe mogu otvoriti utmp datoteku.\nIzlazak iz programa!\n");
1367             exit(1);
1368         }
1369         while (fread(&entry, sizeof(entry), 1, fp))
1370         {
1371 #if defined(__linux__)
1372             entry.ut_line[UT_LINESIZE-1] = 0;
1373             entry.ut_user[UT_NAMESIZE-1] = 0;
1374             entry.ut_host[UT_HOSTSIZE-1] = 0;
1375 #else
1376             entry.ut_line[8] = 0;
1377             entry.ut_name[8] = 0;
1378             entry.ut_host[16] = 0;
1379 #endif
1380 #if defined (__linux__)
1381             if (entry.ut_type == DEAD_PROCESS)
1382                 continue;
1383             if (strncmp(entry.ut_line, cptr, UT_LINESIZE-1))
1384                 continue;
1385             if (!strncmp(entry.ut_line, "tty", 3) && \
1386                     entry.ut_line[3] >= '0' && \
1387                     entry.ut_line[3] <= '9' && \
1388                     !strncmp(entry.ut_user, name, UT_NAMESIZE-1))
1389             {
1390                 oncon = 1;
1391                 break;
1392             }
1393             else if (!strncmp(entry.ut_host, ":0", 2) && \
1394                      !strncmp(entry.ut_user, name, UT_NAMESIZE-1))
1395             {
1396                 oncon = 1;
1397                 break;
1398             }
1399             else
1400                 break; /* pravi tty, a nije na konzoli */
1401 #else
1402             if (strncmp(entry.ut_line, cptr, 8))
1403                 continue;
1404             if (!strncmp(entry.ut_line, ":0", 2) && !strncmp(entry.ut_name, name, 8))
1405             {
1406                 oncon = 1;
1407                 break;
1408             }
1409             if (!strncmp(entry.ut_host, ":0.0", 8) || !strncmp(entry.ut_host, "local", 8))
1410             {
1411                 oncon = 1;
1412                 break;
1413             }
1414 #endif /* __linux__ */
1415         }
1416         fclose(fp);
1417         if (!oncon)
1418             consexit();
1419 #endif
1420     }
1421     return;
1422 }
1423
1424
1425 int main(int argc, char **argv)
1426 {
1427     char ch, *cptr;
1428     int allowed;
1429     FILE *aclfile;
1430     FILE *conffile;
1431     struct passwd *acl = NULL;
1432     char adminlogin[64], adminfull[1024];
1433     char *p;
1434
1435 #if defined(DU4)
1436     set_auth_parameters(argc,argv);
1437 #endif
1438     umask(022);
1439     putenv("IFS=\" \"");
1440     signal(SIGINT, SIG_IGN);
1441     signal(SIGTSTP, SIG_IGN);
1442     signal(SIGQUIT, SIG_IGN);
1443     signal(SIGPIPE, SIG_IGN);
1444     saveduid = getuid();
1445     setuid(0);
1446     chmod(LOGFILE, 0600);
1447     chmod(ACLFILE, 0600);
1448     chown(LOGFILE, 0, -1);
1449     chown(ACLFILE, 0, -1);
1450     if (!(logfile = fopen(LOGFILE, "a")))
1451     {
1452         priv(OFF);
1453         perror("fopen");
1454         fprintf(stderr, "\nNe mogu otvoriti log datoteku.\nIzlazak iz programa!\n");
1455         exit(1);
1456     }
1457     if (saveduid)
1458     {
1459         if (!(aclfile = fopen(ACLFILE, "r")))
1460         {
1461             priv(OFF);
1462             perror("fopen");
1463             fprintf(stderr, "\nNe mogu otvoriti datoteku kontrole pristupa.\nIzlazak iz programa!\n");
1464             exit(1);
1465         }
1466         allowed = 0;
1467         while (fgets(string, MAXSTR, aclfile))
1468         {
1469             if (*string == '#')
1470                 continue;
1471             authdir = group_fallback_dir = NULL;
1472             for (p = string; *p && !isspace(*p); p++);
1473             cptr = p;
1474             if (*p && *p != '\n')
1475             {
1476                 while (isspace(*p))
1477                     ++p;
1478                 authdir = p;
1479                 while (*p && !isspace(*p))
1480                     ++p;
1481                 if (*p != '\n')
1482                 {
1483                     *p++ = '\0';
1484                     group_fallback_dir = p;
1485                     while (*p && !isspace(*p))
1486                         ++p;
1487                     *p = '\0';
1488                     group_fallback_dir = strdup(group_fallback_dir);
1489                 }
1490                 else
1491                     *p = '\0';
1492             }
1493             *cptr = 0;
1494             if ((acl = getpwnam(string)) && acl->pw_uid == saveduid)
1495             {
1496                 if (authdir)
1497                     authdir = strdup(authdir);
1498                 else
1499                     authdir = NULL;
1500                 allowed = 1;
1501                 break;
1502             }
1503         }
1504         fclose(aclfile);
1505         if (!group_fallback_dir)
1506             group_fallback_dir = authdir ? authdir : HM;
1507         if (!allowed)
1508         {
1509             priv(OFF);
1510             fprintf(stderr, "\nNemate dozvolu za koristenje programa.\nIzlazak iz programa!\n");
1511             exit(1);
1512         }
1513         priv(ON);
1514         if (!(conffile = fopen(OPTFILE, "r")))
1515         {
1516             priv(OFF);
1517             /*      perror("fopen");
1518                     fprintf(stderr, "Ne mogu otvoriti datoteku s konfiguracijskim opcijama.\n");
1519                     sleep(2);
1520             */
1521         }
1522         else
1523         {
1524             priv(OFF);
1525             while (fgets(string, MAXSTR, conffile))
1526             {
1527                 p = &string[strlen(string)-1];
1528                 if (*p == '\n')
1529                     *p = '\0';
1530                 if (!strncmp(string, CONF_NOCONSOLE, MAXSTR-1))
1531                     conscheck = 0;
1532             }
1533             fclose(conffile);
1534         }
1535
1536         if (!authdir && conscheck)
1537             console_check(acl->pw_name);
1538     }
1539     else
1540     {
1541         authdir = NULL;
1542         group_fallback_dir = HM;
1543         acl = getpwuid(0);
1544     }
1545     if (acl && acl->pw_name)
1546         strcpy(adminlogin, acl->pw_name);
1547     else
1548         strcpy(adminlogin, "(none)");
1549     if (acl && acl->pw_gecos)
1550         strcpy(adminfull, acl->pw_gecos);
1551     else
1552         strcpy(adminfull, "NULL");
1553     logger("ADMIN START: admin %s (%s)", adminlogin, adminfull);
1554     for (;;)
1555     {
1556         priv(OFF);
1557         banner();
1558         puts("1 -- Dodavanje korisnika");
1559         puts("2 -- Brisanje korisnika");
1560         puts("3 -- Promjena lozinke korisnika");
1561         puts("4 -- Promjena quote korisnika\n");
1562         puts("5 -- Operacije nad grupama korisnika\n");
1563         puts("6 -- Zaustavljanje i gasenje racunala\n");
1564         puts("7 -- Pomoc\n");
1565         puts("8 -- Izlazak iz administracijskog programa\n");
1566         printf("Unesite odabir > ");
1567         ch = getch();
1568         clear();
1569         switch(ch)
1570         {
1571         case '1':
1572             adduser();
1573             break;
1574         case '2':
1575             rmuser();
1576             break;
1577         case '3':
1578             chpass();
1579             break;
1580         case '4':
1581             chquota();
1582             break;
1583         case '5':
1584             opgroup();
1585             break;
1586         case '6':
1587             shutdown();
1588             break;
1589         case '7':
1590         case 'h':
1591         case '?':
1592             manual();
1593             break;
1594         case '0':
1595         case '8':
1596         case 'Q':
1597         case 'q':
1598             clear();
1599             logger("ADMIN END: admin %s (%s)", adminlogin, adminfull);
1600             fclose(logfile);
1601             exit(0);
1602         default:
1603             break;
1604         }
1605     }
1606 }