static int restore_term = 0; /* 1 => we've munged the terminal */
static struct termios inittermios; /* Initial TTY termios */
-static int new_style_driver = 0;
+int new_style_driver = 0;
static char loop_name[20];
static unsigned char inbuf[512]; /* buffer for chars read from loopback */
if ( ok_error (errno) )
flags = 0;
else
- fatal("ioctl(PPPIOCGFLAGS): %m");
+ fatal("ioctl(PPPIOCGFLAGS): %m (line %d)", __LINE__);
}
SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
if (! ok_error (errno) )
- fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
+ fatal("ioctl(PPPIOCSFLAGS, %x): %m (line %d)", flags, errno, __LINE__);
}
}
{
int flags;
- openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
- setlogmask(LOG_UPTO(LOG_INFO));
- if (debug)
- setlogmask(LOG_UPTO(LOG_DEBUG));
-
if (new_style_driver) {
ppp_dev_fd = open("/dev/ppp", O_RDWR);
if (ppp_dev_fd < 0)
return 1;
if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
if ( ! ok_error (errno) )
- error("ioctl(PPPIOCSDEBUG): %m");
+ error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
return (0);
}
SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
/********************************************************************
*
- * establish_ppp - Turn the serial port into a ppp interface.
+ * tty_establish_ppp - Turn the serial port into a ppp interface.
*/
-int establish_ppp (int tty_fd)
+int tty_establish_ppp (int tty_fd)
{
- int x;
- int fd = -1;
+ int ret_fd;
/*
* Ensure that the tty device is in exclusive mode.
*/
if (!new_style_driver && looped
&& ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
- error("ioctl(transfer ppp unit): %m");
+ error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
return -1;
}
/*
}
}
+ ret_fd = generic_establish_ppp(tty_fd);
+
+#define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
+#define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
+ | SC_LOG_FLUSH)
+
+ if (ret_fd >= 0) {
+ set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
+ | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
+ } else {
+ if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
+ warn("Couldn't reset tty to normal line discipline: %m");
+ }
+
+ return ret_fd;
+}
+
+/********************************************************************
+ *
+ * generic_establish_ppp - Turn the fd into a ppp interface.
+ */
+int generic_establish_ppp (int fd)
+{
+ int x;
+
if (new_style_driver) {
/* Open another instance of /dev/ppp and connect the channel to it */
int flags;
- if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
+ if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
error("Couldn't get channel number: %m");
goto err;
}
/*
* Old-style driver: find out which interface we were given.
*/
- set_ppp_fd (tty_fd);
- if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
+ set_ppp_fd (fd);
+ if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
if (ok_error (errno))
goto err;
- fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
+ fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
}
/* Check that we got the same unit again. */
if (looped && x != ifunit)
/*
* Fetch the initial file flags and reset blocking mode on the file.
*/
- initfdflags = fcntl(tty_fd, F_GETFL);
+ initfdflags = fcntl(fd, F_GETFL);
if (initfdflags == -1 ||
- fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
+ fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
if ( ! ok_error (errno))
warn("Couldn't set device to non-blocking mode: %m");
}
if (!looped)
set_kdebugflag (kdebugflag);
- set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
- SC_RCV_EVNP | SC_RCV_ODDP));
-
SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
driver_version, driver_modification, driver_patch));
err_close:
close(fd);
err:
- if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
- warn("Couldn't reset tty to normal line discipline: %m");
return -1;
}
/********************************************************************
*
- * disestablish_ppp - Restore the serial port to normal operation.
+ * tty_disestablish_ppp - Restore the serial port to normal operation.
* This shouldn't call die() because it's called from die().
*/
-void disestablish_ppp(int tty_fd)
+void tty_disestablish_ppp(int tty_fd)
{
if (!hungup) {
/*
*/
if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
if ( ! ok_error (errno))
- error("ioctl(TIOCSETD, N_TTY): %m");
+ error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
}
if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
if ( ! ok_error (errno))
- warn("ioctl(TIOCNXCL): %m(%d)", errno);
+ warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
}
/* Reset non-blocking mode on fd. */
}
initfdflags = -1;
+ generic_disestablish_ppp(tty_fd);
+}
+
+/********************************************************************
+ *
+ * generic_disestablish_ppp - Restore device components to normal
+ * operation, and reconnect the ppp unit to the loopback if in demand
+ * mode. This shouldn't call die() because it's called from die().
+ */
+void generic_disestablish_ppp(int dev_fd)
+{
if (new_style_driver) {
close(ppp_fd);
ppp_fd = -1;
- if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
+ if (demand) {
+ set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
+ looped = 1;
+ } else if (ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
error("Couldn't release PPP unit: %m");
if (!multilink)
remove_fd(ppp_dev_fd);
+ } else {
+ /* old-style driver */
+ if (demand)
+ set_ppp_fd(slave_fd);
}
}
setdtr(tty_fd, 1);
if (tcgetattr(tty_fd, &tios) < 0) {
if (!ok_error(errno))
- fatal("tcgetattr: %m(%d)", errno);
+ fatal("tcgetattr: %m (line %d)", __LINE__);
return;
}
if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
if (!ok_error(errno))
- fatal("tcsetattr: %m");
+ fatal("tcsetattr: %m (line %d)", __LINE__);
baud_rate = baud_rate_of(speed);
restore_term = 1;
if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
if (! ok_error (errno))
- warn("tcsetattr: %m");
+ warn("tcsetattr: %m (line %d)", __LINE__);
}
}
}
int fd = ppp_fd;
int proto;
- if (debug)
- dbglog("sent %P", p, len);
+ dump_packet("sent", p, len);
if (len < PPP_HDRLEN)
return;
exc = in_fds;
n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
if (n < 0 && errno != EINTR)
- fatal("select: %m(%d)", errno);
+ fatal("select: %m");
}
/*
nr = read(ppp_fd, buf, len);
if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
error("read: %m");
+ if (nr < 0 && errno == ENXIO)
+ return 0;
}
if (nr < 0 && new_style_driver && ifunit >= 0) {
/* N.B. we read ppp_fd first since LCP packets come in there. */
nr = read(ppp_dev_fd, buf, len);
if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
error("read /dev/ppp: %m");
+ if (nr < 0 && errno == ENXIO)
+ return 0;
}
return (new_style_driver && nr > 0)? nr+2: nr;
}
ifr.ifr_mtu = mtu;
if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
- fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
+ error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
}
/********************************************************************
SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
if (!ok_error(errno))
- fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
+ fatal("ioctl(PPPIOCSASYNCMAP): %m (line %d)", __LINE__);
return;
}
return;
if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
if ( ! ok_error (errno))
- warn("ioctl(set extended ACCM): %m(%d)", errno);
+ warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
}
}
*/
if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
if ( ! ok_error (errno))
- error("ioctl(PPPIOCSMRU): %m(%d)", errno);
+ error("ioctl(PPPIOCSMRU): %m (line %d)", __LINE__);
}
if (new_style_driver && ifunit >= 0
&& ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
if (!ok_error(errno))
- error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
+ error("ioctl(PPPIOCSRASYNCMAP): %m (line %d)", __LINE__);
}
}
void ccp_flags_set (int unit, int isopen, int isup)
{
- if (still_ppp()) {
+ if (still_ppp() && ifunit >= 0) {
int x = get_flags(ppp_dev_fd);
x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
}
stats->bytes_in = req.stats.p.ppp_ibytes;
stats->bytes_out = req.stats.p.ppp_obytes;
+ stats->pkts_in = req.stats.p.ppp_ipackets;
+ stats->pkts_out = req.stats.p.ppp_opackets;
return 1;
}
rt.rt_flags = RTF_UP | RTF_GATEWAY;
if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
if ( ! ok_error ( errno ))
- error("default route ioctl(SIOCADDRT): %m(%d)", errno);
+ error("default route ioctl(SIOCADDRT): %m");
return 0;
}
if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
if (still_ppp()) {
if ( ! ok_error ( errno ))
- error("default route ioctl(SIOCDELRT): %m (%d)", errno);
+ error("default route ioctl(SIOCDELRT): %m");
return 0;
}
}
if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
if ( ! ok_error ( errno ))
- error("ioctl(SIOCSARP): %m(%d)", errno);
+ error("ioctl(SIOCSARP): %m");
return 0;
}
proxy_arp_addr = his_adr;
if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
if ( ! ok_error ( errno ))
- warn("ioctl(SIOCDARP): %m(%d)", errno);
+ warn("ioctl(SIOCDARP): %m");
return 0;
}
}
ifc.ifc_req = ifs;
if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
if ( ! ok_error ( errno ))
- error("ioctl(SIOCGIFCONF): %m(%d)", errno);
+ error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
return 0;
}
*/
memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
- error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
+ error("SIOCGIFHWADDR(%s): %m", ifreq.ifr_name);
return 0;
}
ifc.ifc_req = ifs;
if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
if ( ! ok_error ( errno ))
- warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
+ warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
return mask;
}
static void decode_version (char *buf, int *version,
int *modification, int *patch)
{
- *version = (int) strtoul (buf, &buf, 10);
+ char *endp;
+
+ *version = (int) strtoul (buf, &endp, 10);
*modification = 0;
*patch = 0;
- if (*buf == '.') {
- ++buf;
- *modification = (int) strtoul (buf, &buf, 10);
- if (*buf == '.') {
- ++buf;
+ if (endp != buf && *endp == '.') {
+ buf = endp + 1;
+ *modification = (int) strtoul (buf, &endp, 10);
+ if (endp != buf && *endp == '.') {
+ buf = endp + 1;
*patch = (int) strtoul (buf, &buf, 10);
}
}
-
- if (*buf != '\0') {
- *version =
- *modification =
- *patch = 0;
- }
}
/********************************************************************
* Try to put the device into the PPP discipline.
*/
if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
- error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
+ error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
} else
ret = 1;
close(fd);
return 1;
}
- if (kernel_version >= KVERSION(2,3,13))
+ if (kernel_version >= KVERSION(2,3,13)) {
+ if (errno == ENOENT)
+ no_ppp_msg =
+ "pppd is unable to open the /dev/ppp device.\n"
+ "You need to create the /dev/ppp device node by\n"
+ "executing the following command as root:\n"
+ " mknod /dev/ppp c 108 0\n";
return 0;
+ }
/*
* Open a socket for doing the ioctl operations.
while ((utp = getutent()) && (utp->ut_pid != mypid))
/* nothing */;
- /* Is this call really necessary? There is another one after the 'put' */
- endutent();
-
if (utp)
memcpy(&ut, utp, sizeof(ut));
else
if (vjcomp) {
if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
if (! ok_error (errno))
- error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
+ error("ioctl(PPPIOCSMAXCID): %m (line %d)", __LINE__);
vjcomp = 0;
}
}
strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
- error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
+ error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
return 0;
}
ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
- error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
+ error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
return 0;
}
if_is_up++;
strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
- error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
+ error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
return 0;
}
ifr.ifr_flags |= IFF_POINTOPOINT;
if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
- error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
+ error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
return 0;
}
return 1;
if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
if (errno != EEXIST) {
if (! ok_error (errno))
- error("ioctl(SIOCSIFADDR): %m(%d)", errno);
+ error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
}
else {
warn("ioctl(SIOCSIFADDR): Address already exists");
SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
- error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
+ error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
return (0);
}
/*
SIN_ADDR(ifr.ifr_netmask) = net_mask;
if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
- error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
+ error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
return (0);
}
}
if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
if (! ok_error (errno))
- error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
+ error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
return (0);
}
}
if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
if (still_ppp() && ! ok_error (errno))
- error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
+ error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
return (0);
}
}
if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
if (! ok_error (errno)) {
- error("ioctl(SIOCSIFADDR): %m(%d)", errno);
+ error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
return 0;
}
}
memset(&ifr, 0, sizeof (ifr));
strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
- error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
+ error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
return 0;
}
ifr6.ifr6_prefixlen = 10;
if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
- error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
+ error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
return 0;
}
rt6.rtmsg_metric = 1;
if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
- error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
+ error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
return 0;
}
memset(&ifr, 0, sizeof(ifr));
strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
- error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
+ error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
return 0;
}
if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
if (errno != EADDRNOTAVAIL) {
if (! ok_error (errno))
- error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
+ error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
}
else {
warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
flags = fcntl(master_fd, F_GETFL);
if (flags == -1 ||
fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
- warn("couldn't set master loopback to nonblock: %m(%d)", errno);
+ warn("couldn't set master loopback to nonblock: %m");
flags = fcntl(ppp_fd, F_GETFL);
if (flags == -1 ||
fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
- warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
+ warn("couldn't set slave loopback to nonblock: %m");
if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
- fatal("ioctl(TIOCSETD): %m(%d)", errno);
+ fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
/*
* Find out which interface we were given.
*/
if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
- fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
+ fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
/*
* Enable debug in the driver if requested.
*/
return master_fd;
}
-/********************************************************************
- *
- * restore_loop - reattach the ppp unit to the loopback.
- *
- * The kernel ppp driver automatically reattaches the ppp unit to
- * the loopback if the serial port is set to a line discipline other
- * than ppp, or if it detects a modem hangup. The former will happen
- * in disestablish_ppp if the latter hasn't already happened, so we
- * shouldn't need to do anything.
- *
- * Just to be sure, set the real serial port to the normal discipline.
- */
-
-void
-restore_loop(void)
-{
- looped = 1;
- if (new_style_driver) {
- set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
- return;
- }
- if (ppp_fd != slave_fd) {
- (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
- set_ppp_fd(slave_fd);
- }
-}
-
/********************************************************************
*
* sifnpmode - Set the mode for handling packets for a given NP.
npi.mode = mode;
if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
if (! ok_error (errno))
- error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
- proto, mode, errno);
+ error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
return 0;
}
return 1;
skfd = socket (AF_IPX, SOCK_DGRAM, 0);
if (skfd < 0) {
if (! ok_error (errno))
- dbglog("socket(AF_IPX): %m (%d)", errno);
+ dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
result = 0;
}
else {
result = 0;
if (errno != EEXIST) {
if (! ok_error (errno))
- dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
+ dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
}
else {
warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
skfd = socket (AF_IPX, SOCK_DGRAM, 0);
if (skfd < 0) {
if (! ok_error (errno))
- dbglog("socket(AF_IPX): %m (%d)", errno);
+ dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
result = 0;
}
else {
*/
if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
- info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
+ info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
result = 0;
}
close (skfd);
projects / ppp.git / blobdiff