*/
#ifndef lint
-static char rcsid[] = "$Id: sys-svr4.c,v 1.3 1995/06/23 01:54:11 paulus Exp $";
+static char rcsid[] = "$Id: sys-svr4.c,v 1.9 1996/01/01 23:06:39 paulus Exp $";
#endif
+#include <limits.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
+#include <alloca.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
+#ifndef CRTSCTS
+#include <sys/termiox.h>
+#endif
+#include <signal.h>
+#include <utmpx.h>
#include <sys/types.h>
#include <sys/ioccom.h>
#include <sys/stream.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/syslog.h>
+#include <sys/sysmacros.h>
#include <sys/systeminfo.h>
#include <sys/dlpi.h>
#include <sys/stat.h>
+#include <sys/mkdev.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <net/route.h>
static int restore_term;
static struct termios inittermios;
+#ifndef CRTSCTS
+static struct termiox inittermiox;
+#endif
+static struct winsize wsinfo; /* Initial window size info */
+static pid_t tty_sid; /* original session ID for terminal */
+
+extern u_char inpacket_buf[]; /* borrowed from main.c */
static int link_mtu, link_mru;
static int tty_nmodules;
static char tty_modules[NMODULES][FMNAMESZ+1];
+static int if_is_up; /* Interface has been marked up */
+static u_int32_t default_route_gateway; /* Gateway for default route added */
+static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
+
+/* Prototypes for procedures local to this file. */
+static int translate_speed __P((int));
+static int baud_rate_of __P((int));
+static int get_ether_addr __P((u_int32_t, struct sockaddr *));
+static int get_hw_addr __P((char *, struct sockaddr *));
+static int dlpi_attach __P((int, int));
+static int dlpi_info_req __P((int));
+static int dlpi_get_reply __P((int, union DL_primitives *, int, int));
+static int strioctl __P((int, int, void *, int, int));
+
/*
* sys_init - System-dependent initialization.
*/
void
sys_init()
{
+ int ifd, x;
+#ifndef sun
+ struct ifreq ifr;
+ struct {
+ union DL_primitives prim;
+ char space[64];
+ } reply;
+#endif
+
openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
setlogmask(LOG_UPTO(LOG_INFO));
if (debug)
syslog(LOG_ERR, "Couldn't open IP device: %m");
die(1);
}
+
+ if (default_device)
+ tty_sid = getsid((pid_t)0);
+
+ pppfd = open("/dev/ppp", O_RDWR | O_NONBLOCK, 0);
+ if (pppfd < 0) {
+ syslog(LOG_ERR, "Can't open /dev/ppp: %m");
+ die(1);
+ }
+ if (kdebugflag) {
+ x = PPPDBG_LOG + PPPDBG_DRIVER;
+ strioctl(pppfd, PPPIO_DEBUG, &x, sizeof(int), 0);
+ }
+
+ /* Assign a new PPA and get its unit number. */
+ if (strioctl(pppfd, PPPIO_NEWPPA, &ifunit, 0, sizeof(int)) < 0) {
+ syslog(LOG_ERR, "Can't create new PPP interface: %m");
+ die(1);
+ }
+
+ /*
+ * Open the ppp device again and link it under the ip multiplexor.
+ * IP will assign a unit number which hopefully is the same as ifunit.
+ * I don't know any way to be certain they will be the same. :-(
+ */
+ ifd = open("/dev/ppp", O_RDWR, 0);
+ if (ifd < 0) {
+ syslog(LOG_ERR, "Can't open /dev/ppp (2): %m");
+ die(1);
+ }
+ if (kdebugflag) {
+ x = PPPDBG_LOG + PPPDBG_DRIVER;
+ strioctl(ifd, PPPIO_DEBUG, &x, sizeof(int), 0);
+ }
+#ifdef sun
+ if (ioctl(ifd, I_PUSH, "ip") < 0) {
+ syslog(LOG_ERR, "Can't push IP module: %m");
+ close(ifd);
+ die(1);
+ }
+#else
+ if (dlpi_attach(ifd, ifunit) < 0 ||
+ dlpi_get_reply(ifd, &reply.prim, DL_OK_ACK, sizeof(reply)) < 0) {
+ syslog(LOG_ERR, "Can't attach to ppp%d: %m", ifunit);
+ close(ifd);
+ die(1);
+ }
+#endif
+ ipmuxid = ioctl(ipfd, I_LINK, ifd);
+ close(ifd);
+ if (ipmuxid < 0) {
+ syslog(LOG_ERR, "Can't link PPP device to IP: %m");
+ die(1);
+ }
+
+#ifndef sun
+ /* Set the interface name for the link. */
+ (void) sprintf (ifr.ifr_name, "ppp%d", ifunit);
+ ifr.ifr_metric = ipmuxid;
+ if (strioctl(ipfd, SIOCSIFNAME, (char *)&ifr, sizeof ifr, 0) < 0) {
+ syslog(LOG_ERR, "Can't set interface name %s: %m", ifr.ifr_name);
+ die(1);
+ }
+#endif
}
+/*
+ * sys_cleanup - restore any system state we modified before exiting:
+ * mark the interface down, delete default route and/or proxy arp entry.
+ * This should call die() because it's called from die().
+ */
+void
+sys_cleanup()
+{
+ struct ifreq ifr;
+
+ if (if_is_up)
+ sifdown(0);
+ if (default_route_gateway)
+ cifdefaultroute(0, default_route_gateway);
+ if (proxy_arp_addr)
+ cifproxyarp(0, proxy_arp_addr);
+}
+
+/*
+ * sys_close - Clean up in a child process before execing.
+ */
+void
+sys_close()
+{
+ close(ipfd);
+ if (pppfd >= 0)
+ close(pppfd);
+ closelog();
+}
+
+/*
+ * sys_check_options - check the options that the user specified
+ */
+void
+sys_check_options()
+{
+}
+
+
/*
* daemon - Detach us from controlling terminal session.
*/
note_debug_level()
{
if (debug) {
- syslog(LOG_INFO, "Debug turned ON, Level %d", debug);
setlogmask(LOG_UPTO(LOG_DEBUG));
} else {
setlogmask(LOG_UPTO(LOG_WARNING));
* establish_ppp - Turn the serial port into a ppp interface.
*/
void
-establish_ppp()
+establish_ppp(fd)
+ int fd;
{
- int i, ifd;
-
- pppfd = open("/dev/ppp", O_RDWR | O_NONBLOCK, 0);
- if (pppfd < 0) {
- syslog(LOG_ERR, "Can't open /dev/ppp: %m");
- die(1);
- }
-
- /* Assign a new PPA and get its unit number. */
- if (strioctl(pppfd, PPPIO_NEWPPA, &ifunit, 0, sizeof(int)) < 0) {
- syslog(LOG_ERR, "Can't create new PPP interface: %m");
- die(1);
- }
-
- /*
- * Open the ppp device again and link it under the ip multiplexor.
- * IP will assign a unit number which hopefully is the same as ifunit.
- * I don't know any way to be certain they will be the same. :-(
- */
- ifd = open("/dev/ppp", O_RDWR, 0);
- if (ifd < 0) {
- syslog(LOG_ERR, "Can't open /dev/ppp (2): %m");
- die(1);
- }
- if (ioctl(ifd, I_PUSH, "ip") < 0) {
- syslog(LOG_ERR, "Can't push IP module: %m");
- close(ifd);
- die(1);
- }
- ipmuxid = ioctl(ipfd, I_LINK, ifd);
- close(ifd);
- if (ipmuxid < 0) {
- syslog(LOG_ERR, "Can't link PPP device to IP: %m");
- die(1);
- }
+ int i;
/* Pop any existing modules off the tty stream. */
for (i = 0;; ++i)
}
}
+/*
+ * restore_loop - reattach the ppp unit to the loopback.
+ * This doesn't need to do anything because disestablish_ppp does it.
+ */
+void
+restore_loop()
+{
+}
+
/*
* disestablish_ppp - Restore the serial port to normal operation.
- * This shouldn't call die() because it's called from die().
+ * It attempts to reconstruct the stream with the previously popped
+ * modules. This shouldn't call die() because it's called from die().
*/
void
-disestablish_ppp()
+disestablish_ppp(fd)
+ int fd;
{
int i;
syslog(LOG_ERR, "Couldn't restore tty module %s: %m",
tty_modules[i]);
}
+ if (hungup && default_device && tty_sid > 0) {
+ /*
+ * If we have received a hangup, we need to send a SIGHUP
+ * to the terminal's controlling process. The reason is
+ * that the original stream head for the terminal hasn't
+ * seen the M_HANGUP message (it went up through the ppp
+ * driver to the stream head for our fd to /dev/ppp).
+ */
+ kill(tty_sid, SIGHUP);
+ }
+ }
+}
+
+/*
+ * Check whether the link seems not to be 8-bit clean.
+ */
+void
+clean_check()
+{
+ int x;
+ char *s;
+
+ if (strioctl(pppfd, PPPIO_GCLEAN, &x, 0, sizeof(x)) < 0)
+ return;
+ s = NULL;
+ switch (~x) {
+ case RCV_B7_0:
+ s = "bit 7 set to 1";
+ break;
+ case RCV_B7_1:
+ s = "bit 7 set to 0";
+ break;
+ case RCV_EVNP:
+ s = "odd parity";
+ break;
+ case RCV_ODDP:
+ s = "even parity";
+ break;
+ }
+ if (s != NULL) {
+ syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
+ syslog(LOG_WARNING, "All received characters had %s", s);
}
}
/*
* Translate from bits/second to a speed_t.
*/
-int
+static int
translate_speed(bps)
int bps;
{
/*
* Translate from a speed_t to bits/second.
*/
-int
+static int
baud_rate_of(speed)
int speed;
{
* at the requested speed, etc. If `local' is true, set CLOCAL
* regardless of whether the modem option was specified.
*/
+void
set_up_tty(fd, local)
int fd, local;
{
int speed;
struct termios tios;
+#if !defined (CRTSCTS)
+ struct termiox tiox;
+#endif
if (tcgetattr(fd, &tios) < 0) {
syslog(LOG_ERR, "tcgetattr: %m");
die(1);
}
- if (!restore_term)
+#ifndef CRTSCTS
+ if (ioctl (fd, TCGETX, &tiox) < 0) {
+ syslog (LOG_ERR, "TCGETX: %m");
+ die (1);
+ }
+#endif
+
+ if (!restore_term) {
inittermios = tios;
+#ifndef CRTSCTS
+ inittermiox = tiox;
+#endif
+ ioctl(fd, TIOCGWINSZ, &wsinfo);
+ }
tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
+#ifdef CRTSCTS
if (crtscts > 0)
tios.c_cflag |= CRTSCTS;
else if (crtscts < 0)
tios.c_cflag &= ~CRTSCTS;
+#else
+ if (crtscts > 0) {
+ tiox.x_hflag |= RTSXOFF|CTSXON;
+ }
+ else if (crtscts < 0) {
+ tiox.x_hflag &= ~(RTSXOFF|CTSXON);
+ }
+#endif
tios.c_cflag |= CS8 | CREAD | HUPCL;
if (local || !modem)
tios.c_cc[VMIN] = 1;
tios.c_cc[VTIME] = 0;
- if (crtscts == 2) {
- tios.c_iflag |= IXOFF;
+ if (crtscts == -2) {
+ tios.c_iflag |= IXON | IXOFF;
tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
}
die(1);
}
+#ifndef CRTSCTS
+ if (ioctl (fd, TCSETXF, &tiox) < 0){
+ syslog (LOG_ERR, "TCSETXF: %m");
+ die (1);
+ }
+#endif
+
baud_rate = inspeed = baud_rate_of(speed);
restore_term = 1;
}
* restore_tty - restore the terminal to the saved settings.
*/
void
-restore_tty()
+restore_tty(fd)
+ int fd;
{
if (restore_term) {
if (!default_device) {
if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
if (!hungup && errno != ENXIO)
syslog(LOG_WARNING, "tcsetattr: %m");
+#ifndef CRTSCTS
+ if (ioctl (fd, TCSETXF, &inittermiox) < 0){
+ if (!hungup && errno != ENXIO)
+ syslog (LOG_ERR, "TCSETXF: %m");
+ }
+#endif
+ ioctl(fd, TIOCSWINSZ, &wsinfo);
restore_term = 0;
}
}
* setdtr - control the DTR line on the serial port.
* This is called from die(), so it shouldn't call die().
*/
+void
setdtr(fd, on)
int fd, on;
{
ioctl(fd, (on? TIOCMBIS: TIOCMBIC), &modembits);
}
+/*
+ * open_loopback - open the device we use for getting packets
+ * in demand mode. Under Solaris 2, we use our existing fd
+ * to the ppp driver.
+ */
+void
+open_ppp_loopback()
+{
+}
+
/*
* output - Output PPP packet.
*/
int len;
{
struct strbuf data;
+ int retries;
+ struct pollfd pfd;
if (debug)
log_packet(p, len, "sent ");
data.len = len;
data.buf = (caddr_t) p;
- if (putmsg(pppfd, NULL, &data, 0) < 0) {
- if (errno != ENXIO) {
- syslog(LOG_ERR, "Couldn't send packet: %m");
- die(1);
+ retries = 4;
+ while (putmsg(pppfd, NULL, &data, 0) < 0) {
+ if (--retries < 0 || (errno != EWOULDBLOCK && errno != EAGAIN)) {
+ if (errno != ENXIO)
+ syslog(LOG_ERR, "Couldn't send packet: %m");
+ break;
}
+ pfd.fd = pppfd;
+ pfd.events = POLLOUT;
+ poll(&pfd, 1, 250); /* wait for up to 0.25 seconds */
}
}
+
/*
* wait_input - wait until there is data available on fd,
* for the length of time specified by *timo (indefinite
* if timo is NULL).
*/
+void
wait_input(timo)
struct timeval *timo;
{
}
}
+/*
+ * wait_loop_output - wait until there is data available on the
+ * loopback, for the length of time specified by *timo (indefinite
+ * if timo is NULL).
+ */
+wait_loop_output(timo)
+ struct timeval *timo;
+{
+ wait_input(timo);
+}
+
+/*
+ * wait_time - wait for a given length of time or until a
+ * signal is received.
+ */
+wait_time(timo)
+ struct timeval *timo;
+{
+ int n;
+
+ n = select(0, NULL, NULL, NULL, timo);
+ if (n < 0 && errno != EINTR) {
+ syslog(LOG_ERR, "select: %m");
+ die(1);
+ }
+}
+
+
/*
* read_packet - get a PPP packet from the serial device.
*/
/*
* Got a M_PROTO or M_PCPROTO message. Interpret it
- * as a DLPI primitive.
+ * as a DLPI primitive??
*/
if (debug)
syslog(LOG_DEBUG, "got dlpi prim 0x%x, len=%d",
}
}
+/*
+ * get_loop_output - get outgoing packets from the ppp device,
+ * and detect when we want to bring the real link up.
+ * Return value is 1 if we need to bring up the link, 0 otherwise.
+ */
+int
+get_loop_output()
+{
+ int len;
+ int rv = 0;
+
+ while ((len = read_packet(inpacket_buf)) > 0) {
+ if (loop_frame(inpacket_buf, len))
+ rv = 1;
+ }
+ return rv;
+}
+
/*
* ppp_send_config - configure the transmit characteristics of
* the ppp interface.
* ccp_test - ask kernel whether a given compression method
* is acceptable for use.
*/
+int
ccp_test(unit, opt_ptr, opt_len, for_transmit)
int unit, opt_len, for_transmit;
u_char *opt_ptr;
{
- return strioctl(pppfd, (for_transmit? PPPIO_XCOMP: PPPIO_RCOMP),
- opt_ptr, opt_len, 0) >= 0;
+ if (strioctl(pppfd, (for_transmit? PPPIO_XCOMP: PPPIO_RCOMP),
+ opt_ptr, opt_len, 0) >= 0)
+ return 1;
+ return (errno == ENOSR)? 0: -1;
}
/*
}
}
+/*
+ * get_idle_time - return how long the link has been idle.
+ */
+int
+get_idle_time(u, ip)
+ int u;
+ struct ppp_idle *ip;
+{
+ return strioctl(pppfd, PPPIO_GIDLE, ip, 0, sizeof(struct ppp_idle)) >= 0;
+}
+
+
/*
* ccp_fatal_error - returns 1 if decompression was disabled as a
* result of an error detected after decompression of a packet,
syslog(LOG_ERR, "Couldn't mark interface up (set): %m");
return 0;
}
+ if_is_up = 1;
return 1;
}
syslog(LOG_ERR, "Couldn't mark interface down (set): %m");
return 0;
}
+ if_is_up = 0;
+ return 1;
+}
+
+/*
+ * sifnpmode - Set the mode for handling packets for a given NP.
+ */
+int
+sifnpmode(u, proto, mode)
+ int u;
+ int proto;
+ enum NPmode mode;
+{
+ int npi[2];
+
+ npi[0] = proto;
+ npi[1] = (int) mode;
+ if (strioctl(pppfd, PPPIO_NPMODE, &npi, 2 * sizeof(int), 0) < 0) {
+ syslog(LOG_ERR, "ioctl(set NP %d mode to %d): %m", proto, mode);
+ return 0;
+ }
return 1;
}
return 0;
}
+ default_route_gateway = g;
return 1;
}
return 0;
}
+ default_route_gateway = 0;
return 1;
}
return 0;
}
+ proxy_arp_addr = hisaddr;
return 1;
}
return 0;
}
+ proxy_arp_addr = 0;
return 1;
}
*/
#define MAX_IFS 32
-int
+static int
get_ether_addr(ipaddr, hwaddr)
u_int32_t ipaddr;
struct sockaddr *hwaddr;
/*
* Scan through the system's network interfaces.
*/
+#ifdef SIOCGIFNUM
if (ioctl(ipfd, SIOCGIFNUM, &nif) < 0)
+#endif
nif = MAX_IFS;
ifc.ifc_len = nif * sizeof(struct ifreq);
- ifc.ifc_req = alloca(ifc.ifc_len);
+ ifc.ifc_buf = (caddr_t) alloca(ifc.ifc_len);
if (ifc.ifc_req == 0)
return 0;
if (ioctl(ipfd, SIOCGIFCONF, &ifc) < 0) {
/*
* get_hw_addr - obtain the hardware address for a named interface.
*/
-int
+static int
get_hw_addr(name, hwaddr)
char *name;
struct sockaddr *hwaddr;
}
if (dlpi_attach(iffd, unit) < 0
|| dlpi_get_reply(iffd, &reply.prim, DL_OK_ACK, sizeof(reply)) < 0
- || dlpi_phys_addr_req(iffd) < 0
- || dlpi_get_reply(iffd, &reply.prim, DL_PHYS_ADDR_ACK,
- sizeof(reply)) < 0) {
+ || dlpi_info_req(iffd) < 0
+ || dlpi_get_reply(iffd, &reply.prim, DL_INFO_ACK, sizeof(reply)) < 0) {
close(iffd);
return 0;
}
+ adrlen = reply.prim.info_ack.dl_addr_length;
+ adrp = (unsigned char *)&reply + reply.prim.info_ack.dl_addr_offset;
+#if DL_CURRENT_VERSION >= 2
+ if (reply.prim.info_ack.dl_sap_length < 0)
+ adrlen += reply.prim.info_ack.dl_sap_length;
+ else
+ adrp += reply.prim.info_ack.dl_sap_length;
+#endif
hwaddr->sa_family = AF_UNSPEC;
- adrlen = reply.prim.physaddr_ack.dl_addr_length;
- adrp = (unsigned char *)&reply + reply.prim.physaddr_ack.dl_addr_offset;
memcpy(hwaddr->sa_data, adrp, adrlen);
return 1;
}
-int
+static int
dlpi_attach(fd, ppa)
int fd, ppa;
{
return putmsg(fd, &buf, NULL, RS_HIPRI);
}
-int
-dlpi_phys_addr_req(fd)
+static int
+dlpi_info_req(fd)
int fd;
{
- dl_phys_addr_req_t req;
+ dl_info_req_t req;
struct strbuf buf;
- req.dl_primitive = DL_PHYS_ADDR_REQ;
- req.dl_addr_type = DL_CURR_PHYS_ADDR;
+ req.dl_primitive = DL_INFO_REQ;
buf.len = sizeof(req);
buf.buf = (void *) &req;
return putmsg(fd, &buf, NULL, RS_HIPRI);
}
-int
+static int
dlpi_get_reply(fd, reply, expected_prim, maxlen)
union DL_primitives *reply;
int fd, expected_prim, maxlen;
/*
* Scan through the system's network interfaces.
*/
+#ifdef SIOCGIFNUM
if (ioctl(ipfd, SIOCGIFNUM, &nif) < 0)
+#endif
nif = MAX_IFS;
ifc.ifc_len = nif * sizeof(struct ifreq);
- ifc.ifc_req = alloca(ifc.ifc_len);
+ ifc.ifc_buf = (caddr_t) alloca(ifc.ifc_len);
if (ifc.ifc_req == 0)
return mask;
if (ioctl(ipfd, SIOCGIFCONF, &ifc) < 0) {
logwtmp(line, name, host)
char *line, *name, *host;
{
+ static struct utmpx utmpx;
+
+ if (name[0] != 0) {
+ /* logging in */
+ strncpy(utmpx.ut_user, name, sizeof(utmpx.ut_user));
+ strncpy(utmpx.ut_id, ifname, sizeof(utmpx.ut_id));
+ strncpy(utmpx.ut_line, line, sizeof(utmpx.ut_line));
+ utmpx.ut_pid = getpid();
+ utmpx.ut_type = USER_PROCESS;
+ } else {
+ utmpx.ut_type = DEAD_PROCESS;
+ }
+ gettimeofday(&utmpx.ut_tv, NULL);
+ updwtmpx("/var/adm/wtmpx", &utmpx);
+ return 0;
}
/*
syslog(LOG_ERR, "sysinfo: %m");
return 0;
}
- return strtol(buf, NULL, 16);
+ return (int) strtoul(buf, NULL, 16);
}
-int
+static int
strioctl(fd, cmd, ptr, ilen, olen)
int fd, cmd, ilen, olen;
- char *ptr;
+ void *ptr;
{
struct strioctl str;
return 0;
}
+/*
+ * lock - create a lock file for the named lock device
+ */
+
+#define LOCK_PREFIX "/var/spool/locks/LK."
+static char lock_file[40]; /* name of lock file created */
+
int
lock(dev)
char *dev;
{
+ int n, fd, pid;
+ struct stat sbuf;
+ char ascii_pid[12];
+
+ if (stat(dev, &sbuf) < 0) {
+ syslog(LOG_ERR, "Can't get device number for %s: %m", dev);
+ return -1;
+ }
+ if ((sbuf.st_mode & S_IFMT) != S_IFCHR) {
+ syslog(LOG_ERR, "Can't lock %s: not a character device", dev);
+ return -1;
+ }
+ sprintf(lock_file, "%s%03d.%03d.%03d", LOCK_PREFIX, major(sbuf.st_dev),
+ major(sbuf.st_rdev), minor(sbuf.st_rdev));
+
+ while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) {
+ if (errno == EEXIST
+ && (fd = open(lock_file, O_RDONLY, 0)) >= 0) {
+ /* Read the lock file to find out who has the device locked */
+ n = read(fd, ascii_pid, 11);
+ if (n <= 0) {
+ syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
+ close(fd);
+ } else {
+ ascii_pid[n] = 0;
+ pid = atoi(ascii_pid);
+ if (pid > 0 && kill(pid, 0) == -1 && errno == ESRCH) {
+ /* pid no longer exists - remove the lock file */
+ if (unlink(lock_file) == 0) {
+ close(fd);
+ syslog(LOG_NOTICE, "Removed stale lock on %s (pid %d)",
+ dev, pid);
+ continue;
+ } else
+ syslog(LOG_WARNING, "Couldn't remove stale lock on %s",
+ dev);
+ } else
+ syslog(LOG_NOTICE, "Device %s is locked by pid %d",
+ dev, pid);
+ }
+ close(fd);
+ } else
+ syslog(LOG_ERR, "Can't create lock file %s: %m", lock_file);
+ lock_file[0] = 0;
+ return -1;
+ }
+
+ sprintf(ascii_pid, "%10d\n", getpid());
+ write(fd, ascii_pid, 11);
+
+ close(fd);
return 1;
}
-int
+/*
+ * unlock - remove our lockfile
+ */
+void
unlock()
{
- return 1;
+ if (lock_file[0]) {
+ unlink(lock_file);
+ lock_file[0] = 0;
+ }
}
projects / ppp.git / blobdiff