Return to statsb.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix

Annotation of coherent/g/usr/lib/uucp/tay104/unix/statsb.c, revision 1.1

1.1     ! root        1: /* statsb.c
        !             2:    System dependent routines for uustat.
        !             3: 
        !             4:    Copyright (C) 1992 Ian Lance Taylor
        !             5: 
        !             6:    This file is part of the Taylor UUCP package.
        !             7: 
        !             8:    This program is free software; you can redistribute it and/or
        !             9:    modify it under the terms of the GNU General Public License as
        !            10:    published by the Free Software Foundation; either version 2 of the
        !            11:    License, or (at your option) any later version.
        !            12: 
        !            13:    This program is distributed in the hope that it will be useful, but
        !            14:    WITHOUT ANY WARRANTY; without even the implied warranty of
        !            15:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            16:    General Public License for more details.
        !            17: 
        !            18:    You should have received a copy of the GNU General Public License
        !            19:    along with this program; if not, write to the Free Software
        !            20:    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
        !            21: 
        !            22:    The author of the program may be contacted at [email protected] or
        !            23:    c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
        !            24:    */
        !            25: 
        !            26: #include "uucp.h"
        !            27: 
        !            28: #if USE_RCS_ID
        !            29: const char statsb_rcsid[] = "$Id: statsb.c,v 1.1 93/07/30 08:03:31 bin Exp Locker: bin $";
        !            30: #endif
        !            31: 
        !            32: #include "uudefs.h"
        !            33: #include "uuconf.h"
        !            34: #include "sysdep.h"
        !            35: #include "system.h"
        !            36: 
        !            37: #include <errno.h>
        !            38: 
        !            39: #if HAVE_FCNTL_H
        !            40: #include <fcntl.h>
        !            41: #else
        !            42: #if HAVE_SYS_FILE_H
        !            43: #include <sys/file.h>
        !            44: #endif
        !            45: #endif
        !            46: 
        !            47: #ifndef O_RDONLY
        !            48: #define O_RDONLY 0
        !            49: #define O_WRONLY 1
        !            50: #define O_RDWR 2
        !            51: #endif
        !            52: 
        !            53: #ifndef O_NOCTTY
        !            54: #define O_NOCTTY 0
        !            55: #endif
        !            56: 
        !            57: #if HAVE_OPENDIR
        !            58: #if HAVE_DIRENT_H
        !            59: #include <dirent.h>
        !            60: #else /* ! HAVE_DIRENT_H */
        !            61: #include <sys/dir.h>
        !            62: #define dirent direct
        !            63: #endif /* ! HAVE_DIRENT_H */
        !            64: #endif /* HAVE_OPENDIR */
        !            65: 
        !            66: #if HAVE_TIME_H
        !            67: #include <time.h>
        !            68: #endif
        !            69: 
        !            70: #if HAVE_UTIME_H
        !            71: #include <utime.h>
        !            72: #endif
        !            73: 
        !            74: /* Local functions.  */
        !            75: 
        !            76: static int ussettime P((const char *z, time_t inow));
        !            77: static boolean fskill_or_rejuv P((pointer puuconf, const char *zid,
        !            78:                                  boolean fkill));
        !            79: 
        !            80: /* See whether the user is permitted to kill arbitrary jobs.  This is
        !            81:    true only for root and uucp.  We check for uucp by seeing if the
        !            82:    real user ID and the effective user ID are the same; this works
        !            83:    because we should be suid to uucp, so our effective user ID will
        !            84:    always be uucp while our real user ID will be whoever ran the
        !            85:    program.  */
        !            86: 
        !            87: boolean
        !            88: fsysdep_privileged ()
        !            89: {
        !            90:   uid_t iuid;
        !            91: 
        !            92:   iuid = getuid ();
        !            93:   return iuid == 0 || iuid == geteuid ();
        !            94: }
        !            95: 
        !            96: /* Set file access time to the present.  On many systems this could be
        !            97:    done by passing NULL to utime, but on some that doesn't work.  This
        !            98:    routine is not time critical, so we never rely on NULL.  */
        !            99: 
        !           100: static int
        !           101: ussettime(z, inow)
        !           102:      const char *z;
        !           103:      time_t inow;
        !           104: {
        !           105: #if HAVE_UTIME_H
        !           106:   struct utimbuf s;
        !           107: 
        !           108:   s.actime = inow;
        !           109:   s.modtime = inow;
        !           110:   return utime ((char *) z, &s);
        !           111: #else
        !           112:   time_t ai[2];
        !           113: 
        !           114:   ai[0] = inow;
        !           115:   ai[1] = inow;
        !           116:   return utime ((char *) z, ai);
        !           117: #endif
        !           118: }
        !           119: 
        !           120: /* Kill a job, given the jobid.  */
        !           121: 
        !           122: boolean
        !           123: fsysdep_kill_job (puuconf, zid)
        !           124:      pointer puuconf;
        !           125:      const char *zid;
        !           126: {
        !           127:   return fskill_or_rejuv (puuconf, zid, TRUE);
        !           128: }
        !           129: 
        !           130: /* Rejuvenate a job, given the jobid.  */
        !           131: 
        !           132: boolean
        !           133: fsysdep_rejuvenate_job (puuconf, zid)
        !           134:      pointer puuconf;
        !           135:      const char *zid;
        !           136: {
        !           137:   return fskill_or_rejuv (puuconf, zid, FALSE);
        !           138: }
        !           139: 
        !           140: /* Kill or rejuvenate a job, given the jobid.  */
        !           141: 
        !           142: static boolean
        !           143: fskill_or_rejuv (puuconf, zid, fkill)
        !           144:      pointer puuconf;
        !           145:      const char *zid;
        !           146:      boolean fkill;
        !           147: {
        !           148:   char *zfile;
        !           149:   char *zsys;
        !           150:   char bgrade;
        !           151:   time_t inow = 0;
        !           152:   int iuuconf;
        !           153:   struct uuconf_system ssys;
        !           154:   FILE *e;
        !           155:   boolean fret;
        !           156:   char *zline;
        !           157:   size_t cline;
        !           158:   int isys;
        !           159: 
        !           160:   zfile = zsjobid_to_file (zid, &zsys, &bgrade);
        !           161:   if (zfile == NULL)
        !           162:     return FALSE;
        !           163: 
        !           164:   if (! fkill)
        !           165:     inow = time ((time_t *) NULL);
        !           166: 
        !           167:   iuuconf = uuconf_system_info (puuconf, zsys, &ssys);
        !           168:   if (iuuconf == UUCONF_NOT_FOUND)
        !           169:     {
        !           170:       if (! funknown_system (puuconf, zsys, &ssys))
        !           171:        {
        !           172:          ulog (LOG_ERROR, "%s: Bad job id", zid);
        !           173:          ubuffree (zfile);
        !           174:          ubuffree (zsys);
        !           175:          return FALSE;
        !           176:        }
        !           177:     }
        !           178:   else if (iuuconf != UUCONF_SUCCESS)
        !           179:     {
        !           180:       ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
        !           181:       ubuffree (zfile);
        !           182:       ubuffree (zsys);
        !           183:       return FALSE;
        !           184:     }
        !           185: 
        !           186:   e = fopen (zfile, "r");
        !           187:   if (e == NULL)
        !           188:     {
        !           189:       if (errno == ENOENT)
        !           190:        ulog (LOG_ERROR, "%s: Job not found", zid);
        !           191:       else
        !           192:        ulog (LOG_ERROR, "fopen (%s): %s", zfile, strerror (errno));
        !           193:       (void) uuconf_system_free (puuconf, &ssys);
        !           194:       ubuffree (zfile);
        !           195:       ubuffree (zsys);
        !           196:       return FALSE;
        !           197:     }
        !           198: 
        !           199:   /* Now we have to read through the file to identify any temporary
        !           200:      files.  */
        !           201:   fret = TRUE;
        !           202:   zline = NULL;
        !           203:   cline = 0;
        !           204:   while (getline (&zline, &cline, e) > 0)
        !           205:     {
        !           206:       struct scmd s;
        !           207: 
        !           208:       if (! fparse_cmd (zline, &s))
        !           209:        {
        !           210:          ulog (LOG_ERROR, "Bad line in command file %s", zfile);
        !           211:          fret = FALSE;
        !           212:          continue;
        !           213:        }
        !           214: 
        !           215:       /* You are only permitted to delete a job if you submitted it or
        !           216:         if you are root or uucp.  */
        !           217:       if (strcmp (s.zuser, zsysdep_login_name ()) != 0
        !           218:          && ! fsysdep_privileged ())
        !           219:        {
        !           220:          ulog (LOG_ERROR, "%s: Not submitted by you", zid);
        !           221:          xfree ((pointer) zline);
        !           222:          (void) fclose (e);
        !           223:          (void) uuconf_system_free (puuconf, &ssys);
        !           224:          ubuffree (zfile);
        !           225:          ubuffree (zsys);
        !           226:          return FALSE;
        !           227:        }
        !           228: 
        !           229:       if (s.bcmd == 'S' || s.bcmd == 'E')
        !           230:        {
        !           231:          char *ztemp;
        !           232: 
        !           233:          ztemp = zsfind_file (s.ztemp, ssys.uuconf_zname, bgrade);
        !           234:          if (ztemp == NULL)
        !           235:            fret = FALSE;
        !           236:          else
        !           237:            {
        !           238:              if (fkill)
        !           239:                isys = remove (ztemp);
        !           240:              else
        !           241:                isys = ussettime (ztemp, inow);
        !           242: 
        !           243:              if (isys != 0 && errno != ENOENT)
        !           244:                {
        !           245:                  ulog (LOG_ERROR, "%s (%s): %s",
        !           246:                        fkill ? "remove" : "utime", ztemp,
        !           247:                        strerror (errno));
        !           248:                  fret = FALSE;
        !           249:                }
        !           250: 
        !           251:              ubuffree (ztemp);
        !           252:            }
        !           253:        }
        !           254:     }
        !           255: 
        !           256:   xfree ((pointer) zline);
        !           257:   (void) fclose (e);
        !           258:   (void) uuconf_system_free (puuconf, &ssys);
        !           259:   ubuffree (zsys);
        !           260: 
        !           261:   if (fkill)
        !           262:     isys = remove (zfile);
        !           263:   else
        !           264:     isys = ussettime (zfile, inow);
        !           265: 
        !           266:   if (isys != 0 && errno != ENOENT)
        !           267:     {
        !           268:       ulog (LOG_ERROR, "%s (%s): %s", fkill ? "remove" : "utime",
        !           269:            zfile, strerror (errno));
        !           270:       fret = FALSE;
        !           271:     }
        !           272: 
        !           273:   ubuffree (zfile);
        !           274: 
        !           275:   return fret;
        !           276: }
        !           277: 
        !           278: /* Get the time a work job was queued.  */
        !           279: 
        !           280: long
        !           281: ixsysdep_work_time (qsys, pseq)
        !           282:      const struct uuconf_system *qsys;
        !           283:      pointer pseq;
        !           284: {
        !           285:   char *zjobid, *zfile;
        !           286:   long iret;
        !           287: 
        !           288:   zjobid = zsysdep_jobid (qsys, pseq);
        !           289:   zfile = zsjobid_to_file (zjobid, (char **) NULL, (char *) NULL);
        !           290:   if (zfile == NULL)
        !           291:     return 0;
        !           292:   ubuffree (zjobid);
        !           293:   iret = ixsysdep_file_time (zfile);
        !           294:   ubuffree (zfile);
        !           295:   return iret;
        !           296: }
        !           297: 
        !           298: /* Get the time a file was created (actually, the time it was last
        !           299:    modified).  */
        !           300: 
        !           301: long
        !           302: ixsysdep_file_time (zfile)
        !           303:      const char *zfile;
        !           304: {
        !           305:   struct stat s;
        !           306: 
        !           307:   if (stat ((char *) zfile, &s) < 0)
        !           308:     {
        !           309:       if (errno != ENOENT)
        !           310:        ulog (LOG_ERROR, "stat (%s): %s", zfile, strerror (errno));
        !           311:       return ixsysdep_time ((long *) NULL);
        !           312:     }
        !           313: 
        !           314:   return (long) s.st_mtime;
        !           315: }
        !           316: 
        !           317: /* Start getting the status files.  */
        !           318: 
        !           319: boolean
        !           320: fsysdep_all_status_init (phold)
        !           321:      pointer *phold;
        !           322: {
        !           323:   DIR *qdir;
        !           324: 
        !           325:   qdir = opendir ((char *) ".Status");
        !           326:   if (qdir == NULL)
        !           327:     {
        !           328:       ulog (LOG_ERROR, "opendir (.Status): %s", strerror (errno));
        !           329:       return FALSE;
        !           330:     }
        !           331: 
        !           332:   *phold = (pointer) qdir;
        !           333:   return TRUE;
        !           334: }
        !           335: 
        !           336: /* Get the next status file.  */
        !           337: 
        !           338: char *
        !           339: zsysdep_all_status (phold, pferr, qstat)
        !           340:      pointer phold;
        !           341:      boolean *pferr;
        !           342:      struct sstatus *qstat;
        !           343: {
        !           344:   DIR *qdir = (DIR *) phold;
        !           345:   struct dirent *qentry;
        !           346: 
        !           347:   while (TRUE)
        !           348:     {
        !           349:       errno = 0;
        !           350:       qentry = readdir (qdir);
        !           351:       if (qentry == NULL)
        !           352:        {
        !           353:          if (errno == 0)
        !           354:            *pferr = FALSE;
        !           355:          else
        !           356:            {
        !           357:              ulog (LOG_ERROR, "readdir: %s", strerror (errno));
        !           358:              *pferr = TRUE;
        !           359:            }
        !           360:          return NULL;
        !           361:        }
        !           362: 
        !           363:       if (qentry->d_name[0] != '.')
        !           364:        {
        !           365:          struct uuconf_system ssys;
        !           366: 
        !           367:          /* Hack seriously; fsysdep_get_status only looks at the
        !           368:             zname element of the qsys argument, so if we fake that we
        !           369:             can read the status file.  This should really be done
        !           370:             differently.  */
        !           371:          ssys.uuconf_zname = qentry->d_name;
        !           372:          if (fsysdep_get_status (&ssys, qstat, (boolean *) NULL))
        !           373:            return zbufcpy (qentry->d_name);
        !           374: 
        !           375:          /* If fsysdep_get_status fails, it will output an error
        !           376:             message.  We just continue with the next entry, so that
        !           377:             most of the status files will be displayed.  */
        !           378:        }
        !           379:     }
        !           380: }
        !           381: 
        !           382: /* Finish getting the status file.  */
        !           383: 
        !           384: void
        !           385: usysdep_all_status_free (phold)
        !           386:      pointer phold;
        !           387: {
        !           388:   DIR *qdir = (DIR *) phold;
        !           389: 
        !           390:   (void) closedir (qdir);
        !           391: }
        !           392: 
        !           393: /* Get the status of all processes holding lock files.  We do this by
        !           394:    invoking ps after we've figured out the process entries to use.  */
        !           395: 
        !           396: boolean
        !           397: fsysdep_lock_status ()
        !           398: {
        !           399:   DIR *qdir;
        !           400:   struct dirent *qentry;
        !           401:   int calc;
        !           402:   int *pai;
        !           403:   int cgot;
        !           404:   int aidescs[3];
        !           405:   char *zcopy, *ztok;
        !           406:   int cargs, iarg;
        !           407:   char **pazargs;
        !           408: 
        !           409:   qdir = opendir ((char *) zSlockdir);
        !           410:   if (qdir == NULL)
        !           411:     {
        !           412:       ulog (LOG_ERROR, "opendir (%s): %s", zSlockdir, strerror (errno));
        !           413:       return FALSE;
        !           414:     }
        !           415: 
        !           416:   /* We look for entries that start with "LCK.." and ignore everything
        !           417:      else.  This won't find all possible lock files, but it should
        !           418:      find all the locks on terminals and systems.  */
        !           419: 
        !           420:   calc = 0;
        !           421:   pai = NULL;
        !           422:   cgot = 0;
        !           423:   while ((qentry = readdir (qdir)) != NULL)
        !           424:     {
        !           425:       char *zname;
        !           426:       int o;
        !           427: #if HAVE_V2_LOCKFILES
        !           428:       int i;
        !           429: #else
        !           430:       char ab[12];
        !           431: #endif
        !           432:       int cread;
        !           433:       int ierr;
        !           434:       int ipid;
        !           435: 
        !           436:       if (strncmp (qentry->d_name, "LCK..", sizeof "LCK.." - 1) != 0)
        !           437:        continue;
        !           438: 
        !           439:       zname = zsysdep_in_dir (zSlockdir, qentry->d_name);
        !           440:       o = open ((char *) zname, O_RDONLY | O_NOCTTY, 0);
        !           441:       if (o < 0)
        !           442:        {
        !           443:          if (errno != ENOENT)
        !           444:            ulog (LOG_ERROR, "open (%s): %s", zname, strerror (errno));
        !           445:          ubuffree (zname);
        !           446:          continue;
        !           447:        }
        !           448: 
        !           449: #if HAVE_V2_LOCKFILES
        !           450:       cread = read (o, &i, sizeof i);
        !           451: #else
        !           452:       cread = read (o, ab, sizeof ab - 1);
        !           453: #endif
        !           454: 
        !           455:       ierr = errno;
        !           456:       (void) close (o);
        !           457: 
        !           458:       if (cread < 0)
        !           459:        {
        !           460:          ulog (LOG_ERROR, "read %s: %s", zname, strerror (ierr));
        !           461:          ubuffree (zname);
        !           462:          continue;
        !           463:        }
        !           464: 
        !           465:       ubuffree (zname);
        !           466: 
        !           467: #if HAVE_V2_LOCKFILES
        !           468:       ipid = i;
        !           469: #else
        !           470:       ab[cread] = '\0';
        !           471:       ipid = strtol (ab, (char **) NULL, 10);
        !           472: #endif
        !           473: 
        !           474:       printf ("%s: %d\n", qentry->d_name, ipid);
        !           475: 
        !           476:       if (cgot >= calc)
        !           477:        {
        !           478:          calc += 10;
        !           479:          pai = (int *) xrealloc ((pointer) pai, calc * sizeof (int));
        !           480:        }
        !           481: 
        !           482:       pai[cgot] = ipid;
        !           483:       ++cgot;
        !           484:     }
        !           485: 
        !           486:   if (cgot == 0)
        !           487:     return TRUE;
        !           488: 
        !           489:   aidescs[0] = SPAWN_NULL;
        !           490:   aidescs[1] = 1;
        !           491:   aidescs[2] = 2;
        !           492: 
        !           493:   /* Parse PS_PROGRAM into an array of arguments.  */
        !           494:   zcopy = zbufcpy (PS_PROGRAM);
        !           495: 
        !           496:   cargs = 0;
        !           497:   for (ztok = strtok (zcopy, " \t");
        !           498:        ztok != NULL;
        !           499:        ztok = strtok ((char *) NULL, " \t"))
        !           500:     ++cargs;
        !           501: 
        !           502:   pazargs = (char **) xmalloc ((cargs + 1) * sizeof (char *));
        !           503: 
        !           504:   memcpy (zcopy, PS_PROGRAM, sizeof PS_PROGRAM);
        !           505:   for (ztok = strtok (zcopy, " \t"), iarg = 0;
        !           506:        ztok != NULL;
        !           507:        ztok = strtok ((char *) NULL, " \t"), ++iarg)
        !           508:     pazargs[iarg] = ztok;
        !           509:   pazargs[iarg] = NULL;
        !           510: 
        !           511: #if ! HAVE_PS_MULTIPLE
        !           512:   /* We have to invoke ps multiple times.  */
        !           513:   {
        !           514:     int i;
        !           515:     char *zlast, *zset;
        !           516: 
        !           517:     zlast = pazargs[cargs - 1];
        !           518:     zset = zbufalc (strlen (zlast) + 20);
        !           519:     for (i = 0; i < cgot; i++)
        !           520:       {
        !           521:        pid_t ipid;
        !           522: 
        !           523:        sprintf (zset, "%s%d", zlast, pai[i]);
        !           524:        pazargs[cargs - 1] = zset;
        !           525: 
        !           526:        ipid = ixsspawn ((const char **) pazargs, aidescs, FALSE, FALSE,
        !           527:                         (const char *) NULL, FALSE, TRUE,
        !           528:                         (const char *) NULL, (const char *) NULL,
        !           529:                         (const char *) NULL);
        !           530:        if (ipid < 0)
        !           531:          ulog (LOG_ERROR, "ixsspawn: %s", strerror (errno));
        !           532:        else
        !           533:          (void) ixswait ((unsigned long) ipid, PS_PROGRAM);
        !           534:       }
        !           535:     ubuffree (zset);
        !           536:   }
        !           537: #else
        !           538:   {
        !           539:     char *zlast;
        !           540:     int i;
        !           541:     pid_t ipid;
        !           542: 
        !           543:     zlast = zbufalc (strlen (pazargs[cargs - 1]) + cgot * 20 + 1);
        !           544:     strcpy (zlast, pazargs[cargs - 1]);
        !           545:     for (i = 0; i < cgot; i++)
        !           546:       {
        !           547:        char ab[20];
        !           548: 
        !           549:        sprintf (ab, "%d", pai[i]);
        !           550:        strcat (zlast, ab);
        !           551:        if (i + 1 < cgot)
        !           552:          strcat (zlast, ",");
        !           553:       }
        !           554:     pazargs[cargs - 1] = zlast;
        !           555: 
        !           556:     ipid = ixsspawn ((const char **) pazargs, aidescs, FALSE, FALSE,
        !           557:                     (const char *) NULL, FALSE, TRUE,
        !           558:                     (const char *) NULL, (const char *) NULL,
        !           559:                     (const char *) NULL);
        !           560:     if (ipid < 0)
        !           561:       ulog (LOG_ERROR, "ixsspawn: %s", strerror (errno));
        !           562:     else
        !           563:       (void) ixswait ((unsigned long) ipid, PS_PROGRAM);
        !           564:     ubuffree (zlast);
        !           565:   }
        !           566: #endif    
        !           567: 
        !           568:   ubuffree (zcopy);
        !           569:   xfree ((pointer) pazargs);
        !           570: 
        !           571:   return TRUE;
        !           572: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.