/* new_fd is the fd of a tty */
static void set_ppp_fd (int new_fd)
{
SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
ppp_fd = new_fd;
if (!new_style_driver)
ppp_dev_fd = new_fd;
}
static void set_flags (int fd, int flags)
{
SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
if (! ok_error (errno) )
fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
}
}
static int set_kdebugflag (int requested_level)
{
if (new_style_driver && ifunit < 0)
return 1;
if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
if ( ! ok_error (errno) )
error("ioctl(PPPIOCSDEBUG): %m");
return (0);
}
SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
requested_level));
return (1);
}
/*
* netif_set_mtu - set the MTU on the PPP network interface.
*/
void
netif_set_mtu(int unit, int mtu)
{
struct ifreq ifr;
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");
}
static int get_flags (int fd)
{
int flags;
if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
if ( ok_error (errno) )
flags = 0;
else
fatal("ioctl(PPPIOCGFLAGS): %m");
}
SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
return flags;
}
/*
* These are copied from conf.c. However as conf.c will be moved to using
* the callback system, they can be pulled from there eventually, so we
* don't need to pollute utils.c with these low level functions
*/
int find_fstype_cb(char *buffer, void *data)
{
struct cbarg {
const char *rootfs;
const char *target;
const char *options;
} *cbarg = data;
unsigned long mntflags;
char *mntdata;
char *fstype;
/* we don't try 'nodev' entries */
if (strstr(buffer, "nodev"))
return 0;
fstype = buffer;
fstype += lxc_char_left_gc(fstype, strlen(fstype));
fstype[lxc_char_right_gc(fstype, strlen(fstype))] = '\0';
DEBUG("Trying to mount \"%s\"->\"%s\" with FSType \"%s\"", cbarg->rootfs,
cbarg->target, fstype);
if (parse_mntopts(cbarg->options, &mntflags, &mntdata) < 0) {
free(mntdata);
return 0;
}
if (mount(cbarg->rootfs, cbarg->target, fstype, mntflags, mntdata)) {
SYSDEBUG("Failed to mount");
free(mntdata);
return 0;
}
free(mntdata);
INFO("Mounted \"%s\" on \"%s\", with FSType \"%s\"", cbarg->rootfs,
cbarg->target, fstype);
return 1;
}
static int lxc_monitord_fifo_create(struct lxc_monitor *mon)
{
struct flock lk;
char fifo_path[PATH_MAX];
int ret;
ret = lxc_monitor_fifo_name(mon->lxcpath, fifo_path, sizeof(fifo_path), 1);
if (ret < 0)
return ret;
ret = mknod(fifo_path, S_IFIFO | S_IRUSR | S_IWUSR, 0);
if (ret < 0 && errno != EEXIST) {
SYSINFO("Failed to mknod monitor fifo %s", fifo_path);
return -1;
}
mon->fifofd = open(fifo_path, O_RDWR);
if (mon->fifofd < 0) {
SYSERROR("Failed to open monitor fifo %s", fifo_path);
unlink(fifo_path);
return -1;
}
lk.l_type = F_WRLCK;
lk.l_whence = SEEK_SET;
lk.l_start = 0;
lk.l_len = 0;
if (fcntl(mon->fifofd, F_SETLK, &lk) != 0) {
/* another lxc-monitord is already running, don't start up */
SYSDEBUG("lxc-monitord already running on lxcpath %s", mon->lxcpath);
close(mon->fifofd);
return -1;
}
return 0;
}
/********************************************************************
*
* generic_establish_ppp - Turn the fd into a ppp interface.
*/
int generic_establish_ppp (int fd)
{
int x;
/*
* Demand mode - prime the old ppp device to relinquish the unit.
*/
if (!new_style_driver && looped
&& ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
error("ioctl(transfer ppp unit): %m");
return -1;
}
if (new_style_driver) {
/* Open another instance of /dev/ppp and connect the channel to it */
int flags;
if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
error("Couldn't get channel number: %m");
goto err;
}
dbglog("using channel %d", chindex);
fd = open("/dev/ppp", O_RDWR);
if (fd < 0) {
error("Couldn't reopen /dev/ppp: %m");
goto err;
}
if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
error("Couldn't attach to channel %d: %m", chindex);
goto err_close;
}
flags = fcntl(fd, F_GETFL);
if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
set_ppp_fd(fd);
if (!looped)
ifunit = -1;
if (!looped && !multilink) {
/*
* Create a new PPP unit.
*/
if (make_ppp_unit() < 0)
goto err_close;
}
if (looped)
set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
if (!multilink) {
add_fd(ppp_dev_fd);
if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
error("Couldn't attach to PPP unit %d: %m", ifunit);
goto err_close;
}
}
} else {
/*
* Old-style driver: find out which interface we were given.
*/
set_ppp_fd (fd);
if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
if (ok_error (errno))
goto err;
fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
}
/* Check that we got the same unit again. */
if (looped && x != ifunit)
fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
ifunit = x;
/*
* Fetch the initial file flags and reset blocking mode on the file.
*/
initfdflags = fcntl(fd, F_GETFL);
if (initfdflags == -1 ||
fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
if ( ! ok_error (errno))
warn("Couldn't set device to non-blocking mode: %m");
}
}
/*
* Enable debug in the driver if requested.
*/
if (!looped)
set_kdebugflag (kdebugflag);
SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
driver_version, driver_modification, driver_patch));
return ppp_fd;
err_close:
close(fd);
err:
if (ioctl(fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
warn("Couldn't reset tty to normal line discipline: %m");
return -1;
}