#include "cvs.h"
struct lock {
char *repository;
int have_lckdir;
};
static void remove_locks PROTO((void));
static int readers_exist PROTO((char *repository));
static int set_lock PROTO ((struct lock *lock, int will_wait));
static void clear_lock PROTO ((struct lock *lock));
static void set_lockers_name PROTO((struct stat *statp));
static int set_writelock_proc PROTO((Node * p, void *closure));
static int unlock_proc PROTO((Node * p, void *closure));
static int write_lock PROTO ((struct lock *lock));
static void lock_simple_remove PROTO ((struct lock *lock));
static void lock_wait PROTO((char *repository));
static void lock_obtained PROTO((char *repository));
static char *lockers_name;
static char *readlock;
static char *writelock;
static char *masterlock;
static List *locklist;
#define L_OK 0
#define L_ERROR 1
#define L_LOCKED 2
static struct lock global_readlock;
static List *lock_tree_list;
static char *locked_dir;
static List *locked_list;
void
Lock_Cleanup ()
{
remove_locks ();
dellist (&lock_tree_list);
if (locked_dir != NULL)
{
dellist (&locked_list);
free (locked_dir);
locked_dir = NULL;
locked_list = NULL;
}
}
static void
remove_locks ()
{
if (global_readlock.repository != NULL)
{
lock_simple_remove (&global_readlock);
global_readlock.repository = NULL;
}
if (locklist != (List *) NULL)
{
(void) walklist (locklist, unlock_proc, NULL);
locklist = (List *) NULL;
}
}
static int
unlock_proc (p, closure)
Node *p;
void *closure;
{
lock_simple_remove ((struct lock *)p->data);
return (0);
}
static void
lock_simple_remove (lock)
struct lock *lock;
{
char *tmp;
if (readlock != NULL)
{
tmp = xmalloc (strlen (lock->repository) + strlen (readlock) + 10);
(void) sprintf (tmp, "%s/%s", lock->repository, readlock);
if ( CVS_UNLINK (tmp) < 0 && ! existence_error (errno))
error (0, errno, "failed to remove lock %s", tmp);
free (tmp);
}
if (writelock != NULL)
{
tmp = xmalloc (strlen (lock->repository) + strlen (writelock) + 10);
(void) sprintf (tmp, "%s/%s", lock->repository, writelock);
if ( CVS_UNLINK (tmp) < 0 && ! existence_error (errno))
error (0, errno, "failed to remove lock %s", tmp);
free (tmp);
}
if (lock->have_lckdir)
{
tmp = xmalloc (strlen (lock->repository) + sizeof (CVSLCK) + 10);
(void) sprintf (tmp, "%s/%s", lock->repository, CVSLCK);
SIG_beginCrSect ();
if (CVS_RMDIR (tmp) < 0)
error (0, errno, "failed to remove lock dir %s", tmp);
lock->have_lckdir = 0;
SIG_endCrSect ();
free (tmp);
}
}
int
Reader_Lock (xrepository)
char *xrepository;
{
int err = 0;
FILE *fp;
char *tmp;
if (noexec)
return (0);
if (global_readlock.repository != NULL)
{
error (0, 0, "Reader_Lock called while read locks set - Help!");
return (1);
}
if (readlock == NULL)
{
readlock = xmalloc (strlen (hostname) + sizeof (CVSRFL) + 40);
(void) sprintf (readlock,
#ifdef HAVE_LONG_FILE_NAMES
"%s.%s.%ld", CVSRFL, hostname,
#else
"%s.%ld", CVSRFL,
#endif
(long) getpid ());
}
global_readlock.repository = xrepository;
if (set_lock (&global_readlock, 1) != L_OK)
{
error (0, 0, "failed to obtain dir lock in repository `%s'",
xrepository);
if (readlock != NULL)
free (readlock);
readlock = NULL;
return (1);
}
tmp = xmalloc (strlen (xrepository) + strlen (readlock) + 10);
(void) sprintf (tmp, "%s/%s", xrepository, readlock);
if ((fp = CVS_FOPEN (tmp, "w+")) == NULL || fclose (fp) == EOF)
{
error (0, errno, "cannot create read lock in repository `%s'",
xrepository);
if (readlock != NULL)
free (readlock);
readlock = NULL;
err = 1;
}
free (tmp);
clear_lock (&global_readlock);
return (err);
}
static char *lock_error_repos;
static int lock_error;
static int Writer_Lock PROTO ((List * list));
static int
Writer_Lock (list)
List *list;
{
char *wait_repos;
if (noexec)
return (0);
if (locklist != (List *) NULL)
{
error (0, 0, "Writer_Lock called while write locks set - Help!");
return (1);
}
wait_repos = NULL;
for (;;)
{
lock_error = L_OK;
lock_error_repos = (char *) NULL;
locklist = list;
if (lockers_name != NULL)
free (lockers_name);
lockers_name = xstrdup ("unknown");
(void) walklist (list, set_writelock_proc, NULL);
switch (lock_error)
{
case L_ERROR:
if (wait_repos != NULL)
free (wait_repos);
Lock_Cleanup ();
error (0, 0, "lock failed - giving up");
return (1);
case L_LOCKED:
remove_locks ();
lock_wait (lock_error_repos);
wait_repos = xstrdup (lock_error_repos);
continue;
case L_OK:
if (wait_repos != NULL)
{
lock_obtained (wait_repos);
free (wait_repos);
}
return (0);
default:
if (wait_repos != NULL)
free (wait_repos);
error (0, 0, "unknown lock status %d in Writer_Lock",
lock_error);
return (1);
}
}
}
static int
set_writelock_proc (p, closure)
Node *p;
void *closure;
{
if (lock_error != L_OK)
return (0);
lock_error_repos = p->key;
lock_error = write_lock ((struct lock *)p->data);
return (0);
}
static int
write_lock (lock)
struct lock *lock;
{
int status;
FILE *fp;
char *tmp;
if (writelock == NULL)
{
writelock = xmalloc (strlen (hostname) + sizeof (CVSWFL) + 40);
(void) sprintf (writelock,
#ifdef HAVE_LONG_FILE_NAMES
"%s.%s.%ld", CVSWFL, hostname,
#else
"%s.%ld", CVSWFL,
#endif
(long) getpid());
}
status = set_lock (lock, 0);
if (status == L_OK)
{
if (readers_exist (lock->repository))
{
if (status == L_OK)
{
clear_lock (lock);
}
return (L_LOCKED);
}
tmp = xmalloc (strlen (lock->repository) + strlen (writelock) + 10);
(void) sprintf (tmp, "%s/%s", lock->repository, writelock);
if ((fp = CVS_FOPEN (tmp, "w+")) == NULL || fclose (fp) == EOF)
{
int xerrno = errno;
if ( CVS_UNLINK (tmp) < 0 && ! existence_error (errno))
error (0, errno, "failed to remove lock %s", tmp);
if (status == L_OK)
{
clear_lock (lock);
}
error (0, xerrno, "cannot create write lock in repository `%s'",
lock->repository);
free (tmp);
return (L_ERROR);
}
free (tmp);
return (L_OK);
}
else
return (status);
}
static int
readers_exist (repository)
char *repository;
{
char *line;
DIR *dirp;
struct dirent *dp;
struct stat sb;
int ret = 0;
#ifdef CVS_FUDGELOCKS
again:
#endif
if ((dirp = CVS_OPENDIR (repository)) == NULL)
error (1, 0, "cannot open directory %s", repository);
errno = 0;
while ((dp = readdir (dirp)) != NULL)
{
if (CVS_FNMATCH (CVSRFLPAT, dp->d_name, 0) == 0)
{
#ifdef CVS_FUDGELOCKS
time_t now;
(void) time (&now);
#endif
line = xmalloc (strlen (repository) + strlen (dp->d_name) + 5);
(void) sprintf (line, "%s/%s", repository, dp->d_name);
if ( CVS_STAT (line, &sb) != -1)
{
#ifdef CVS_FUDGELOCKS
if (now >= (sb.st_ctime + CVSLCKAGE) && CVS_UNLINK (line) != -1)
{
(void) closedir (dirp);
free (line);
goto again;
}
#endif
set_lockers_name (&sb);
}
else
{
if (!existence_error (errno))
error (0, errno, "cannot stat %s", line);
}
errno = 0;
free (line);
ret = 1;
break;
}
errno = 0;
}
if (errno != 0)
error (0, errno, "error reading directory %s", repository);
closedir (dirp);
return (ret);
}
static void
set_lockers_name (statp)
struct stat *statp;
{
struct passwd *pw;
if (lockers_name != NULL)
free (lockers_name);
if ((pw = (struct passwd *) getpwuid (statp->st_uid)) !=
(struct passwd *) NULL)
{
lockers_name = xstrdup (pw->pw_name);
}
else
{
lockers_name = xmalloc (20);
(void) sprintf (lockers_name, "uid%lu", (unsigned long) statp->st_uid);
}
}
static int
set_lock (lock, will_wait)
struct lock *lock;
int will_wait;
{
int waited;
struct stat sb;
mode_t omask;
#ifdef CVS_FUDGELOCKS
time_t now;
#endif
if (masterlock != NULL)
free (masterlock);
masterlock = xmalloc (strlen (lock->repository) + sizeof (CVSLCK) + 10);
(void) sprintf (masterlock, "%s/%s", lock->repository, CVSLCK);
waited = 0;
lock->have_lckdir = 0;
for (;;)
{
int status = -1;
omask = umask (cvsumask);
SIG_beginCrSect ();
if (CVS_MKDIR (masterlock, 0777) == 0)
{
lock->have_lckdir = 1;
SIG_endCrSect ();
status = L_OK;
if (waited)
lock_obtained (lock->repository);
goto out;
}
SIG_endCrSect ();
out:
(void) umask (omask);
if (status != -1)
return status;
if (errno != EEXIST)
{
error (0, errno,
"failed to create lock directory in repository `%s'",
lock->repository);
return (L_ERROR);
}
if (CVS_STAT (masterlock, &sb) < 0)
{
if (existence_error (errno))
continue;
error (0, errno, "couldn't stat lock directory `%s'", masterlock);
return (L_ERROR);
}
#ifdef CVS_FUDGELOCKS
(void) time (&now);
if (now >= (sb.st_ctime + CVSLCKAGE))
{
if (CVS_RMDIR (masterlock) >= 0)
continue;
}
#endif
set_lockers_name (&sb);
if (!will_wait)
return (L_LOCKED);
lock_wait (lock->repository);
waited = 1;
}
}
static void
clear_lock (lock)
struct lock *lock;
{
SIG_beginCrSect ();
if (CVS_RMDIR (masterlock) < 0)
error (0, errno, "failed to remove lock dir `%s'", masterlock);
lock->have_lckdir = 0;
SIG_endCrSect ();
}
static void
lock_wait (repos)
char *repos;
{
time_t now;
(void) time (&now);
error (0, 0, "[%8.8s] waiting for %s's lock in %s", ctime (&now) + 11,
lockers_name, repos);
cvs_flusherr ();
(void) sleep (CVSLCKSLEEP);
}
static void
lock_obtained (repos)
char *repos;
{
time_t now;
(void) time (&now);
error (0, 0, "[%8.8s] obtained lock in %s", ctime (&now) + 11, repos);
cvs_flusherr ();
}
static int lock_filesdoneproc PROTO ((void *callerdat, int err,
char *repository, char *update_dir,
List *entries));
static int
lock_filesdoneproc (callerdat, err, repository, update_dir, entries)
void *callerdat;
int err;
char *repository;
char *update_dir;
List *entries;
{
Node *p;
p = getnode ();
p->type = LOCK;
p->key = xstrdup (repository);
p->data = xmalloc (sizeof (struct lock));
((struct lock *)p->data)->repository = p->key;
((struct lock *)p->data)->have_lckdir = 0;
if (p->key == NULL || addnode (lock_tree_list, p) != 0)
freenode (p);
return (err);
}
void
lock_tree_for_write (argc, argv, local, aflag)
int argc;
char **argv;
int local;
int aflag;
{
int err;
lock_tree_list = getlist ();
err = start_recursion ((FILEPROC) NULL, lock_filesdoneproc,
(DIRENTPROC) NULL, (DIRLEAVEPROC) NULL, NULL, argc,
argv, local, W_LOCAL, aflag, 0, (char *) NULL, 0);
sortlist (lock_tree_list, fsortcmp);
if (Writer_Lock (lock_tree_list) != 0)
error (1, 0, "lock failed - giving up");
}
void
lock_dir_for_write (repository)
char *repository;
{
if (repository != NULL
&& (locked_dir == NULL
|| strcmp (locked_dir, repository) != 0))
{
Node *node;
if (locked_dir != NULL)
Lock_Cleanup ();
locked_dir = xstrdup (repository);
locked_list = getlist ();
node = getnode ();
node->type = LOCK;
node->key = xstrdup (repository);
node->data = xmalloc (sizeof (struct lock));
((struct lock *)node->data)->repository = node->key;
((struct lock *)node->data)->have_lckdir = 0;
(void) addnode (locked_list, node);
Writer_Lock (locked_list);
}
}