2 * Written by Eivind Eklund <eivind@yes.no>
5 * Copyright (C) 1998, Yes Interactive. All rights reserved.
7 * Redistribution and use in any form is permitted. Redistribution in
8 * source form should include the above copyright and this set of
9 * conditions, because large sections american law seems to have been
10 * created by a bunch of jerks on drugs that are now illegal, forcing
11 * me to include this copyright-stuff instead of placing this in the
12 * public domain. The name of of 'Yes Interactive' or 'Eivind Eklund'
13 * may not be used to endorse or promote products derived from this
14 * software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
23 #include <sys/param.h>
24 #include <netinet/in.h>
25 #include <netinet/in_systm.h>
26 #include <netinet/ip.h>
27 #include <sys/socket.h>
47 #if defined(__OpenBSD__) || defined(__NetBSD__)
48 #include <sys/ioctl.h>
71 #include "throughput.h"
75 #include "slcompress.h"
79 #include "descriptor.h"
103 #include "netgraph.h"
110 static int physical_DescriptorWrite(struct fdescriptor
*, struct bundle
*,
114 physical_DeviceSize(void)
116 return sizeof(struct device
);
120 struct device
*(*create
)(struct physical
*);
121 struct device
*(*iov2device
)(int, struct physical
*, struct iovec
*,
122 int *, int, int *, int *);
123 unsigned (*DeviceSize
)(void);
125 { tty_Create
, tty_iov2device
, tty_DeviceSize
},
128 * This must come before ``udp'' so that the probe routine is
129 * able to identify it as a more specific type of SOCK_DGRAM.
131 { ether_Create
, ether_iov2device
, ether_DeviceSize
},
132 #ifdef EXPERIMENTAL_NETGRAPH
133 { ng_Create
, ng_iov2device
, ng_DeviceSize
},
137 /* Ditto for ATM devices */
138 { atm_Create
, atm_iov2device
, atm_DeviceSize
},
140 { tcp_Create
, tcp_iov2device
, tcp_DeviceSize
},
141 { udp_Create
, udp_iov2device
, udp_DeviceSize
},
142 { exec_Create
, exec_iov2device
, exec_DeviceSize
}
145 #define NDEVICES (sizeof devices / sizeof devices[0])
148 physical_UpdateSet(struct fdescriptor
*d
, fd_set
*r
, fd_set
*w
, fd_set
*e
,
151 return physical_doUpdateSet(d
, r
, w
, e
, n
, 0);
155 physical_SetDescriptor(struct physical
*p
)
157 p
->desc
.type
= PHYSICAL_DESCRIPTOR
;
158 p
->desc
.UpdateSet
= physical_UpdateSet
;
159 p
->desc
.IsSet
= physical_IsSet
;
160 p
->desc
.Read
= physical_DescriptorRead
;
161 p
->desc
.Write
= physical_DescriptorWrite
;
165 physical_Create(struct datalink
*dl
, int type
)
169 p
= (struct physical
*)malloc(sizeof(struct physical
));
173 p
->link
.type
= PHYSICAL_LINK
;
174 p
->link
.name
= dl
->name
;
175 p
->link
.len
= sizeof *p
;
177 /* The sample period is fixed - see physical2iov() & iov2physical() */
178 throughput_init(&p
->link
.stats
.total
, SAMPLE_PERIOD
);
179 p
->link
.stats
.parent
= dl
->bundle
->ncp
.mp
.active
?
180 &dl
->bundle
->ncp
.mp
.link
.stats
.total
: NULL
;
181 p
->link
.stats
.gather
= 1;
183 memset(p
->link
.Queue
, '\0', sizeof p
->link
.Queue
);
184 memset(p
->link
.proto_in
, '\0', sizeof p
->link
.proto_in
);
185 memset(p
->link
.proto_out
, '\0', sizeof p
->link
.proto_out
);
186 link_EmptyStack(&p
->link
);
189 physical_SetDescriptor(p
);
192 hdlc_Init(&p
->hdlc
, &p
->link
.lcp
);
193 async_Init(&p
->async
);
197 p
->connect_count
= 0;
200 *p
->name
.full
= '\0';
201 p
->name
.base
= p
->name
.full
;
204 p
->session_owner
= (pid_t
)-1;
206 p
->cfg
.rts_cts
= MODEM_CTSRTS
;
207 p
->cfg
.speed
= MODEM_SPEED
;
209 memcpy(p
->cfg
.devlist
, MODEM_LIST
, sizeof MODEM_LIST
);
210 p
->cfg
.ndev
= NMODEMS
;
211 p
->cfg
.cd
.necessity
= CD_DEFAULT
;
212 p
->cfg
.cd
.delay
= 0; /* reconfigured or device specific default */
214 lcp_Init(&p
->link
.lcp
, dl
->bundle
, &p
->link
, &dl
->fsmp
);
215 ccp_Init(&p
->link
.ccp
, dl
->bundle
, &p
->link
, &dl
->fsmp
);
220 static const struct parity
{
225 { "even", "P_EVEN", CS7
| PARENB
},
226 { "odd", "P_ODD", CS7
| PARENB
| PARODD
},
227 { "none", "P_ZERO", CS8
},
232 GetParityValue(const char *str
)
234 const struct parity
*pp
;
236 for (pp
= validparity
; pp
->name
; pp
++) {
237 if (strcasecmp(pp
->name
, str
) == 0 ||
238 strcasecmp(pp
->name1
, str
) == 0) {
246 physical_SetParity(struct physical
*p
, const char *str
)
248 struct termios rstio
;
251 val
= GetParityValue(str
);
255 tcgetattr(p
->fd
, &rstio
);
256 rstio
.c_cflag
&= ~(CSIZE
| PARODD
| PARENB
);
257 rstio
.c_cflag
|= val
;
258 tcsetattr(p
->fd
, TCSADRAIN
, &rstio
);
262 log_Printf(LogWARN
, "%s: %s: Invalid parity\n", p
->link
.name
, str
);
267 physical_GetSpeed(struct physical
*p
)
269 if (p
->handler
&& p
->handler
->speed
)
270 return (*p
->handler
->speed
)(p
);
276 physical_SetSpeed(struct physical
*p
, unsigned speed
)
278 if (UnsignedToSpeed(speed
) != B0
) {
279 p
->cfg
.speed
= speed
;
287 physical_Raw(struct physical
*p
)
289 if (p
->handler
&& p
->handler
->raw
)
290 return (*p
->handler
->raw
)(p
);
296 physical_Offline(struct physical
*p
)
298 if (p
->handler
&& p
->handler
->offline
)
299 (*p
->handler
->offline
)(p
);
300 log_Printf(LogPHASE
, "%s: Disconnected!\n", p
->link
.name
);
304 physical_Lock(struct physical
*p
)
308 if (*p
->name
.full
== '/' && p
->type
!= PHYS_DIRECT
&&
309 (res
= ID0uu_lock(p
->name
.base
)) != UU_LOCK_OK
) {
310 if (res
== UU_LOCK_INUSE
)
311 log_Printf(LogPHASE
, "%s: %s is in use\n", p
->link
.name
, p
->name
.full
);
313 log_Printf(LogPHASE
, "%s: %s is in use: uu_lock: %s\n",
314 p
->link
.name
, p
->name
.full
, uu_lockerr(res
));
322 physical_Unlock(struct physical
*p
)
324 if (*p
->name
.full
== '/' && p
->type
!= PHYS_DIRECT
&&
325 ID0uu_unlock(p
->name
.base
) == -1)
326 log_Printf(LogALERT
, "%s: Can't uu_unlock %s\n", p
->link
.name
,
331 physical_Close(struct physical
*p
)
340 log_Printf(LogDEBUG
, "%s: Close\n", p
->link
.name
);
342 if (p
->handler
&& p
->handler
->cooked
)
343 (*p
->handler
->cooked
)(p
);
345 physical_StopDeviceTimer(p
);
347 memset(&ut
, 0, sizeof ut
);
348 ut
.ut_type
= DEAD_PROCESS
;
349 gettimeofday(&ut
.ut_tv
, NULL
);
350 snprintf(ut
.ut_id
, sizeof ut
.ut_id
, "%xppp", (int)getpid());
354 newsid
= tcgetpgrp(p
->fd
) == getpgrp();
357 log_SetTtyCommandMode(p
->dl
);
359 throughput_stop(&p
->link
.stats
.total
);
360 throughput_log(&p
->link
.stats
.total
, LogPHASE
, p
->link
.name
);
362 if (p
->session_owner
!= (pid_t
)-1) {
363 log_Printf(LogPHASE
, "%s: HUPing %ld\n", p
->link
.name
,
364 (long)p
->session_owner
);
365 ID0kill(p
->session_owner
, SIGHUP
);
366 p
->session_owner
= (pid_t
)-1;
370 bundle_setsid(p
->dl
->bundle
, 0);
372 if (*p
->name
.full
== '/') {
373 snprintf(fn
, sizeof fn
, "%s%s.if", _PATH_VARRUN
, p
->name
.base
);
374 #ifndef RELEASE_CRUNCH
375 if (ID0unlink(fn
) == -1)
376 log_Printf(LogALERT
, "%s: Can't remove %s: %s\n",
377 p
->link
.name
, fn
, strerror(errno
));
383 if (p
->handler
&& p
->handler
->destroy
)
384 (*p
->handler
->destroy
)(p
);
386 p
->name
.base
= p
->name
.full
;
387 *p
->name
.full
= '\0';
391 physical_Destroy(struct physical
*p
)
394 throughput_destroy(&p
->link
.stats
.total
);
399 physical_DescriptorWrite(struct fdescriptor
*d
, struct bundle
*bundle __unused
,
400 const fd_set
*fdset __unused
)
402 struct physical
*p
= descriptor2physical(d
);
406 p
->out
= link_Dequeue(&p
->link
);
409 nw
= physical_Write(p
, MBUF_CTOP(p
->out
), p
->out
->m_len
);
410 log_Printf(LogDEBUG
, "%s: DescriptorWrite: wrote %d(%lu) to %d\n",
411 p
->link
.name
, nw
, (unsigned long)p
->out
->m_len
, p
->fd
);
414 p
->out
->m_offset
+= nw
;
415 if (p
->out
->m_len
== 0)
416 p
->out
= m_free(p
->out
);
421 else if (errno
!= ENOBUFS
) {
422 log_Printf(LogPHASE
, "%s: write (fd %d, len %zd): %s\n", p
->link
.name
,
423 p
->fd
, p
->out
->m_len
, strerror(errno
));
424 datalink_Down(p
->dl
, CLOSE_NORMAL
);
427 /* else we shouldn't really have been called ! select() is broken ! */
434 physical_ShowStatus(struct cmdargs
const *arg
)
436 struct physical
*p
= arg
->cx
->physical
;
441 prompt_Printf(arg
->prompt
, "Name: %s\n", p
->link
.name
);
442 prompt_Printf(arg
->prompt
, " State: ");
444 prompt_Printf(arg
->prompt
, "closed\n");
446 slot
= physical_Slot(p
);
447 if (p
->handler
&& p
->handler
->openinfo
) {
449 prompt_Printf(arg
->prompt
, "open (%s)\n", (*p
->handler
->openinfo
)(p
));
451 prompt_Printf(arg
->prompt
, "open (%s, port %d)\n",
452 (*p
->handler
->openinfo
)(p
), slot
);
453 } else if (slot
== -1)
454 prompt_Printf(arg
->prompt
, "open\n");
456 prompt_Printf(arg
->prompt
, "open (port %d)\n", slot
);
459 prompt_Printf(arg
->prompt
, " Device: %s",
460 *p
->name
.full
? p
->name
.full
:
461 p
->type
== PHYS_DIRECT
? "unknown" : "N/A");
462 if (p
->session_owner
!= (pid_t
)-1)
463 prompt_Printf(arg
->prompt
, " (session owner: %ld)", (long)p
->session_owner
);
465 prompt_Printf(arg
->prompt
, "\n Link Type: %s\n", mode2Nam(p
->type
));
466 prompt_Printf(arg
->prompt
, " Connect Count: %d\n", p
->connect_count
);
468 if (p
->fd
>= 0 && ioctl(p
->fd
, TIOCOUTQ
, &n
) >= 0)
469 prompt_Printf(arg
->prompt
, " Physical outq: %d\n", n
);
472 prompt_Printf(arg
->prompt
, " Queued Packets: %lu\n",
473 (u_long
)link_QueueLen(&p
->link
));
474 prompt_Printf(arg
->prompt
, " Phone Number: %s\n", arg
->cx
->phone
.chosen
);
476 prompt_Printf(arg
->prompt
, "\nDefaults:\n");
478 prompt_Printf(arg
->prompt
, " Device List: ");
479 dev
= p
->cfg
.devlist
;
480 for (n
= 0; n
< p
->cfg
.ndev
; n
++) {
482 prompt_Printf(arg
->prompt
, ", ");
483 prompt_Printf(arg
->prompt
, "\"%s\"", dev
);
484 dev
+= strlen(dev
) + 1;
487 prompt_Printf(arg
->prompt
, "\n Characteristics: ");
488 if (physical_IsSync(arg
->cx
->physical
))
489 prompt_Printf(arg
->prompt
, "sync");
491 prompt_Printf(arg
->prompt
, "%dbps", p
->cfg
.speed
);
493 switch (p
->cfg
.parity
& CSIZE
) {
495 prompt_Printf(arg
->prompt
, ", cs7");
498 prompt_Printf(arg
->prompt
, ", cs8");
501 if (p
->cfg
.parity
& PARENB
) {
502 if (p
->cfg
.parity
& PARODD
)
503 prompt_Printf(arg
->prompt
, ", odd parity");
505 prompt_Printf(arg
->prompt
, ", even parity");
507 prompt_Printf(arg
->prompt
, ", no parity");
509 prompt_Printf(arg
->prompt
, ", CTS/RTS %s\n", (p
->cfg
.rts_cts
? "on" : "off"));
511 prompt_Printf(arg
->prompt
, " CD check delay: ");
512 cd
= p
->handler
? &p
->handler
->cd
: &p
->cfg
.cd
;
513 if (cd
->necessity
== CD_NOTREQUIRED
)
514 prompt_Printf(arg
->prompt
, "no cd");
515 else if (p
->cfg
.cd
.necessity
== CD_DEFAULT
) {
516 prompt_Printf(arg
->prompt
, "device specific");
518 prompt_Printf(arg
->prompt
, "%d second%s", p
->cfg
.cd
.delay
,
519 p
->cfg
.cd
.delay
== 1 ? "" : "s");
520 if (p
->cfg
.cd
.necessity
== CD_REQUIRED
)
521 prompt_Printf(arg
->prompt
, " (required!)");
523 prompt_Printf(arg
->prompt
, "\n\n");
525 throughput_disp(&p
->link
.stats
.total
, arg
->prompt
);
531 physical_DescriptorRead(struct fdescriptor
*d
, struct bundle
*bundle
,
532 const fd_set
*fdset __unused
)
534 struct physical
*p
= descriptor2physical(d
);
538 rbuff
= p
->input
.buf
+ p
->input
.sz
;
540 /* something to read */
541 n
= physical_Read(p
, rbuff
, sizeof p
->input
.buf
- p
->input
.sz
);
542 log_Printf(LogDEBUG
, "%s: DescriptorRead: read %d/%d from %d\n",
543 p
->link
.name
, n
, (int)(sizeof p
->input
.buf
- p
->input
.sz
), p
->fd
);
546 log_Printf(LogPHASE
, "%s: read (%d): %s\n", p
->link
.name
, p
->fd
,
549 log_Printf(LogPHASE
, "%s: read (%d): Got zero bytes\n",
550 p
->link
.name
, p
->fd
);
551 datalink_Down(p
->dl
, CLOSE_NORMAL
);
555 rbuff
-= p
->input
.sz
;
558 if (p
->link
.lcp
.fsm
.state
<= ST_CLOSED
) {
559 if (p
->type
!= PHYS_DEDICATED
) {
560 found
= hdlc_Detect((u_char
const **)&rbuff
, n
, physical_IsSync(p
));
561 if (rbuff
!= p
->input
.buf
)
562 log_WritePrompts(p
->dl
, "%.*s", (int)(rbuff
- p
->input
.buf
),
564 p
->input
.sz
= n
- (rbuff
- p
->input
.buf
);
567 /* LCP packet is detected. Turn ourselves into packet mode */
568 log_Printf(LogPHASE
, "%s: PPP packet detected, coming up\n",
570 log_SetTtyCommandMode(p
->dl
);
571 datalink_Up(p
->dl
, 0, 1);
572 link_PullPacket(&p
->link
, rbuff
, p
->input
.sz
, bundle
);
575 bcopy(rbuff
, p
->input
.buf
, p
->input
.sz
);
577 /* In -dedicated mode, we just discard input until LCP is started */
580 link_PullPacket(&p
->link
, rbuff
, n
, bundle
);
584 iov2physical(struct datalink
*dl
, struct iovec
*iov
, int *niov
, int maxiov
,
585 int fd
, int *auxfd
, int *nauxfd
)
591 p
= (struct physical
*)iov
[(*niov
)++].iov_base
;
592 p
->link
.name
= dl
->name
;
593 memset(p
->link
.Queue
, '\0', sizeof p
->link
.Queue
);
595 p
->desc
.UpdateSet
= physical_UpdateSet
;
596 p
->desc
.IsSet
= physical_IsSet
;
597 p
->desc
.Read
= physical_DescriptorRead
;
598 p
->desc
.Write
= physical_DescriptorWrite
;
599 p
->type
= PHYS_DIRECT
;
602 p
->connect_count
= 1;
604 physical_SetDevice(p
, p
->name
.full
);
606 p
->link
.lcp
.fsm
.bundle
= dl
->bundle
;
607 p
->link
.lcp
.fsm
.link
= &p
->link
;
608 memset(&p
->link
.lcp
.fsm
.FsmTimer
, '\0', sizeof p
->link
.lcp
.fsm
.FsmTimer
);
609 memset(&p
->link
.lcp
.fsm
.OpenTimer
, '\0', sizeof p
->link
.lcp
.fsm
.OpenTimer
);
610 memset(&p
->link
.lcp
.fsm
.StoppedTimer
, '\0',
611 sizeof p
->link
.lcp
.fsm
.StoppedTimer
);
612 p
->link
.lcp
.fsm
.parent
= &dl
->fsmp
;
613 lcp_SetupCallbacks(&p
->link
.lcp
);
615 p
->link
.ccp
.fsm
.bundle
= dl
->bundle
;
616 p
->link
.ccp
.fsm
.link
= &p
->link
;
617 /* Our in.state & out.state are NULL (no link-level ccp yet) */
618 memset(&p
->link
.ccp
.fsm
.FsmTimer
, '\0', sizeof p
->link
.ccp
.fsm
.FsmTimer
);
619 memset(&p
->link
.ccp
.fsm
.OpenTimer
, '\0', sizeof p
->link
.ccp
.fsm
.OpenTimer
);
620 memset(&p
->link
.ccp
.fsm
.StoppedTimer
, '\0',
621 sizeof p
->link
.ccp
.fsm
.StoppedTimer
);
622 p
->link
.ccp
.fsm
.parent
= &dl
->fsmp
;
623 ccp_SetupCallbacks(&p
->link
.ccp
);
625 p
->hdlc
.lqm
.owner
= &p
->link
.lcp
;
626 p
->hdlc
.ReportTimer
.state
= TIMER_STOPPED
;
627 p
->hdlc
.lqm
.timer
.state
= TIMER_STOPPED
;
630 p
->link
.stats
.total
.in
.SampleOctets
= (long long *)iov
[(*niov
)++].iov_base
;
631 p
->link
.stats
.total
.out
.SampleOctets
= (long long *)iov
[(*niov
)++].iov_base
;
632 p
->link
.stats
.parent
= dl
->bundle
->ncp
.mp
.active
?
633 &dl
->bundle
->ncp
.mp
.link
.stats
.total
: NULL
;
634 p
->link
.stats
.gather
= 1;
636 type
= (long)p
->handler
;
638 for (h
= 0; h
< NDEVICES
&& p
->handler
== NULL
; h
++)
639 p
->handler
= (*devices
[h
].iov2device
)(type
, p
, iov
, niov
, maxiov
,
641 if (p
->handler
== NULL
) {
642 log_Printf(LogPHASE
, "%s: Unknown link type\n", p
->link
.name
);
643 free(iov
[(*niov
)++].iov_base
);
644 physical_SetupStack(p
, "unknown", PHYSICAL_NOFORCE
);
646 log_Printf(LogPHASE
, "%s: Device %s, link type is %s\n",
647 p
->link
.name
, p
->name
.full
, p
->handler
->name
);
649 if (p
->hdlc
.lqm
.method
&& p
->hdlc
.lqm
.timer
.load
)
650 lqr_reStart(&p
->link
.lcp
);
651 hdlc_StartTimer(&p
->hdlc
);
653 throughput_restart(&p
->link
.stats
.total
, "physical throughput",
654 Enabled(dl
->bundle
, OPT_THROUGHPUT
));
660 physical_MaxDeviceSize()
662 unsigned biggest
, sz
, n
;
664 biggest
= sizeof(struct device
);
665 for (n
= 0; n
< NDEVICES
; n
++)
666 if (devices
[n
].DeviceSize
) {
667 sz
= (*devices
[n
].DeviceSize
)();
676 physical2iov(struct physical
*p
, struct iovec
*iov
, int *niov
, int maxiov
,
677 int *auxfd
, int *nauxfd
)
684 hdlc_StopTimer(&p
->hdlc
);
686 timer_Stop(&p
->link
.lcp
.fsm
.FsmTimer
);
687 timer_Stop(&p
->link
.ccp
.fsm
.FsmTimer
);
688 timer_Stop(&p
->link
.lcp
.fsm
.OpenTimer
);
689 timer_Stop(&p
->link
.ccp
.fsm
.OpenTimer
);
690 timer_Stop(&p
->link
.lcp
.fsm
.StoppedTimer
);
691 timer_Stop(&p
->link
.ccp
.fsm
.StoppedTimer
);
694 p
->handler
= (struct device
*)(long)p
->handler
->type
;
697 if (Enabled(p
->dl
->bundle
, OPT_KEEPSESSION
) ||
698 tcgetpgrp(p
->fd
) == getpgrp())
699 p
->session_owner
= getpid(); /* So I'll eventually get HUP'd */
701 p
->session_owner
= (pid_t
)-1;
702 timer_Stop(&p
->link
.stats
.total
.Timer
);
705 if (*niov
+ 2 >= maxiov
) {
706 log_Printf(LogERROR
, "physical2iov: No room for physical + throughput"
713 iov
[*niov
].iov_base
= (void *)p
;
714 iov
[*niov
].iov_len
= sizeof *p
;
717 iov
[*niov
].iov_base
= p
? (void *)p
->link
.stats
.total
.in
.SampleOctets
: NULL
;
718 iov
[*niov
].iov_len
= SAMPLE_PERIOD
* sizeof(long long);
720 iov
[*niov
].iov_base
= p
? (void *)p
->link
.stats
.total
.out
.SampleOctets
: NULL
;
721 iov
[*niov
].iov_len
= SAMPLE_PERIOD
* sizeof(long long);
724 sz
= physical_MaxDeviceSize();
726 if (h
&& h
->device2iov
)
727 (*h
->device2iov
)(h
, iov
, niov
, maxiov
, auxfd
, nauxfd
);
729 if ((iov
[*niov
].iov_base
= malloc(sz
)) == NULL
) {
730 log_Printf(LogALERT
, "physical2iov: Out of memory (%d bytes)\n", sz
);
731 AbortProgram(EX_OSERR
);
734 memcpy(iov
[*niov
].iov_base
, h
, sizeof *h
);
735 iov
[*niov
].iov_len
= sz
;
739 iov
[*niov
].iov_base
= NULL
;
740 iov
[*niov
].iov_len
= sz
;
744 return p
? p
->fd
: 0;
748 physical_LockedDevice(struct physical
*p
)
750 if (p
->fd
>= 0 && *p
->name
.full
== '/' && p
->type
!= PHYS_DIRECT
)
757 physical_ChangedPid(struct physical
*p
, pid_t newpid
)
759 if (physical_LockedDevice(p
)) {
762 if ((res
= ID0uu_lock_txfr(p
->name
.base
, newpid
)) != UU_LOCK_OK
)
763 log_Printf(LogPHASE
, "uu_lock_txfr: %s\n", uu_lockerr(res
));
768 physical_IsSync(struct physical
*p
)
770 return p
->cfg
.speed
== 0;
774 physical_DeviceMTU(struct physical
*p
)
776 return p
->handler
? p
->handler
->mtu
: 0;
779 const char *physical_GetDevice(struct physical
*p
)
785 physical_SetDeviceList(struct physical
*p
, int argc
, const char *const *argv
)
790 p
->cfg
.devlist
[sizeof p
->cfg
.devlist
- 1] = '\0';
791 for (f
= 0, pos
= 0; f
< argc
&& pos
< sizeof p
->cfg
.devlist
- 1; f
++) {
793 p
->cfg
.devlist
[pos
++] = '\0';
794 strncpy(p
->cfg
.devlist
+ pos
, argv
[f
], sizeof p
->cfg
.devlist
- pos
- 1);
795 pos
+= strlen(p
->cfg
.devlist
+ pos
);
801 physical_SetSync(struct physical
*p
)
807 physical_SetRtsCts(struct physical
*p
, int enable
)
809 p
->cfg
.rts_cts
= enable
? 1 : 0;
814 physical_Read(struct physical
*p
, void *buf
, size_t nbytes
)
818 if (p
->handler
&& p
->handler
->read
)
819 ret
= (*p
->handler
->read
)(p
, buf
, nbytes
);
821 ret
= read(p
->fd
, buf
, nbytes
);
823 log_DumpBuff(LogPHYSICAL
, "read", buf
, ret
);
829 physical_Write(struct physical
*p
, const void *buf
, size_t nbytes
)
831 log_DumpBuff(LogPHYSICAL
, "write", buf
, nbytes
);
833 if (p
->handler
&& p
->handler
->write
)
834 return (*p
->handler
->write
)(p
, buf
, nbytes
);
836 return write(p
->fd
, buf
, nbytes
);
840 physical_doUpdateSet(struct fdescriptor
*d
, fd_set
*r
, fd_set
*w
, fd_set
*e
,
843 struct physical
*p
= descriptor2physical(d
);
850 log_Printf(LogTIMER
, "%s: fdset(r) %d\n", p
->link
.name
, p
->fd
);
855 log_Printf(LogTIMER
, "%s: fdset(e) %d\n", p
->link
.name
, p
->fd
);
858 if (w
&& (force
|| link_QueueLen(&p
->link
) || p
->out
)) {
860 log_Printf(LogTIMER
, "%s: fdset(w) %d\n", p
->link
.name
, p
->fd
);
863 if (sets
&& *n
< p
->fd
+ 1)
871 physical_RemoveFromSet(struct physical
*p
, fd_set
*r
, fd_set
*w
, fd_set
*e
)
873 if (p
->handler
&& p
->handler
->removefromset
)
874 return (*p
->handler
->removefromset
)(p
, r
, w
, e
);
880 if (r
&& FD_ISSET(p
->fd
, r
)) {
882 log_Printf(LogTIMER
, "%s: fdunset(r) %d\n", p
->link
.name
, p
->fd
);
885 if (e
&& FD_ISSET(p
->fd
, e
)) {
887 log_Printf(LogTIMER
, "%s: fdunset(e) %d\n", p
->link
.name
, p
->fd
);
890 if (w
&& FD_ISSET(p
->fd
, w
)) {
892 log_Printf(LogTIMER
, "%s: fdunset(w) %d\n", p
->link
.name
, p
->fd
);
902 physical_IsSet(struct fdescriptor
*d
, const fd_set
*fdset
)
904 struct physical
*p
= descriptor2physical(d
);
905 return p
->fd
>= 0 && FD_ISSET(p
->fd
, fdset
);
909 physical_Login(struct physical
*p
, const char *name
)
911 if (p
->type
== PHYS_DIRECT
&& *p
->name
.base
&& !p
->Utmp
) {
916 memset(&ut
, 0, sizeof ut
);
917 ut
.ut_type
= USER_PROCESS
;
918 gettimeofday(&ut
.ut_tv
, NULL
);
919 snprintf(ut
.ut_id
, sizeof ut
.ut_id
, "%xppp", (int)getpid());
920 strncpy(ut
.ut_user
, name
, sizeof ut
.ut_user
);
921 if (p
->handler
&& (p
->handler
->type
== TCP_DEVICE
||
922 p
->handler
->type
== UDP_DEVICE
)) {
923 strncpy(ut
.ut_host
, p
->name
.base
, sizeof ut
.ut_host
);
924 colon
= memchr(ut
.ut_host
, ':', sizeof ut
.ut_host
);
928 strncpy(ut
.ut_line
, p
->name
.base
, sizeof ut
.ut_line
);
929 if ((connstr
= getenv("CONNECT")))
930 /* mgetty sets this to the connection speed */
931 strncpy(ut
.ut_host
, connstr
, sizeof ut
.ut_host
);
938 physical_SetMode(struct physical
*p
, int mode
)
940 if ((p
->type
& (PHYS_DIRECT
|PHYS_DEDICATED
) ||
941 mode
& (PHYS_DIRECT
|PHYS_DEDICATED
)) &&
942 (!(p
->type
& PHYS_DIRECT
) || !(mode
& PHYS_BACKGROUND
))) {
943 /* Note: The -direct -> -background is for callback ! */
944 log_Printf(LogWARN
, "%s: Cannot change mode %s to %s\n", p
->link
.name
,
945 mode2Nam(p
->type
), mode2Nam(mode
));
953 physical_DeleteQueue(struct physical
*p
)
959 link_DeleteQueue(&p
->link
);
963 physical_SetDevice(struct physical
*p
, const char *name
)
965 int len
= strlen(_PATH_DEV
);
967 if (name
!= p
->name
.full
) {
968 strncpy(p
->name
.full
, name
, sizeof p
->name
.full
- 1);
969 p
->name
.full
[sizeof p
->name
.full
- 1] = '\0';
971 p
->name
.base
= *p
->name
.full
== '!' ? p
->name
.full
+ 1 :
972 strncmp(p
->name
.full
, _PATH_DEV
, len
) ?
973 p
->name
.full
: p
->name
.full
+ len
;
977 physical_Found(struct physical
*p
)
982 if (*p
->name
.full
== '/') {
983 snprintf(fn
, sizeof fn
, "%s%s.if", _PATH_VARRUN
, p
->name
.base
);
984 lockfile
= ID0fopen(fn
, "w");
985 if (lockfile
!= NULL
) {
986 fprintf(lockfile
, "%s%d\n", TUN_NAME
, p
->dl
->bundle
->unit
);
989 #ifndef RELEASE_CRUNCH
991 log_Printf(LogALERT
, "%s: Can't create %s: %s\n",
992 p
->link
.name
, fn
, strerror(errno
));
996 throughput_start(&p
->link
.stats
.total
, "physical throughput",
997 Enabled(p
->dl
->bundle
, OPT_THROUGHPUT
));
1001 log_Printf(LogPHASE
, "%s: Connected!\n", p
->link
.name
);
1005 physical_Open(struct physical
*p
)
1008 int devno
, wasfd
, err
;
1012 log_Printf(LogDEBUG
, "%s: Open: Modem is already open!\n", p
->link
.name
);
1013 /* We're going back into "term" mode */
1014 else if (p
->type
== PHYS_DIRECT
) {
1015 physical_SetDevice(p
, "");
1016 p
->fd
= STDIN_FILENO
;
1017 for (h
= 0; h
< NDEVICES
&& p
->handler
== NULL
&& p
->fd
>= 0; h
++)
1018 p
->handler
= (*devices
[h
].create
)(p
);
1019 close(STDOUT_FILENO
);
1021 if (p
->handler
== NULL
) {
1022 physical_SetupStack(p
, "unknown", PHYSICAL_NOFORCE
);
1023 log_Printf(LogDEBUG
, "%s: stdin is unidentified\n", p
->link
.name
);
1028 dev
= p
->cfg
.devlist
;
1030 while (devno
< p
->cfg
.ndev
&& p
->fd
< 0) {
1031 physical_SetDevice(p
, dev
);
1032 if (physical_Lock(p
)) {
1035 if (*p
->name
.full
== '/') {
1036 p
->fd
= ID0open(p
->name
.full
, O_RDWR
| O_NONBLOCK
);
1042 for (h
= 0; h
< NDEVICES
&& p
->handler
== NULL
; h
++)
1043 if ((p
->handler
= (*devices
[h
].create
)(p
)) == NULL
&& wasfd
!= p
->fd
)
1047 if (h
== NDEVICES
) {
1049 log_Printf(LogWARN
, "%s: %s: %s\n", p
->link
.name
, p
->name
.full
,
1052 log_Printf(LogWARN
, "%s: Device (%s) must begin with a '/',"
1053 " a '!' or contain at least one ':'\n", p
->link
.name
,
1060 dev
+= strlen(dev
) + 1;
1069 physical_SetupStack(struct physical
*p
, const char *who
, int how
)
1071 link_EmptyStack(&p
->link
);
1072 if (how
== PHYSICAL_FORCE_SYNC
|| how
== PHYSICAL_FORCE_SYNCNOACF
||
1073 (how
== PHYSICAL_NOFORCE
&& physical_IsSync(p
)))
1074 link_Stack(&p
->link
, &synclayer
);
1076 link_Stack(&p
->link
, &asynclayer
);
1077 link_Stack(&p
->link
, &hdlclayer
);
1079 if (how
!= PHYSICAL_FORCE_SYNCNOACF
)
1080 link_Stack(&p
->link
, &acflayer
);
1081 link_Stack(&p
->link
, &protolayer
);
1082 link_Stack(&p
->link
, &lqrlayer
);
1083 link_Stack(&p
->link
, &ccplayer
);
1084 link_Stack(&p
->link
, &vjlayer
);
1085 link_Stack(&p
->link
, &tcpmsslayer
);
1087 link_Stack(&p
->link
, &natlayer
);
1089 if (how
== PHYSICAL_FORCE_ASYNC
&& physical_IsSync(p
)) {
1090 log_Printf(LogWARN
, "Sync device setting ignored for ``%s'' device\n", who
);
1091 p
->cfg
.speed
= MODEM_SPEED
;
1092 } else if (how
== PHYSICAL_FORCE_SYNC
&& !physical_IsSync(p
)) {
1093 log_Printf(LogWARN
, "Async device setting ignored for ``%s'' device\n",
1095 physical_SetSync(p
);
1100 physical_StopDeviceTimer(struct physical
*p
)
1102 if (p
->handler
&& p
->handler
->stoptimer
)
1103 (*p
->handler
->stoptimer
)(p
);
1107 physical_AwaitCarrier(struct physical
*p
)
1109 if (p
->handler
&& p
->handler
->awaitcarrier
)
1110 return (*p
->handler
->awaitcarrier
)(p
);
1117 physical_SetAsyncParams(struct physical
*p
, u_int32_t mymap
, u_int32_t hismap
)
1119 if (p
->handler
&& p
->handler
->setasyncparams
)
1120 return (*p
->handler
->setasyncparams
)(p
, mymap
, hismap
);
1122 async_SetLinkParams(&p
->async
, mymap
, hismap
);
1126 physical_Slot(struct physical
*p
)
1128 if (p
->handler
&& p
->handler
->slot
)
1129 return (*p
->handler
->slot
)(p
);
1135 physical_SetPPPoEnonstandard(struct physical
*p
, int enable
)
1137 p
->cfg
.nonstandard_pppoe
= enable
? 1 : 0;
1138 p
->cfg
.pppoe_configured
= 1;