#include "pppd.h"
#include "fsm.h"
#include "ipcp.h"
-#include "patchlevel.h"
#ifdef IPX_CHANGE
#include "ipxcp.h"
#endif
#endif /* IPX_CHANGE */
+#ifdef PPP_FILTER
+#include <net/bpf.h>
+#include <linux/filter.h>
+#endif /* PPP_FILTER */
+
#ifdef LOCKLIB
#include <sys/locks.h>
#endif
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);
}
}
void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
{
int flags;
- struct ifreq ifr;
if (!new_style_driver)
return;
error("Couldn't set MRRU: %m");
flags = get_flags(ppp_dev_fd);
flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
- flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0);
-
- if (mtru > 0 && mtru != link_mtu) {
- memset(&ifr, 0, sizeof(ifr));
- slprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ppp%d", ifunit);
- ifr.ifr_mtu = mtru;
- if (ioctl(sock_fd, SIOCSIFMTU, &ifr) < 0)
- error("Couldn't set interface MTU: %m");
- flags |= SC_MULTILINK;
- }
+ flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
+ | (mrru? SC_MULTILINK: 0);
set_flags(ppp_dev_fd, flags);
if (make_ppp_unit() < 0)
die(1);
- /* set the mrru, mtu and flags */
+ /* set the mrru and flags */
cfg_bundle(mrru, mtru, rssn, tssn);
}
#ifdef B57600
{ 57600, B57600 },
#endif
+#ifdef B76800
+ { 76800, B76800 },
+#endif
#ifdef B115200
{ 115200, B115200 },
#endif
#endif
#ifdef B460800
{ 460800, B460800 },
+#endif
+#ifdef B921600
+ { 921600, B921600 },
#endif
{ 0, 0 }
};
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 = -1;
if (ppp_fd >= 0) {
nr = read(ppp_fd, buf, len);
- if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
+ 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)
+ 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;
}
return rv;
}
-/********************************************************************
- *
- * ppp_send_config - configure the transmit characteristics of
- * the ppp interface.
+/*
+ * netif_set_mtu - set the MTU on the PPP network interface.
*/
-
-void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
+void
+netif_set_mtu(int unit, int mtu)
{
- u_int x;
struct ifreq ifr;
-
- SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
-/*
- * Set the MTU and other parameters for the ppp device
- */
+
+ SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
+
memset (&ifr, '\0', sizeof (ifr));
strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
ifr.ifr_mtu = mtu;
if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
- fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
- link_mtu = mtu;
+ error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
+}
+/********************************************************************
+ *
+ * tty_send_config - configure the transmit characteristics of
+ * the ppp interface.
+ */
+
+void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
+{
+ u_int x;
+
+/*
+ * Set the asyncmap and other parameters for the ppp device
+ */
if (!still_ppp())
return;
+ link_mtu = mtu;
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;
}
/********************************************************************
*
- * ppp_set_xaccm - set the extended transmit ACCM for the interface.
+ * tty_set_xaccm - set the extended transmit ACCM for the interface.
*/
-void ppp_set_xaccm (int unit, ext_accm accm)
+void tty_set_xaccm (ext_accm accm)
{
SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
accm[0], accm[1], accm[2], accm[3]));
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__);
}
}
/********************************************************************
*
- * ppp_recv_config - configure the receive-side characteristics of
+ * tty_recv_config - configure the receive-side characteristics of
* the ppp interface.
*/
-void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
+void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
{
SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
/*
*/
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;
}
}
+#ifdef PPP_FILTER
+/*
+ * set_filters - set the active and pass filters in the kernel driver.
+ */
+int set_filters(struct bpf_program *pass, struct bpf_program *active)
+{
+ struct sock_fprog fp;
+
+ fp.len = pass->bf_len;
+ fp.filter = (struct sock_filter *) pass->bf_insns;
+ if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
+ if (errno == ENOTTY)
+ warn("kernel does not support PPP filtering");
+ else
+ error("Couldn't set pass-filter in kernel: %m");
+ return 0;
+ }
+ fp.len = active->bf_len;
+ fp.filter = (struct sock_filter *) active->bf_insns;
+ if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
+ error("Couldn't set active-filter in kernel: %m");
+ return 0;
+ }
+ return 1;
+}
+#endif /* PPP_FILTER */
+
/********************************************************************
*
* get_idle_time - return how long the link has been idle.
}
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");
*slave_fdp = sfd;
if (tcgetattr(sfd, &tios) == 0) {
tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
- tios.c_cflag |= CS8 | CREAD;
- tios.c_iflag = IGNPAR | CLOCAL;
+ tios.c_cflag |= CS8 | CREAD | CLOCAL;
+ tios.c_iflag = IGNPAR;
tios.c_oflag = 0;
tios.c_lflag = 0;
if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
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