usr/src/lib/libdscfg/common/cfg_lockdmsg.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  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <signal.h>
  27 #include <sys/types.h>
  28 #include <sys/time.h>
  29 #include <sys/socket.h>
  30 #include <netinet/in.h>
  31 #include <netinet/tcp.h>
  32 #include <netdb.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36 #include <stdlib.h>
  37 #include <errno.h>
  38
  39 #include "cfg_lockd.h"
  40
  41 static daemonaddr_t     clientaddr;
  42 static daemonaddr_t     server;
  43
  44 static unsigned short   server_port = CFG_SERVER_PORT;
  45 static int      lock_soc = 0;
  46 static int      pf_inet = AF_INET;
  47 static int      locked;
  48 static int      initdone;
  49 static int      initresult;
  50 static pid_t    socket_pid;
  51
  52 static void     cfg_lockd_reinit();
  53
  54 static int last_cmd = -1;
  55 static uint8_t seq = 0;
  56
  57 static void
  58 send_cmd(int cmd)
  59 {
  60         struct lock_msg message_buf;
  61         int rc;
  62
  63         if (last_cmd == cmd) {
  64                 message_buf.seq = seq;
  65         } else {
  66                 message_buf.seq = ++seq;
  67                 last_cmd = cmd;
  68         }
  69         message_buf.message = cmd;
  70         if ((message_buf.pid = getpid()) != socket_pid)
  71                 cfg_lockd_reinit();
  72
  73         do {
  74                 rc = sendto(lock_soc, &message_buf, sizeof (message_buf), 0,
  75                         (struct sockaddr *)&server, sizeof (server));
  76         } while (rc == -1 && errno == EINTR);
  77 #ifdef CFG_LOCKD_DEBUG
  78         if (rc < 0) {
  79                 perror("send");
  80         }
  81 #endif
  82 }
  83
  84 static void
  85 read_msg(struct lock_msg *mp)
  86 {
  87         struct sockaddr from;
  88         int rc, len;
  89
  90         /* wait for response */
  91         do {
  92                 struct pollfd fds;
  93
  94                 fds.fd = lock_soc;
  95                 fds.events = POLLIN;
  96                 fds.revents = 0;
  97
  98                 rc = poll(&fds, 1, 500);
  99                 if (!rc) {
 100 #ifdef CFG_LOCKD_DEBUG
 101                         fprintf(stderr, "LOCKD: resending last command (%d)\n",
 102                             last_cmd);
 103 #endif
 104                         send_cmd(last_cmd);
 105                 }
 106         } while (rc == 0 ||
 107                 (rc == -1 && errno == EINTR));
 108
 109         do {
 110                 len = sizeof (from);
 111                 rc = recvfrom(lock_soc, mp, sizeof (*mp), 0,
 112                         &from, &len);
 113         } while (rc == -1 && errno == EINTR);
 114 #ifdef CFG_LOCKD_DEBUG
 115         if (rc < 0) {
 116                 perror("revcfrom");
 117         }
 118 #endif
 119 }
 120
 121 static void
 122 read_reply()
 123 {
 124         struct lock_msg message_buf;
 125
 126         do {
 127                 read_msg(&message_buf);
 128         } while (message_buf.seq != seq || message_buf.message != LOCK_LOCKED);
 129 }
 130
 131 static void
 132 read_ack()
 133 {
 134         struct lock_msg message_buf;
 135
 136         do {
 137                 read_msg(&message_buf);
 138         } while (message_buf.seq != seq || message_buf.message != LOCK_ACK);
 139 }
 140
 141 void
 142 cfg_lockd_rdlock()
 143 {
 144 #ifdef CFG_LOCKD_DEBUG
 145         FILE *fp;
 146 #endif
 147
 148         send_cmd(LOCK_READ);
 149         locked = 1;
 150         read_reply();
 151
 152 #ifdef CFG_LOCKD_DEBUG
 153         fp = fopen("/tmp/locktag", "a");
 154         if (fp) {
 155                 time_t t = time(0);
 156                 fprintf(fp, "%19.19s read  lock acquired\n", ctime(&t));
 157                 fclose(fp);
 158         }
 159         sleep(3);
 160 #endif
 161 }
 162
 163 void
 164 cfg_lockd_wrlock()
 165 {
 166 #ifdef CFG_LOCKD_DEBUG
 167         FILE *fp;
 168 #endif
 169
 170         send_cmd(LOCK_WRITE);
 171         locked = 1;
 172         read_reply();
 173
 174 #ifdef CFG_LOCKD_DEBUG
 175         fp = fopen("/tmp/locktag", "a");
 176         if (fp) {
 177                 time_t t = time(0);
 178                 fprintf(fp, "%19.19s write lock acquired\n", ctime(&t));
 179                 fclose(fp);
 180         }
 181         sleep(3);
 182 #endif
 183 }
 184
 185 void
 186 cfg_lockd_unlock()
 187 {
 188 #ifdef CFG_LOCKD_DEBUG
 189         FILE *fp;
 190 #endif
 191
 192         send_cmd(LOCK_NOTLOCKED);
 193         read_ack();
 194         locked = 0;
 195
 196 #ifdef CFG_LOCKD_DEBUG
 197         fp = fopen("/tmp/locktag", "a");
 198         if (fp) {
 199                 time_t t = time(0);
 200                 fprintf(fp, "%19.19s ----- lock released\n", ctime(&t));
 201                 fclose(fp);
 202         }
 203         sleep(3);
 204 #endif
 205 }
 206
 207 void
 208 cfg_lockd_stat()
 209 {
 210         send_cmd(LOCK_STAT);
 211 }
 212
 213 cfglockd_t
 214 cfg_lockedby(pid_t *pidp)
 215 {
 216         struct lock_msg message_buf;
 217         send_cmd(LOCK_LOCKEDBY);
 218         read_msg(&message_buf);
 219         *pidp = message_buf.pid;
 220         return ((cfglockd_t)message_buf.message);
 221 }
 222
 223 static void
 224 cfg_atexit()
 225 {
 226         if (locked)
 227                 cfg_lockd_unlock();
 228 }
 229
 230 static int
 231 cfg_lockd_socket()
 232 {
 233         if ((lock_soc = socket(pf_inet, SOCK_DGRAM, 0)) < 0) {
 234 #ifdef CFG_LOCKD_DEBUG
 235                 fprintf(stderr, "libcfg: failed to create socket\n");
 236                 perror("socket");
 237 #endif
 238                 return (-1);
 239         }
 240         clientaddr.sin_family = AF_INET;
 241         clientaddr.sin_addr.s_addr = INADDR_ANY;
 242         clientaddr.sin_port = htons(0);
 243         if (bind(lock_soc, (struct sockaddr *)&clientaddr,
 244             sizeof (clientaddr)) < 0) {
 245 #ifdef CFG_LOCKD_DEBUG
 246                 perror("bind");
 247 #endif
 248                 return (-1);
 249         }
 250         socket_pid = getpid();
 251         return (0);
 252 }
 253
 254 /*
 255  * Re-initialise after a fork has been detected.
 256  *
 257  * Needs to create a new socket for new process to receive messages
 258  * from the lock daemon and enter pid into lock file so that the daemon
 259  * can detect new processes exit if it doesn't call unlock first.
 260  */
 261
 262 static void
 263 cfg_lockd_reinit()
 264 {
 265         if (lock_soc)
 266                 close(lock_soc);
 267         lock_soc = 0;
 268         if (cfg_lockd_socket()) {
 269                 initresult = 0;
 270                 return;
 271         }
 272         cfg_enterpid();
 273         initresult = 1;
 274 }
 275
 276 int
 277 cfg_lockd_init()
 278 {
 279         struct  hostent *hp;
 280         FILE    *fp;
 281         int     pid = 0x12345678;
 282
 283         if (initdone) {
 284                 /* only perform reinit if init worked first time */
 285                 if (getpid() != socket_pid && initresult != 0)
 286                         cfg_lockd_reinit();
 287                 return (initresult);
 288         }
 289
 290         initdone = 1;
 291         initresult = 0;
 292
 293         /* check if there's a lock daemon out there */
 294         if ((fp = fopen(CFG_PIDFILE, "r")) == NULL)
 295                 return (0);
 296         if (fscanf(fp, "%d\n", &pid) != 1) {
 297                 fclose(fp);
 298                 return (0);
 299         }
 300         fclose(fp);
 301         if (kill((pid_t)pid, 0) != 0)
 302                 return (0);
 303
 304         /* there is a lock daemon */
 305         cfg_lfinit();
 306         cfg_enterpid();
 307         if (cfg_lockd_socket())
 308                 return (0);
 309
 310         if ((hp = gethostbyname("localhost")) == NULL) {
 311 #ifdef CFG_LOCKD_DEBUG
 312                 fprintf(stderr, "Can't find hostent for %s\n", "localhost");
 313 #endif
 314                 return (0);
 315         }
 316         (void) memcpy(&(server.sin_addr.s_addr), *(hp->h_addr_list),
 317                                 sizeof (server.sin_addr));
 318         server.sin_port = htons(server_port);
 319         server.sin_family = hp->h_addrtype;
 320         endhostent();
 321         atexit(cfg_atexit);
 322         initresult = 1;
 323         return (1);
 324 }