⟦bedcf3a5f⟧

TextFile

/* 
 * Copyright (c) 1988 Michael A. Cooper, University of Southern California.
 * This program may be used, copied, modified, and redistributed freely
 * for noncommercial purposes, so long as this notice remains intact.
 */

#ifndef lint
static char *RCSid = "$Header: getdtent.c,v 4.3 88/07/05 15:59:47 mcooper Exp $";
#endif

/*
 *------------------------------------------------------------------
 *
 * $Source: /usr/skat3/src/common/usc/etc/downtime/RCS/getdtent.c,v $
 * $Revision: 4.3 $
 * $Date: 88/07/05 15:59:47 $
 * $State: Exp $
 *
 *------------------------------------------------------------------
 *
 * Michael A. Cooper
 * Research and Development Group
 * University Computing Services 
 * University of Southern California
 * (mcooper@oberon.USC.EDU)
 *
 *------------------------------------------------------------------
 *
 * $Log:	getdtent.c,v $
 * Revision 4.3  88/07/05  15:59:47  mcooper
 * Added copyright notice.
 * 
 * Revision 4.2  88/06/30  10:07:09  mcooper
 * Fixed -u problem that caused no checktime()
 * to be run.
 * 
 * Revision 4.1  88/05/24  13:29:46  mcooper
 * General cleanup.
 * 
 * Revision 4.0  88/04/20  15:42:22  mcooper
 * 
 * 
 * Revision 3.5  88/04/20  13:37:34  mcooper
 * Replace F_BROADCAST with F_MSG_REMOTE.
 * Added F_MSG_LOCAL.
 * 
 * Revision 3.4  88/04/11  19:48:14  mcooper
 * Converted all dt_flags to use flag
 * bits.
 * 
 * Revision 3.3  88/03/15  14:42:25  mcooper
 * Malloc dt_shutter and dt_reason.
 * 
 * Revision 3.2  88/03/02  16:10:29  mcooper
 * Cleanup time.
 * 
 * Revision 3.1  88/01/21  20:28:56  mcooper
 * Port to Alliant (Concentrix 3.0).
 * 
 * Revision 3.0  87/07/24  14:19:02  mcooper
 * Version 3.
 * 
 *------------------------------------------------------------------
 */


#include "defs.h"
#include "getdtent.h"

static FILE *fddata = NULL;

/*
 * dtclose - Close data file
 */

dtclose()
{
  if (fddata)
    fclose(fddata);
}

/*
 * dtrewind - Rewind data file
 */

dtrewind()
{
  if (fddata != NULL)
    fclose(fddata);

  if ((fddata = fopen(datafile, "r")) == NULL) {
    return(-1);
  }

  return(0);
}

char *
mkflags(flags)
int flags;
{
  char buf[FC_END+1];

  strcpy(buf, "");
  if (flags & F_KILL)
    buf[FC_HOW] = FC_KILL;
  else if (flags & F_HALT)
    buf[FC_HOW] = FC_HALT;
  else if (flags & F_REBOOT)
    buf[FC_HOW] = FC_REBOOT;
  else if (flags & F_FAKE)
    buf[FC_HOW] = FC_FAKE;
  else
    buf[FC_HOW] = FC_NULL;

  if (flags & F_MOTD) {
    if (flags & F_DONEMOTD)
      buf[FC_MOTD] = FC_DONE;
    else
      buf[FC_MOTD] = FC_YES;
  } else {
    buf[FC_MOTD] = FC_NO;
  }

  if (flags & F_MSG_REMOTE)
    buf[FC_MSG_REMOTE] = FC_YES;
  else
    buf[FC_MSG_REMOTE] = FC_NO;

  if (flags & F_MSG_LOCAL)
    buf[FC_MSG_LOCAL] = FC_YES;
  else
    buf[FC_MSG_LOCAL] = FC_NO;

  if (flags & F_FASTBOOT)
    buf[FC_FTSY] = FC_FASTBOOT;
  else if (flags & F_NOSYNC)
    buf[FC_FTSY] = FC_NOSYNC;
  else
    buf[FC_FTSY] = FC_NULL;

  if (flags & F_SHUTMSG_ONE)
    buf[FC_SHUTMSG] = FC_SHUTMSG_ONE;
  else
    buf[FC_SHUTMSG] = FC_SHUTMSG_VER;

  buf[FC_END] = NULL;

  return(newstr(buf));
}

