usr/src/lib/libc/port/gen/lckpwdf.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1988 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 #include "lint.h"
  33 #include <sys/types.h>
  34 #include <stdio.h>
  35 #include <signal.h>
  36 #include <fcntl.h>
  37 #include <unistd.h>
  38 #include <shadow.h>
  39 #include <errno.h>
  40 #include <thread.h>
  41 #include "mtlib.h"
  42
  43 #define LOCKFILE        "/etc/.pwd.lock"
  44 #define S_WAITTIME      15
  45
  46 static struct flock flock =     {
  47                         0,      /* l_type */
  48                         0,      /* l_whence */
  49                         0,      /* l_start */
  50                         0,      /* l_len */
  51                         0,      /* l_sysid */
  52                         0       /* l_pid */
  53                         };
  54
  55 /*
  56  * lckpwdf() returns a 0 for a successful lock within W_WAITTIME
  57  * seconds and -1 otherwise.  We stand on our head to make it MT-safe.
  58  */
  59
  60 static pid_t lck_pid = 0;       /* process's pid at last lock */
  61 static thread_t lck_tid = 0;    /* thread that holds the lock */
  62 static int fildes = -1;
  63 static mutex_t lck_lock = DEFAULTMUTEX;
  64
  65 int
  66 lckpwdf(void)
  67 {
  68         int seconds = 0;
  69
  70         lmutex_lock(&lck_lock);
  71         for (;;) {
  72                 if (lck_pid != 0 && lck_pid != getpid()) {
  73                         /* somebody forked */
  74                         lck_pid = 0;
  75                         lck_tid = 0;
  76                 }
  77                 if (lck_tid == 0) {
  78                         if ((fildes = creat(LOCKFILE, 0600)) == -1)
  79                                 break;
  80                         flock.l_type = F_WRLCK;
  81                         if (fcntl(fildes, F_SETLK, &flock) != -1) {
  82                                 lck_pid = getpid();
  83                                 lck_tid = thr_self();
  84                                 lmutex_unlock(&lck_lock);
  85                                 return (0);
  86                         }
  87                         (void) close(fildes);
  88                         fildes = -1;
  89                 }
  90                 if (seconds++ >= S_WAITTIME) {
  91                         /*
  92                          * For compatibility with the past, pretend
  93                          * that we were interrupted by SIGALRM.
  94                          */
  95                         errno = EINTR;
  96                         break;
  97                 }
  98                 lmutex_unlock(&lck_lock);
  99                 (void) sleep(1);
 100                 lmutex_lock(&lck_lock);
 101         }
 102         lmutex_unlock(&lck_lock);
 103         return (-1);
 104 }
 105
 106 /*
 107  * ulckpwdf() returns 0 for a successful unlock and -1 otherwise
 108  */
 109 int
 110 ulckpwdf(void)
 111 {
 112         lmutex_lock(&lck_lock);
 113         if (lck_tid == thr_self() && fildes >= 0) {
 114                 flock.l_type = F_UNLCK;
 115                 (void) fcntl(fildes, F_SETLK, &flock);
 116                 (void) close(fildes);
 117                 fildes = -1;
 118                 lck_pid = 0;
 119                 lck_tid = 0;
 120                 lmutex_unlock(&lck_lock);
 121                 return (0);
 122         }
 123         lmutex_unlock(&lck_lock);
 124         return (-1);
 125 }