commands/ci/ci.c
/* ci - check in 			Author: Peter S. Housel 12/17/87 */

#include <sys/types.h>
#include <string.h>
#include <sys/stat.h>
#include <pwd.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <stdio.h>

#define SUFFIX		",S"	/* svc indicator */
#define SVCDIR		"SVC"	/* svc postfix indicator */

#define LINELEN		256	/* maximum line length */

#ifndef PATCH
#define FIX		"fix $1 Fix.$1 > New.$1; mv New.$1 $1\n"
#else
#define FIX		"patch -n -s $1 < Fix.$1; rm -f $1.orig\n"
#endif /* !PATCH */

#ifdef MAXPATHLEN
#define PATHLEN MAXPATHLEN
#else
#define PATHLEN 128		/* buffer length for filenames */
#endif

int unlocked = 0;		/* leave unlocked after checkin */
int relock = 0;			/* lock next revision after checkin */
char file[PATHLEN];		/* file to be checked in */
char svc[PATHLEN];		/* filename for svc file */
char newsvc[PATHLEN];		/* new copy of SVC file */
char line[LINELEN];		/* temporary line buffer */
char *p;			/* scratch character pointer */

FILE *svcfp;			/* svc file */
FILE *origfp, *newfp;		/* "orig" and "new" temp files */
FILE *srcfp;			/* source file */
int rev;			/* new revision number */
int status;			/* wait() buffer */
struct stat stb1, stb2;		/* stat buffers for size compare */
char original[] = "/tmp/cioXXXXXX";	/* previous revision */
char diffout[] = "/tmp/cidXXXXXX";	/* diffs */

int main(int argc, char **argv);
void rundiff(void);
void logmsg(FILE *fp);
void fname(char *src, char *dst);
void svcname(char *src, char *dst);
int lockcheck(FILE *fp, int rev);
void onintr(int dummy);
void clean(void);
char *whoami(void);

int main(argc, argv)
int argc;
char **argv;
{
#ifdef perprintf
  char errbuf[BUFSIZ];
  setbuf(stderr, errbuf);
  perprintf(stderr);
#endif

  while (++argv, --argc) {
	if ('-' == (*argv)[0]) {
		if ('u' == (*argv)[1])
			++unlocked;
		else if ('l' == (*argv)[1])
			++relock;
		else {
			fprintf(stderr, "ci: illegal option -%c\n", (*argv)[1]);
			exit(1);
		}
	} else
		break;
  }

  if (1 != argc) {
	fprintf(stderr, "ci: bad number of files arguments\n");
	exit(1);
  }
  fname(*argv, file);
  svcname(file, svc);

  fprintf(stderr, "%s -> %s\n", file, svc);

  signal(SIGHUP, onintr);
  signal(SIGINT, onintr);
  signal(SIGTERM, onintr);

#ifndef BSD
  if (NULL == (p = strrchr(file, '/')))
	p = file;
  else
	++p;

  if (strlen(p) > 13) {
	fprintf(stderr, "ci: filename %s is too long\n", p);
	exit(1);
  }
#endif /* !BSD */

  strcpy(newsvc, svc);
  *(strrchr(newsvc, ',')) = ';';	/* temporary file will be "file;S" */

  if (NULL == (newfp = fopen(newsvc, "w"))) {
	perror("ci: can't create SVC temporary");
	exit(1);
  }
  (void) mktemp(original);
  (void) mktemp(diffout);

  if (NULL != (svcfp = fopen(svc, "r"))) {	/* does svc-file exist? */
	fgets(line, LINELEN, svcfp);
	if (1 != sscanf(line, "# %d", &rev)) {
		fprintf(stderr, "ci: %s: illegal SVC file header\n", svc);
		exit(1);
	}
	++rev;

	if (!lockcheck(svcfp, rev)) {
		fprintf(stderr, "Revision %d not locked\n", rev);
		clean();
		exit(1);
	}
	if (NULL == (origfp = fopen(original, "w"))) {
		fprintf(stderr, "ci: can't create %s", original);
		perror(" ");
	}
	fgets(line, LINELEN, svcfp);	/* skip "cat <<***MAIN-eof***" line */

	while (NULL != fgets(line, LINELEN, svcfp)
	       && strcmp(line, "***MAIN-eof***\n")) {
		fputs(line, origfp);
		if (ferror(origfp)) {
			perror("ci: origfile");
			exit(1);
		}
	}
	fclose(origfp);

	rundiff();

	if (0 != stat(original, &stb1) || 0 != stat(diffout, &stb2)) {
		perror("ci: can't stat original or diffout");
		clean();
		exit(1);
	}
  } else {			/* no - create one */
	rev = 1;
  }

  fprintf(newfp, "# %d\n", rev);
  fprintf(newfp, "cat <<***MAIN-eof*** >$1\n");
  if (NULL == (srcfp = fopen(file, "r"))) {
	perror("ci: can't read source file");
	clean();
	exit(1);
  }
  while (NULL != fgets(line, LINELEN, srcfp)) fputs(line, newfp);
  fclose(srcfp);
  fputs("***MAIN-eof***\n", newfp);

  if (rev > 1) {
	fprintf(newfp, "if test $2 -ge %d ; then rm -f Fix.$1 ; exit 0 ; fi ; cat <<***%d-eof*** >Fix.$1\n", rev, rev);
	p = (stb1.st_size <= stb2.st_size) ? original : diffout;
	if (NULL == (origfp = fopen(p, "r"))) {
		perror("can't open diff output file");
		clean();
		exit(1);
	}
	while (NULL != fgets(line, LINELEN, origfp)) fputs(line, newfp);
	fclose(origfp);
	fprintf(newfp, "***%d-eof***\n", rev);
	fputs((original == p) ? "mv Fix.$1 $1\n" : FIX, newfp);
	logmsg(newfp);
	while (NULL != fgets(line, LINELEN, svcfp) && strncmp(line, "#***SVCLOCK***", (size_t)14))
		fputs(line, newfp);
  } else {
	logmsg(newfp);
	fputs("rm -f Fix.$1\n", newfp);
  }

  if (relock) {
	fprintf(stderr, "(relocking into revision %d)\n", rev + 1);
	fprintf(newfp, "#***SVCLOCK*** %s %d\n", whoami(), rev + 1);
  }
  signal(SIGHUP, SIG_IGN);	/* disable during critical section */
  signal(SIGINT, SIG_IGN);

  if (ferror(newfp) || fclose(newfp) || ((rev > 1) && unlink(svc))
      || link(newsvc, svc)) {
	fprintf(stderr, "SVC file write/link error - Checkin aborted\n");
	clean();
	exit(1);
  } else
	fprintf(stderr, "Checkin complete.\n");

  if (stat(svc, &stb1) < 0 || chmod(svc, stb1.st_mode & 0555) < 0)
	perror("ci: can't chmod SVC file");

  if (unlocked) {
	if (stat(file, &stb1) < 0 || chmod(file, stb1.st_mode & 0555) < 0)
		perror("ci: can't chmod source file");
  } else if (relock) {
	if (stat(file, &stb1) < 0 || chmod(file, stb1.st_mode | 0200) < 0)
		perror("ci: can't chmod source file");
  } else
	unlink(file);

  clean();
  return(0);
}