/*
 * mkdtline - Make a downtime datafile line.
 */
char *
mkdtline(d)
struct downtime *d;
{
  char buf[BUFSIZ];

  (void) sprintf(buf, "%s %s %s %d %s %s %s '%s'\n", 
		 ttod(d->dt_down),
		 ttod(d->dt_up),
		 ttod(d->dt_orderdown),
		 d->dt_islocked,
		 d->dt_shutter,
		 d->dt_host,
		 mkflags(d->dt_flags),
		 d->dt_reason);
  
  return(newstr(buf));
}

getflags(str)
char *str;
{
  int flags = 0;

  switch (str[FC_HOW]) {
  case FC_NULL:
  case FC_KILL:
    flags |= F_KILL;
    break;
  case FC_HALT:
    flags |= F_HALT;
    break;
  case FC_REBOOT:
    flags |= F_REBOOT;
    break;
  case FC_FAKE:
    flags |= F_FAKE;
    break;
  default:
    fprintf(stderr, "getflags: Unknown take down character `%c'.\n", 
	    str[FC_HOW]);
    return(-1);
  }

  switch (str[FC_FTSY]) {
  case FC_FASTBOOT:
    flags |= F_FASTBOOT;
    break;
  case FC_NOSYNC:
    flags |= F_NOSYNC;
    break;
  case FC_NULL:
    break;
  default:
    fprintf(stderr, "getflags: Unknown fastboot/nosync character `%s'.\n",
	    str[FC_FTSY]);
    return(-1);
  }

  switch (str[FC_SHUTMSG]) {
  case FC_SHUTMSG_ONE:
    flags |= F_SHUTMSG_ONE;
    break;
  case FC_SHUTMSG_VER:
    flags |= F_SHUTMSG_VER;
    break;
  case FC_NULL:
    break;
  default:
    fprintf(stderr, "getflags: Unknown shutmsg character `%s'.\n",
	    str[FC_SHUTMSG]);
    return(-1);
  }

  switch (str[FC_MOTD]) {
  case FC_DONE:
    flags |= F_DONEMOTD;
  case FC_YES:
    flags |= F_MOTD;
    break;
  case FC_NO:
  case FC_NULL:
    break;
  default:
    fprintf(stderr, "getflags: Unknown motd character `%s'.\n",
	    str[FC_SHUTMSG]);
    return(-1);
  }

  if (str[FC_MSG_REMOTE] == FC_YES)
    flags |= F_MSG_REMOTE;

  if (str[FC_MSG_LOCAL] == FC_YES)
    flags |= F_MSG_LOCAL;

  return(flags);
}

/*
 * getdtent() - For each call to getdtent(), it returns a pointer
 *              to the next downtime struct found in the data file.
 *
 *              Returns NULL at EOF.
 */

char tmp[9][200], dbuf[BUFSIZ];

struct downtime *
getdtent()
{
  struct downtime *dt;
  int done;

  if (fddata == NULL) {
    if ((fddata = fopen(datafile, "r")) == NULL) {
      dprintf("fopen failed on %s.\n", datafile);
      return(NULL);
    }
  }

  done = FALSE;
  if (fgets(dbuf, sizeof(dbuf), fddata) == NULL)
    done = TRUE;

  if (done)
    return(NULL);

  tmp[0][0] = NULL;
  sscanf(dbuf, "%s %s %s %s %s %s %s '%[^']",
	 tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7]);

  if (tmp[0][0] == NULL) {
    return(NULL);
  }

  dt = (struct downtime *) xmalloc(sizeof(struct downtime));
  dt->dt_shutter = xmalloc(strlen(tmp[4])+1);
  dt->dt_reason = xmalloc(strlen(tmp[7])+1);

  dt->dt_down = dtot(tmp[0]);
  dt->dt_up = dtot(tmp[1]);
  dt->dt_orderdown = dtot(tmp[2]);
  dt->dt_islocked = atoi(tmp[3]);
  dt->dt_flags = getflags(tmp[6]);
  strcpy(dt->dt_shutter, tmp[4]);
  strcpy(dt->dt_host, tmp[5]);
  strcpy(dt->dt_reason, tmp[7]);

  return(dt);
}

