mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-21 11:13:30 +00:00
Code Issues Releases Activity
0177987224
freebsd/usr.sbin/ppp/physical.h

166 lines
6.0 KiB
C
Raw Normal View History

Create a new MP branch for `multilink protocol'. Do lots of initial shuffling and grouping. Submitted by: Eivind Eklund <perhaps@yes.no>
1998-01-29 00:49:32 +00:00
/*
* Written by Eivind Eklund <eivind@yes.no>
* for Yes Interactive
*
* Copyright (C) 1998, Yes Interactive. All rights reserved.
*
* Redistribution and use in any form is permitted. Redistribution in
* source form should include the above copyright and this set of
* conditions, because large sections american law seems to have been
* created by a bunch of jerks on drugs that are now illegal, forcing
* me to include this copyright-stuff instead of placing this in the
* public domain. The name of of 'Yes Interactive' or 'Eivind Eklund'
* may not be used to endorse or promote products derived from this
* software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
$Id$ -> $FreeBSD$
1999-08-28 01:35:59 +00:00
* $FreeBSD$
Create a new MP branch for `multilink protocol'. Do lots of initial shuffling and grouping. Submitted by: Eivind Eklund <perhaps@yes.no>
1998-01-29 00:49:32 +00:00
*
*/
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
struct datalink;
o Move alias function pointers into loadalias.c o Move Var*Version into command.c o Remove struct pppVars (and there was much rejoicing) ! o Forward-decl some structs in .h files to avoid include ordering requirements and remove a few more redundant #includes.
1998-04-07 00:54:26 +00:00
struct bundle;
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
struct iovec;
struct physical;
struct bundle;
struct ccp;
struct cmdargs;
Rewrite the link descriptor transfer code in MP mode. Previously, ppp attempted to bind() to a local domain tcp socket based on the peer authname & enddisc. If it succeeded, it listen()ed and became MP server. If it failed, it connect()ed and became MP client. The server then select()ed on the descriptor, accept()ed it and wrote its pid to it then read the link data & link file descriptor, and finally sent an ack (``!''). The client would read() the server pid, transfer the link lock to that pid, send the link data & descriptor and read the ack. It would then close the descriptor and clean up. There was a race between the bind() and listen() where someone could attempt to connect() and fail. This change removes the race. Now ppp makes the RCVBUF big enough on a socket descriptor and attempts to bind() to a local domain *udp* socket (same name as before). If it succeeds, it becomes MP server. If it fails, it sets the SNDBUF and connect()s, becoming MP client. The server select()s on the descriptor and recvmsg()s the message, insisting on at least two descriptors (plus the link data). It uses the second descriptor to write() its pid then read()s an ack (``!''). The client creates a socketpair() and sendmsg()s the link data, link descriptor and one of the socketpair descriptors. It then read()s the server pid from the other socketpair descriptor, transfers any locks and write()s an ack. Now, there can be no race, and a connect() failure indicates a stale socket file. This also fixes MP ppp over ethernet, where the struct msghdr was being misconstructed when transferring the control socket descriptor. Also, if we fail to send the link, don't hang around in a ``session owner'' state, just do the setsid() and fork() if it's required to disown a tty. UDP idea suggested by: Chris Bennet from Mindspring at FreeBSDCon
1999-11-25 02:47:04 +00:00
/* Device types (don't use zero, it'll be confused with NULL in physical2iov */
Add ISDN support via isdnd & i4b. This requires version 0.81.1 of the i4b code - namely support of the I4B_VR_REQ ioctl via the i4brbchX device. Ppp controls the phone number, but idle timers and SYNC/RAW decisions are still made by isdnd (in isdnd.rc). This involves a new datalink state machine phase. The ``wait for carrier'' phase happens after dialing but before logging in. The whole dial state should really be abstracted so that each device type can deal with it in its own way (thinking about PPPoE) - but that'll have to wait. The ``set cd'' symantics remain the same for tty devices, but we now delay until we either get CD or timeout waiting (at which time we drop the link if we require CD). For i4b devices we always insist on carrier. Thanks to hm@ for his help, and especially for pointing out that I *don't* need to re-implement isdnd (that was a huge waste of time !) :-]
1999-08-06 20:04:08 +00:00
#define I4B_DEVICE 1
#define TTY_DEVICE 2
#define TCP_DEVICE 3
#define UDP_DEVICE 4
Support PPPoE Help (lots) from: julian, archie Facilities from: ahebert@pubnix.net
1999-11-06 22:50:59 +00:00
#define ETHER_DEVICE 5
#define EXEC_DEVICE 6
Add ISDN support via isdnd & i4b. This requires version 0.81.1 of the i4b code - namely support of the I4B_VR_REQ ioctl via the i4brbchX device. Ppp controls the phone number, but idle timers and SYNC/RAW decisions are still made by isdnd (in isdnd.rc). This involves a new datalink state machine phase. The ``wait for carrier'' phase happens after dialing but before logging in. The whole dial state should really be abstracted so that each device type can deal with it in its own way (thinking about PPPoE) - but that'll have to wait. The ``set cd'' symantics remain the same for tty devices, but we now delay until we either get CD or timeout waiting (at which time we drop the link if we require CD). For i4b devices we always insist on carrier. Thanks to hm@ for his help, and especially for pointing out that I *don't* need to re-implement isdnd (that was a huge waste of time !) :-]
1999-08-06 20:04:08 +00:00
/* Returns from awaitcarrier() */
#define CARRIER_PENDING 1
#define CARRIER_OK 2
#define CARRIER_LOST 3
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
Support ``set cd off'' to tell ppp not to even look for carrier on the device.
1999-09-26 23:02:18 +00:00
/* A cd ``necessity'' value */
Change ``set cd'' so that its default value is device specific. The default is still 1 second for ttys, but is now 6 seconds for i4b (ISDN) devices and 5 seconds for ethernet (PPPoE) devices.
1999-11-26 22:44:33 +00:00
#define CD_VARIABLE 0
#define CD_REQUIRED 1
#define CD_NOTREQUIRED 2
#define CD_DEFAULT 3
struct cd {
unsigned necessity : 2; /* A CD_ value */
int delay; /* Wait this many seconds after login script */
};
Support ``set cd off'' to tell ppp not to even look for carrier on the device.
1999-09-26 23:02:18 +00:00
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
struct device {
int type;
const char *name;
Change ``set cd'' so that its default value is device specific. The default is still 1 second for ttys, but is now 6 seconds for i4b (ISDN) devices and 5 seconds for ethernet (PPPoE) devices.
1999-11-26 22:44:33 +00:00
struct cd cd;
Allow ``host:port/udp'' devices and support ``host:port/tcp'' as being the same as the previous (still supported) ``host:port'' syntax for tcp socket devices. A udp device uses synchronous ppp rather than async, and avoids the double-retransmit overhead that comes with ppp over tcp (it's usually a bad idea to transport IP over a reliable transport that itself is using an unreliable transport). PPP over UDP provides througput of ** 1.5Mb per second ** with all compression disabled, maxing out a PPro/200 when running ppp twice, back-to-back. This proves that PPPoE is plausable in userland.... This change adds a few more handler functions to struct device and allows derivations of struct device (which may contain their own data etc) to pass themselves through the unix domain socket for MP. ** At last **, struct physical has lost all the tty crud ! iov2physical() is now smart enough to restore the correct stack of layers so that MP servers will work again. The version number has bumped as our MP link transfer contents have changed (they now may contain a `struct device'). Don't extract the protocol twice in MP mode (resulting in protocol rejects for every MP packet). This was broken with my original layering changes. Add ``Physical'' and ``Sync'' log levels for logging the relevent raw packets and add protocol-tracking LogDEBUG stuff in various LayerPush & LayerPull functions. Assign our physical device name for incoming tcp connections by calling getpeername(). Assign our physical device name for incoming udp connections from the address retrieved by the first recvfrom().
1999-05-12 09:49:12 +00:00
Add ISDN support via isdnd & i4b. This requires version 0.81.1 of the i4b code - namely support of the I4B_VR_REQ ioctl via the i4brbchX device. Ppp controls the phone number, but idle timers and SYNC/RAW decisions are still made by isdnd (in isdnd.rc). This involves a new datalink state machine phase. The ``wait for carrier'' phase happens after dialing but before logging in. The whole dial state should really be abstracted so that each device type can deal with it in its own way (thinking about PPPoE) - but that'll have to wait. The ``set cd'' symantics remain the same for tty devices, but we now delay until we either get CD or timeout waiting (at which time we drop the link if we require CD). For i4b devices we always insist on carrier. Thanks to hm@ for his help, and especially for pointing out that I *don't* need to re-implement isdnd (that was a huge waste of time !) :-]
1999-08-06 20:04:08 +00:00
int (*awaitcarrier)(struct physical *);
Support PPPoE Help (lots) from: julian, archie Facilities from: ahebert@pubnix.net
1999-11-06 22:50:59 +00:00
int (*removefromset)(struct physical *, fd_set *, fd_set *, fd_set *);
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
int (*raw)(struct physical *);
void (*offline)(struct physical *);
void (*cooked)(struct physical *);
Allow ``host:port/udp'' devices and support ``host:port/tcp'' as being the same as the previous (still supported) ``host:port'' syntax for tcp socket devices. A udp device uses synchronous ppp rather than async, and avoids the double-retransmit overhead that comes with ppp over tcp (it's usually a bad idea to transport IP over a reliable transport that itself is using an unreliable transport). PPP over UDP provides througput of ** 1.5Mb per second ** with all compression disabled, maxing out a PPro/200 when running ppp twice, back-to-back. This proves that PPPoE is plausable in userland.... This change adds a few more handler functions to struct device and allows derivations of struct device (which may contain their own data etc) to pass themselves through the unix domain socket for MP. ** At last **, struct physical has lost all the tty crud ! iov2physical() is now smart enough to restore the correct stack of layers so that MP servers will work again. The version number has bumped as our MP link transfer contents have changed (they now may contain a `struct device'). Don't extract the protocol twice in MP mode (resulting in protocol rejects for every MP packet). This was broken with my original layering changes. Add ``Physical'' and ``Sync'' log levels for logging the relevent raw packets and add protocol-tracking LogDEBUG stuff in various LayerPush & LayerPull functions. Assign our physical device name for incoming tcp connections by calling getpeername(). Assign our physical device name for incoming udp connections from the address retrieved by the first recvfrom().
1999-05-12 09:49:12 +00:00
void (*stoptimer)(struct physical *);
void (*destroy)(struct physical *);
ssize_t (*read)(struct physical *, void *, size_t);
ssize_t (*write)(struct physical *, const void *, size_t);
Rewrite the link descriptor transfer code in MP mode. Previously, ppp attempted to bind() to a local domain tcp socket based on the peer authname & enddisc. If it succeeded, it listen()ed and became MP server. If it failed, it connect()ed and became MP client. The server then select()ed on the descriptor, accept()ed it and wrote its pid to it then read the link data & link file descriptor, and finally sent an ack (``!''). The client would read() the server pid, transfer the link lock to that pid, send the link data & descriptor and read the ack. It would then close the descriptor and clean up. There was a race between the bind() and listen() where someone could attempt to connect() and fail. This change removes the race. Now ppp makes the RCVBUF big enough on a socket descriptor and attempts to bind() to a local domain *udp* socket (same name as before). If it succeeds, it becomes MP server. If it fails, it sets the SNDBUF and connect()s, becoming MP client. The server select()s on the descriptor and recvmsg()s the message, insisting on at least two descriptors (plus the link data). It uses the second descriptor to write() its pid then read()s an ack (``!''). The client creates a socketpair() and sendmsg()s the link data, link descriptor and one of the socketpair descriptors. It then read()s the server pid from the other socketpair descriptor, transfers any locks and write()s an ack. Now, there can be no race, and a connect() failure indicates a stale socket file. This also fixes MP ppp over ethernet, where the struct msghdr was being misconstructed when transferring the control socket descriptor. Also, if we fail to send the link, don't hang around in a ``session owner'' state, just do the setsid() and fork() if it's required to disown a tty. UDP idea suggested by: Chris Bennet from Mindspring at FreeBSDCon
1999-11-25 02:47:04 +00:00
void (*device2iov)(struct device *, struct iovec *, int *, int, int *, int *);
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
int (*speed)(struct physical *);
const char *(*openinfo)(struct physical *);
};
o Move alias function pointers into loadalias.c o Move Var*Version into command.c o Remove struct pppVars (and there was much rejoicing) ! o Forward-decl some structs in .h files to avoid include ordering requirements and remove a few more redundant #includes.
1998-04-07 00:54:26 +00:00
Create a new MP branch for `multilink protocol'. Do lots of initial shuffling and grouping. Submitted by: Eivind Eklund <perhaps@yes.no>
1998-01-29 00:49:32 +00:00
struct physical {
Create `struct link' - the logical link from which `struct physical' (and the future `struct logical') are derived.
1998-01-30 19:46:07 +00:00
struct link link;
o Introduce struct descriptor. This will ultimately be a member of a list of descriptors and their handler functions on which we need to select() in the main loop. o Make struct physical into a `sort' of struct descriptor.
1998-02-09 19:21:11 +00:00
struct descriptor desc;
Cosmetic: Make our external function names consistent.
1998-05-01 19:26:12 +00:00
int type; /* What sort of PHYS_* link are we ? */
Create `struct async' and make it part of `struct physical'. This structure contains the asynchronous state of the physical link. Unfortunately, just about every .h file is included in every .c file now. Fixing this can be one of the last jobs.
1998-02-02 19:33:40 +00:00
struct async async; /* Our async state */
o Create `struct hdlc' - a part of struct physical. o Move our LCP report timer into struct hdlc - it's really a hdlc timer (fcs errors etc). o Make `show hdlc' require context and make the output more friendly. o Remove all non-const globals from hdlc.c o Output peer-rejected protocols by name - not just ones that we reject.
1998-02-18 19:35:59 +00:00
struct hdlc hdlc; /* Our hdlc state */
Create `struct link' - the logical link from which `struct physical' (and the future `struct logical') are derived.
1998-01-30 19:46:07 +00:00
int fd; /* File descriptor for this device */
Move `Utmp' into struct physical. We can be logged in once for every -direct physical connection.
1998-03-10 03:06:07 +00:00
struct mbuf *out; /* mbuf that suffered a short write */
Create `struct link' - the logical link from which `struct physical' (and the future `struct logical') are derived.
1998-01-30 19:46:07 +00:00
int connect_count;
"dial" now may optionally have context. Tidy up some LcpInfo uses.
1998-03-13 00:44:51 +00:00
struct datalink *dl; /* my owner */
Create a new MP branch for `multilink protocol'. Do lots of initial shuffling and grouping. Submitted by: Eivind Eklund <perhaps@yes.no>
1998-01-29 00:49:32 +00:00
Handle the detection of frames even if we read them with more than one read(). When we detect one, don't forget to pass it to async_Input() and drop our terminal back into command mode. Don't output an extraneous \r if we're passed \r\n to prompt_vprintf in raw mode.
1999-04-03 11:54:00 +00:00
struct {
u_char buf[MAX_MRU]; /* Our input data buffer */
size_t sz;
} input;
o Move all device names into struct physical. o Use the correct device name in -direct mode. o Use a default list of "cuaa1, cuaa0" rather than just cuaa1 and allow embedded spaces as separators.
1998-03-06 00:34:47 +00:00
struct {
Increase the length of an individual device name to LINE_LEN. Adjust the base physical device name correctly after a link transfer (allowing correct multilink callbacks).
1999-06-01 19:08:59 +00:00
char full[DEVICE_LEN]; /* Our current device name */
o Move all device names into struct physical. o Use the correct device name in -direct mode. o Use a default list of "cuaa1, cuaa0" rather than just cuaa1 and allow embedded spaces as separators.
1998-03-06 00:34:47 +00:00
char *base;
} name;
Manually create a correct(*) entry in wtmp when logging out a PPPoTCP or PPPoUDP connection. (*) This is as correct as ftp and uucp wtmp entries are - that is, multiple concurrent connections will not record enough information in wtmp to tell last(1) who was logged in for how long.
1999-10-21 21:55:22 +00:00
time_t Utmp; /* Are we in utmp ? */
o If there's a session leader left running for a descriptor that we're now closing, manually HUP that session leader so that the tty is fully released. o Always restart our carrier detect timer in the receiving process if it was running in the sending process (as we now *always* pass the descriptor). o Tweak argv when we go into pause() mode to keep our session so that ps can see what's going on (without checking for a `pause' state in `ps -l').
1998-05-29 18:33:10 +00:00
pid_t session_owner; /* HUP this when closing the link */
Move `Utmp' into struct physical. We can be logged in once for every -direct physical connection.
1998-03-10 03:06:07 +00:00
Allow ``host:port/udp'' devices and support ``host:port/tcp'' as being the same as the previous (still supported) ``host:port'' syntax for tcp socket devices. A udp device uses synchronous ppp rather than async, and avoids the double-retransmit overhead that comes with ppp over tcp (it's usually a bad idea to transport IP over a reliable transport that itself is using an unreliable transport). PPP over UDP provides througput of ** 1.5Mb per second ** with all compression disabled, maxing out a PPro/200 when running ppp twice, back-to-back. This proves that PPPoE is plausable in userland.... This change adds a few more handler functions to struct device and allows derivations of struct device (which may contain their own data etc) to pass themselves through the unix domain socket for MP. ** At last **, struct physical has lost all the tty crud ! iov2physical() is now smart enough to restore the correct stack of layers so that MP servers will work again. The version number has bumped as our MP link transfer contents have changed (they now may contain a `struct device'). Don't extract the protocol twice in MP mode (resulting in protocol rejects for every MP packet). This was broken with my original layering changes. Add ``Physical'' and ``Sync'' log levels for logging the relevent raw packets and add protocol-tracking LogDEBUG stuff in various LayerPush & LayerPull functions. Assign our physical device name for incoming tcp connections by calling getpeername(). Assign our physical device name for incoming udp connections from the address retrieved by the first recvfrom().
1999-05-12 09:49:12 +00:00
struct device *handler; /* device specific handler */
Cosmetic: Group configuration items in struct physical.
1998-02-17 19:29:03 +00:00
struct {
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
unsigned rts_cts : 1; /* Is rts/cts enabled ? */
unsigned parity; /* What parity is enabled? (tty flags) */
unsigned speed; /* tty speed */
Change ``set device'' so that it parses its arguments as one device per argument rather than the old way of concatenating everything then splitting the result at commas and whitespace. Old syntax of ``set device /dev/cuaa0, /dev/cuaa1'' may no longer contain the comma, but syntax such as ``set device "!ssh host ppp -direct label"'' is now possible.
1999-04-27 00:23:57 +00:00
char devlist[LINE_LEN]; /* NUL separated list of devices */
int ndev; /* number of devices in list */
Change ``set cd'' so that its default value is device specific. The default is still 1 second for ttys, but is now 6 seconds for i4b (ISDN) devices and 5 seconds for ethernet (PPPoE) devices.
1999-11-26 22:44:33 +00:00
struct cd cd;
Cosmetic: Group configuration items in struct physical.
1998-02-17 19:29:03 +00:00
} cfg;
Create a new MP branch for `multilink protocol'. Do lots of initial shuffling and grouping. Submitted by: Eivind Eklund <perhaps@yes.no>
1998-01-29 00:49:32 +00:00
};
o Introduce struct descriptor. This will ultimately be a member of a list of descriptors and their handler functions on which we need to select() in the main loop. o Make struct physical into a `sort' of struct descriptor.
1998-02-09 19:21:11 +00:00
#define field2phys(fp, name) \
((struct physical *)((char *)fp - (int)(&((struct physical *)0)->name)))
#define link2physical(l) \
((l)->type == PHYSICAL_LINK ? field2phys(l, link) : NULL)
#define descriptor2physical(d) \
((d)->type == PHYSICAL_DESCRIPTOR ? field2phys(d, desc) : NULL)
Create `struct link' - the logical link from which `struct physical' (and the future `struct logical') are derived.
1998-01-30 19:46:07 +00:00
Support PPPoE Help (lots) from: julian, archie Facilities from: ahebert@pubnix.net
1999-11-06 22:50:59 +00:00
#define PHYSICAL_NOFORCE 1
#define PHYSICAL_FORCE_ASYNC 2
#define PHYSICAL_FORCE_SYNC 3
#define PHYSICAL_FORCE_SYNCNOACF 4
Allow ``host:port/udp'' devices and support ``host:port/tcp'' as being the same as the previous (still supported) ``host:port'' syntax for tcp socket devices. A udp device uses synchronous ppp rather than async, and avoids the double-retransmit overhead that comes with ppp over tcp (it's usually a bad idea to transport IP over a reliable transport that itself is using an unreliable transport). PPP over UDP provides througput of ** 1.5Mb per second ** with all compression disabled, maxing out a PPro/200 when running ppp twice, back-to-back. This proves that PPPoE is plausable in userland.... This change adds a few more handler functions to struct device and allows derivations of struct device (which may contain their own data etc) to pass themselves through the unix domain socket for MP. ** At last **, struct physical has lost all the tty crud ! iov2physical() is now smart enough to restore the correct stack of layers so that MP servers will work again. The version number has bumped as our MP link transfer contents have changed (they now may contain a `struct device'). Don't extract the protocol twice in MP mode (resulting in protocol rejects for every MP packet). This was broken with my original layering changes. Add ``Physical'' and ``Sync'' log levels for logging the relevent raw packets and add protocol-tracking LogDEBUG stuff in various LayerPush & LayerPull functions. Assign our physical device name for incoming tcp connections by calling getpeername(). Assign our physical device name for incoming udp connections from the address retrieved by the first recvfrom().
1999-05-12 09:49:12 +00:00
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
extern struct physical *physical_Create(struct datalink *, int);
extern int physical_Open(struct physical *, struct bundle *);
extern int physical_Raw(struct physical *);
extern int physical_GetSpeed(struct physical *);
Cosmetic: Make our external function names consistent.
1998-05-01 19:26:12 +00:00
extern int physical_SetSpeed(struct physical *, int);
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
extern int physical_SetParity(struct physical *, const char *);
extern int physical_SetRtsCts(struct physical *, int);
Cosmetic: Make our external function names consistent.
1998-05-01 19:26:12 +00:00
extern void physical_SetSync(struct physical *);
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
extern int physical_ShowStatus(struct cmdargs const *);
extern void physical_Offline(struct physical *);
extern void physical_Close(struct physical *);
extern void physical_Destroy(struct physical *);
extern struct physical *iov2physical(struct datalink *, struct iovec *, int *,
Support PPPoE Help (lots) from: julian, archie Facilities from: ahebert@pubnix.net
1999-11-06 22:50:59 +00:00
int, int, int *, int *);
extern int physical2iov(struct physical *, struct iovec *, int *, int, int *,
Rewrite the link descriptor transfer code in MP mode. Previously, ppp attempted to bind() to a local domain tcp socket based on the peer authname & enddisc. If it succeeded, it listen()ed and became MP server. If it failed, it connect()ed and became MP client. The server then select()ed on the descriptor, accept()ed it and wrote its pid to it then read the link data & link file descriptor, and finally sent an ack (``!''). The client would read() the server pid, transfer the link lock to that pid, send the link data & descriptor and read the ack. It would then close the descriptor and clean up. There was a race between the bind() and listen() where someone could attempt to connect() and fail. This change removes the race. Now ppp makes the RCVBUF big enough on a socket descriptor and attempts to bind() to a local domain *udp* socket (same name as before). If it succeeds, it becomes MP server. If it fails, it sets the SNDBUF and connect()s, becoming MP client. The server select()s on the descriptor and recvmsg()s the message, insisting on at least two descriptors (plus the link data). It uses the second descriptor to write() its pid then read()s an ack (``!''). The client creates a socketpair() and sendmsg()s the link data, link descriptor and one of the socketpair descriptors. It then read()s the server pid from the other socketpair descriptor, transfers any locks and write()s an ack. Now, there can be no race, and a connect() failure indicates a stale socket file. This also fixes MP ppp over ethernet, where the struct msghdr was being misconstructed when transferring the control socket descriptor. Also, if we fail to send the link, don't hang around in a ``session owner'' state, just do the setsid() and fork() if it's required to disown a tty. UDP idea suggested by: Chris Bennet from Mindspring at FreeBSDCon
1999-11-25 02:47:04 +00:00
int *);
extern const char *physical_LockedDevice(struct physical *);
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
extern void physical_ChangedPid(struct physical *, pid_t);
Create a new MP branch for `multilink protocol'. Do lots of initial shuffling and grouping. Submitted by: Eivind Eklund <perhaps@yes.no>
1998-01-29 00:49:32 +00:00
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
extern int physical_IsSync(struct physical *);
extern const char *physical_GetDevice(struct physical *);
extern void physical_SetDeviceList(struct physical *, int, const char *const *);
extern void physical_SetDevice(struct physical *, const char *);
Cosmetic: Make our external function names consistent.
1998-05-01 19:26:12 +00:00
extern ssize_t physical_Read(struct physical *, void *, size_t);
extern ssize_t physical_Write(struct physical *, const void *, size_t);
o Redesign the layering mechanism and make the aliasing code part of the layering. We now ``stack'' layers as soon as we open the device (when we figure out what we're dealing with). A static set of `dispatch' routines are also declared for dealing with incoming packets after they've been `pulled' up through the stacked layers. Physical devices are now assigned handlers based on the device type when they're opened. For the moment there are three device types; ttys, execs and tcps. o Increment version number to 2.2 o Make an entry in [uw]tmp for non-tty -direct invocations (after pap/chap authentication). o Make throughput counters quad_t's o Account for the absolute number of mbuf malloc()s and free()s in ``show mem''. o ``show modem'' becomes ``show physical''.
1999-05-08 11:07:56 +00:00
extern int physical_doUpdateSet(struct descriptor *, fd_set *, fd_set *,
fd_set *, int *, int);
Cosmetic: Make our external function names consistent.
1998-05-01 19:26:12 +00:00
extern int physical_IsSet(struct descriptor *, const fd_set *);
Support PPPoE Help (lots) from: julian, archie Facilities from: ahebert@pubnix.net
1999-11-06 22:50:59 +00:00
extern void physical_DescriptorRead(struct descriptor *, struct bundle *,
const fd_set *);
Cosmetic: Make our external function names consistent.
1998-05-01 19:26:12 +00:00
extern void physical_Login(struct physical *, const char *);
o Call bundle_LinkClosed() when transferring a datalink so that the bundle has the opportunity to go PHASE_DEAD and cleanup the interface (if it's the last link). o Regnerate our phys_type value when we transfer the link. o Always clean up the interface when destroying our bundle in case we're abending. o Always clean up our interface when the last link is gone rather than delaying things 'till exit time in the -direct case (the interface is useless anyway). Do this *after* slamming down our NCPs (if they're still around). o Our MP server descriptor now clears the relevent device descriptor from our descriptor [fd]sets when a datalink is on death-row (to be transferred to another running ppp), thus avoiding the possibility of passing a bum descriptor to select() and having ppp abend. o Handle the MP socket descriptor functions from within the bundle descriptor functions. Now we ensure that the MP socket descriptor functions see the descriptor sets *after* they've been seen by our datalinks. o Add/fix a few more comments.
1998-05-15 18:21:45 +00:00
extern int physical_RemoveFromSet(struct physical *, fd_set *, fd_set *,
fd_set *);
o Add the `set mode' command for change a links current mode. It is not possible to switch to or from dedicated or direct mode, but all other combinations are ok (eg. -auto -> -ddial). o Cope with the fact that commands with optional context may not be able to obtain a link with command_ChooseLink() (if all links have been deleted for example). o Allow `clone'ing in non-multilink mode. We may for example want to configure two links in unilink mode and dial them both, using the one that comes up first. It's also possible to rename ``deflink'' by cloning it, deleting the original, then setting the mode of the new link.
1998-05-15 23:58:30 +00:00
extern int physical_SetMode(struct physical *, int);
If we've got a full output buffer queue and cannot send anything for two mintues (see ``set choked'' and ``show bundle''), nuke the ip, mp and link level buffer queues. This should fix problems where ``ppp -auto'' seems to stop responding after failing to connect to the peer a few times.
1998-08-25 17:48:43 +00:00
extern void physical_DeleteQueue(struct physical *);
Correct the ``ignoring sync/async'' warnings so that they show up with the correct device type. Reassign the correct tcpdevice or execdevice after transfering a link in MP server mode.
1999-05-24 16:39:17 +00:00
extern void physical_SetupStack(struct physical *, const char *, int);
Allow ``host:port/udp'' devices and support ``host:port/tcp'' as being the same as the previous (still supported) ``host:port'' syntax for tcp socket devices. A udp device uses synchronous ppp rather than async, and avoids the double-retransmit overhead that comes with ppp over tcp (it's usually a bad idea to transport IP over a reliable transport that itself is using an unreliable transport). PPP over UDP provides througput of ** 1.5Mb per second ** with all compression disabled, maxing out a PPro/200 when running ppp twice, back-to-back. This proves that PPPoE is plausable in userland.... This change adds a few more handler functions to struct device and allows derivations of struct device (which may contain their own data etc) to pass themselves through the unix domain socket for MP. ** At last **, struct physical has lost all the tty crud ! iov2physical() is now smart enough to restore the correct stack of layers so that MP servers will work again. The version number has bumped as our MP link transfer contents have changed (they now may contain a `struct device'). Don't extract the protocol twice in MP mode (resulting in protocol rejects for every MP packet). This was broken with my original layering changes. Add ``Physical'' and ``Sync'' log levels for logging the relevent raw packets and add protocol-tracking LogDEBUG stuff in various LayerPush & LayerPull functions. Assign our physical device name for incoming tcp connections by calling getpeername(). Assign our physical device name for incoming udp connections from the address retrieved by the first recvfrom().
1999-05-12 09:49:12 +00:00
extern void physical_StopDeviceTimer(struct physical *);
Correct the way ppp transfers links on the server side in MP mode by padding out the ``struct device'' to the maximum device size. Bump the ppp version number to indicate the transfer format change. This should make MP over tty and udp devices functional again.
1999-06-05 21:36:00 +00:00
extern int physical_MaxDeviceSize(void);
Add ISDN support via isdnd & i4b. This requires version 0.81.1 of the i4b code - namely support of the I4B_VR_REQ ioctl via the i4brbchX device. Ppp controls the phone number, but idle timers and SYNC/RAW decisions are still made by isdnd (in isdnd.rc). This involves a new datalink state machine phase. The ``wait for carrier'' phase happens after dialing but before logging in. The whole dial state should really be abstracted so that each device type can deal with it in its own way (thinking about PPPoE) - but that'll have to wait. The ``set cd'' symantics remain the same for tty devices, but we now delay until we either get CD or timeout waiting (at which time we drop the link if we require CD). For i4b devices we always insist on carrier. Thanks to hm@ for his help, and especially for pointing out that I *don't* need to re-implement isdnd (that was a huge waste of time !) :-]
1999-08-06 20:04:08 +00:00
extern int physical_AwaitCarrier(struct physical *);
Support PPPoE Help (lots) from: julian, archie Facilities from: ahebert@pubnix.net
1999-11-06 22:50:59 +00:00
extern void physical_SetDescriptor(struct physical *);
Reference in New Issue Copy Permalink