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