/* 
 * getdtdate - get entry for "date".  Date is of form:
 *
 *    MM/DD/YY-HH:MM
 */
struct downtime *
getdtdate(date)
char *date;
{
  struct downtime *d;

  dtrewind();

  while (d = getdtent()) {
    if (strncmp(ttod(d->dt_down), date, strlen(date)) == 0) {
      return(d);
    }
  }

  return(NULL);
}

dtlock(d, how)
struct downtime *d;
int how;
{
  struct downtime *tmpdt;
  char *date, *p;
  char tmpfile[200];
  int found_it = FALSE;
  int did_it = FALSE;
  FILE *fdtmp;

  dtrewind();

  if (d != NULL) {
    date = ttod(d->dt_down);
  }

  sprintf(tmpfile, "%s.tmpXXXXXX", datafile);
  mktemp(tmpfile);
  if ((fdtmp = fopen(tmpfile, "w")) == NULL) {
    perror(tmpfile);
    return(-1);
  }

  while (tmpdt = getdtent()) {
    did_it = FALSE;

    if (uflag && tmpdt->dt_islocked) {
      if (!iflag)
        printf("%s: ", prog);
      printf("  Unlocking [%s] ... ", mkdate(tmpdt->dt_down, D_DATE));
      did_it = TRUE;
    }

    if (uflag || strncmp(ttod(tmpdt->dt_down), date, strlen(date)) == 0) {
      found_it = TRUE;

      if (tmpdt->dt_islocked && !uflag) {
        fprintf(stderr, "Entry for %s is already locked.\n", date);
        return(-1);
      }

      if (how == L_LOCK) 
        tmpdt->dt_islocked = getpid();
      else if (how == L_UNLOCK)
        tmpdt->dt_islocked = 0;

      if (d != NULL)
        tmpdt->dt_flags = d->dt_flags;
    }

    if ((p = mkdtline(tmpdt)) == NULL) {
      fprintf(stderr, "dtlock: mkdtline failed.\n");
      return(-1);
    }
    fputs(p, fdtmp);

    if (uflag && did_it)
      printf(" done.\n");
  }
  fclose(fdtmp);
  dtclose();

  unlink(datafile);

  if (rename(tmpfile, datafile) < 0) {
    fprintf(stderr, "%s --> ", tmpfile);
    perror(datafile);
    return(-1);
  }

  if (!found_it && !uflag) {
    fprintf(stderr, "dtlock: Cannot lock entry for %s: No entry found.\n",
	    date);
    return(-1);
  }

  return(0);
}

dtfileislocked()
{
  if (access(LOCKFILE, F_OK) == 0)
    return(TRUE);
  else
    return(FALSE);
}

dtfilewaitlock()
{
  register int r;

  for (r = 0;r <= LOCKRETRIES && access(LOCKFILE, F_OK) == 0;++r) {
    sleep(1);
  }

  return(dtfileislocked());
}

dtfilelock()
{
  FILE *fd;

  if (dtfileislocked()) {
    if (dtfilewaitlock()) {
      fprintf(stderr, "%s: File is locked by `%s'.\n", datafile, LOCKFILE);
      return(-1);
    }
  }

  if ((fd = fopen(LOCKFILE, "w")) == NULL) {
    fprintf(stderr, "%s: Cannot create lock file: ", datafile);
    perror(LOCKFILE);
    return(-1);
  }

  fclose(fd);

  return(0);
}

dtfileunlock()
{
  if (!dtfileislocked()) {
    fprintf(stderr, "%s: Cannot remove lock: File is not locked.\n", 
	    datafile);
    return(-1);
  }

  if (unlink(LOCKFILE) < 0) {
    fprintf(stderr, "%s: Cannot remove lock: ", LOCKFILE);
    perror();
    return(-1);
  }

  return(0);
}
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦bedcf3a5f⟧ TextFile

Derivation

TextFile