void rundiff()
{				/* do "diff file original > diffout" */
  int fd;			/* redirected output file */

  switch (fork()) {
      case -1:
	perror("ci: fork");	/* error */
	clean();
	exit(1);

      case 0:			/* child */
	if ((fd = creat(diffout, 0600)) < 0 || -1 == dup2(fd, 1)) {
		perror("ci: diffout");
		clean();
		exit(1);
	}
	close(fd);
	execlp("diff", "diff", file, original, (char *) 0);
	perror("ci: exec diff failed");
	exit(1);

      default:	break;		/* parent */
}
  wait(&status);
  if (0 != status && 1 << 8 != status) {
	fprintf(stderr, "ci: bad return status (0x%x) from diff\n", status);
	clean();
	exit(1);
  }
}

void logmsg(fp)
FILE *fp;
{
  long now;

  time(&now);
  fprintf(stderr, "Enter log message for revision %d (end with ^D or '.'):\n", rev);
  fprintf(fp, "#***SVC*** revision %d %s %s", rev, file, ctime(&now));
  while (NULL != gets(line) && strcmp(line, "."))
	fprintf(fp, "#***SVC*** %s\n", line);
}

void fname(src, dst)
char *src, *dst;
{
  char *p;
  strcpy(dst, src);
  p = &dst[strlen(src) - strlen(SUFFIX)];
  if (!strcmp(p, SUFFIX)) *p = '\0';
}

void svcname(src, dst)
char *src, *dst;
{
  char *p;

  strcpy(dst, src);
  strcat(dst, SUFFIX);

  if (0 != access(dst, 4)) {
	char dirname[PATHLEN];
	if (NULL != (p = strrchr(src, '/')))
		strncpy(dirname, src, (size_t)(p - src + 1));
	else
		dirname[0] = '\0';
	strcat(dirname, SVCDIR);

	if (0 == access(dirname, 1)) {
		strcpy(dst, dirname);
		if (NULL == p) {
			strcat(dst, "/");
			strcat(dst, src);
		} else
			strcat(dst, p);
		strcat(dst, SUFFIX);
	}
  }
}

int lockcheck(fp, rev)
FILE *fp;
int rev;
{
  char lock[40], check[40];
  long pos;
  int ret;

  sprintf(lock, "#***SVCLOCK*** %s %d\n", whoami(), rev);

  pos = ftell(fp);
  fseek(fp, -((long) strlen(lock)), 2);
  fgets(check, 40, fp);
  ret = (0 == strcmp(lock, check));
  fseek(fp, pos, 0);

  return ret;
}

void onintr(dummy)
int dummy; /* to keep the compiler happy */
{
  fprintf(stderr, "Interrupt - Aborting checkin, cleaning up\n");
  clean();
  exit(1);
}

void clean()
{
  if (strlen(original))		/* if only more programs made this check! */
	unlink(original);
  if (strlen(diffout)) unlink(diffout);
  if (strlen(newsvc)) unlink(newsvc);
}

char *whoami()
{
  struct passwd *pw;

  if (NULL != (pw = getpwuid(getuid())))
	return pw->pw_name;
  else
	return "nobody";
}
