#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/socketvar.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <net/if.h>
#include <net/route.h>
#include <netccitt/dll.h>
#include <netccitt/x25.h>
#include <netccitt/x25err.h>
#include <netccitt/pk.h>
#include <netccitt/pk_var.h>
int pk_sendspace = 1024 * 2 + 8;
int pk_recvspace = 1024 * 2 + 8;
struct pklcd_q pklcd_q = {&pklcd_q, &pklcd_q};
struct x25bitslice x25_bitslice[] = {
{ 0xf0, 0x4 },
{ 0xf, 0x0 },
{ 0x80, 0x7 },
{ 0x40, 0x6 },
{ 0x30, 0x4 },
{ 0xe0, 0x5 },
{ 0x10, 0x4 },
{ 0xe, 0x1 },
{ 0x1, 0x0 }
};
struct pklcd *
pk_attach (so)
struct socket *so;
{
register struct pklcd *lcp;
register int error = ENOBUFS;
int pk_output ();
MALLOC(lcp, struct pklcd *, sizeof (*lcp), M_PCB, M_NOWAIT);
if (lcp) {
bzero ((caddr_t)lcp, sizeof (*lcp));
insque (&lcp -> lcd_q, &pklcd_q);
lcp -> lcd_state = READY;
lcp -> lcd_send = pk_output;
if (so) {
error = soreserve (so, pk_sendspace, pk_recvspace);
lcp -> lcd_so = so;
if (so -> so_options & SO_ACCEPTCONN)
lcp -> lcd_state = LISTEN;
} else
sbreserve (&lcp -> lcd_sb, pk_sendspace);
}
if (so) {
so -> so_pcb = (caddr_t) lcp;
so -> so_error = error;
}
return (lcp);
}
pk_disconnect (lcp)
register struct pklcd *lcp;
{
register struct socket *so = lcp -> lcd_so;
register struct pklcd *l, *p;
switch (lcp -> lcd_state) {
case LISTEN:
for (p = 0, l = pk_listenhead; l && l != lcp; p = l, l = l -> lcd_listen);
if (p == 0) {
if (l != 0)
pk_listenhead = l -> lcd_listen;
}
else
if (l != 0)
p -> lcd_listen = l -> lcd_listen;
pk_close (lcp);
break;
case READY:
pk_acct (lcp);
pk_close (lcp);
break;
case SENT_CLEAR:
case RECEIVED_CLEAR:
break;
default:
pk_acct (lcp);
if (so) {
soisdisconnecting (so);
sbflush (&so -> so_rcv);
}
pk_clear (lcp, 241, 0);
}
}
pk_close (lcp)
struct pklcd *lcp;
{
register struct socket *so = lcp -> lcd_so;
if (so && so -> so_snd.sb_flags & SB_LOCK)
lcp -> lcd_state = LCN_ZOMBIE;
else
pk_freelcd (lcp);
if (so == NULL)
return;
so -> so_pcb = 0;
soisdisconnected (so);
}
struct mbuf *
pk_template (lcn, type)
int lcn, type;
{
register struct mbuf *m;
register struct x25_packet *xp;
MGETHDR (m, M_DONTWAIT, MT_HEADER);
if (m == 0)
panic ("pk_template");
m -> m_act = 0;
m -> m_data += max_linkhdr;
m -> m_pkthdr.len = m -> m_len = PKHEADERLN;
xp = mtod (m, struct x25_packet *);
*(long *)xp = 0;
X25SBITS(xp -> bits, fmt_identifier, 1);
SET_LCN(xp, lcn);
xp -> packet_type = type;
return (m);
}
pk_restart (pkp, restart_cause)
register struct pkcb *pkp;
int restart_cause;
{
register struct mbuf *m;
register struct pklcd *lcp;
register int i;
if (pkp -> pk_chan == 0)
return;
if (!(pkp -> pk_dxerole & DTE_CONNECTPENDING)) {
for (i = 1; i <= pkp -> pk_maxlcn; ++i)
if ((lcp = pkp -> pk_chan[i]) != NULL) {
if (lcp -> lcd_so) {
lcp -> lcd_so -> so_error = ENETRESET;
pk_close (lcp);
} else {
pk_flush (lcp);
lcp -> lcd_state = READY;
if (lcp -> lcd_upper)
lcp -> lcd_upper (lcp, 0);
}
}
}
if (restart_cause < 0)
return;
pkp -> pk_state = DTE_SENT_RESTART;
pkp -> pk_dxerole &= ~(DTE_PLAYDCE | DTE_PLAYDTE);
lcp = pkp -> pk_chan[0];
m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESTART);
m -> m_pkthdr.len = m -> m_len += 2;
mtod (m, struct x25_packet *) -> packet_data = 0;
mtod (m, octet *)[4] = restart_cause;
pk_output (lcp);
}
pk_freelcd (lcp)
register struct pklcd *lcp;
{
if (lcp == NULL)
return;
if (lcp -> lcd_lcn > 0)
lcp -> lcd_pkp -> pk_chan[lcp -> lcd_lcn] = NULL;
pk_flush (lcp);
remque (&lcp -> lcd_q);
FREE((caddr_t)lcp, M_PCB);
}
static struct x25_ifaddr *
pk_ifwithaddr (sx)
struct sockaddr_x25 *sx;
{
struct ifnet *ifp;
struct ifaddr *ifa;
register struct x25_ifaddr *ia;
char *addr = sx -> x25_addr;
for (ifp = ifnet; ifp; ifp = ifp -> if_next)
for (ifa = ifp -> if_addrlist; ifa; ifa = ifa -> ifa_next)
if (ifa -> ifa_addr -> sa_family == AF_CCITT) {
ia = (struct x25_ifaddr *)ifa;
if (bcmp (addr, ia -> ia_xc.xc_addr.x25_addr,
16) == 0)
return (ia);
}
return ((struct x25_ifaddr *)0);
}
#define XTRACTPKP(rt) ((rt) -> rt_flags & RTF_GATEWAY ? \
((rt) -> rt_llinfo ? \
(struct pkcb *) ((struct rtentry *)((rt) -> rt_llinfo)) -> rt_llinfo : \
(struct pkcb *) NULL) : \
(struct pkcb *)((rt) -> rt_llinfo))
pk_bind (lcp, nam)
struct pklcd *lcp;
struct mbuf *nam;
{
register struct pklcd *pp;
register struct sockaddr_x25 *sa;
if (nam == NULL)
return (EADDRNOTAVAIL);
if (lcp -> lcd_ceaddr)
return (EADDRINUSE);
if (pk_checksockaddr (nam))
return (EINVAL);
sa = mtod (nam, struct sockaddr_x25 *);
if (sa -> x25_addr[0]) {
if (!pk_ifwithaddr (sa))
return (ENETUNREACH);
} else if (sa -> x25_net) {
if (!ifa_ifwithnet ((struct sockaddr *)sa))
return (ENETUNREACH);
}
for (pp = pk_listenhead; pp; pp = pp -> lcd_listen) {
register struct sockaddr_x25 *sa2 = pp -> lcd_ceaddr;
if ((sa2 -> x25_udlen == sa -> x25_udlen) &&
(sa2 -> x25_udlen == 0 ||
(bcmp (sa2 -> x25_udata, sa -> x25_udata,
min (sa2 -> x25_udlen, sa -> x25_udlen)) == 0)))
return (EADDRINUSE);
}
lcp -> lcd_laddr = *sa;
lcp -> lcd_ceaddr = &lcp -> lcd_laddr;
return (0);
}
pk_listen (lcp)
register struct pklcd *lcp;
{
register struct pklcd **pp;
if (lcp -> lcd_ceaddr == 0)
return (EDESTADDRREQ);
lcp -> lcd_state = LISTEN;
if (lcp -> lcd_ceaddr -> x25_udlen == 0) {
for (pp = &pk_listenhead; *pp; )
pp = &((*pp) -> lcd_listen);
*pp = lcp;
} else {
lcp -> lcd_listen = pk_listenhead;
pk_listenhead = lcp;
}
return (0);
}
pk_protolisten (spi, spilen, callee)
int (*callee) ();
{
register struct pklcd *lcp = pk_attach ((struct socket *)0);
register struct mbuf *nam;
register struct sockaddr_x25 *sa;
int error = ENOBUFS;
if (lcp) {
if (nam = m_getclr (MT_SONAME, M_DONTWAIT)) {
sa = mtod (nam, struct sockaddr_x25 *);
sa -> x25_family = AF_CCITT;
sa -> x25_len = nam -> m_len = sizeof (*sa);
sa -> x25_udlen = spilen;
sa -> x25_udata[0] = spi;
lcp -> lcd_upper = callee;
lcp -> lcd_flags = X25_MBS_HOLD;
if ((error = pk_bind (lcp, nam)) == 0)
error = pk_listen (lcp);
(void) m_free (nam);
}
if (error)
pk_freelcd (lcp);
}
return error;
}
pk_assoc (pkp, lcp, sa)
register struct pkcb *pkp;
register struct pklcd *lcp;
register struct sockaddr_x25 *sa;
{
lcp -> lcd_pkp = pkp;
lcp -> lcd_packetsize = pkp -> pk_xcp -> xc_psize;
lcp -> lcd_windowsize = pkp -> pk_xcp -> xc_pwsize;
lcp -> lcd_rsn = MODULUS - 1;
pkp -> pk_chan[lcp -> lcd_lcn] = lcp;
if (sa -> x25_opts.op_psize)
lcp -> lcd_packetsize = sa -> x25_opts.op_psize;
else
sa -> x25_opts.op_psize = lcp -> lcd_packetsize;
if (sa -> x25_opts.op_wsize)
lcp -> lcd_windowsize = sa -> x25_opts.op_wsize;
else
sa -> x25_opts.op_wsize = lcp -> lcd_windowsize;
sa -> x25_net = pkp -> pk_xcp -> xc_addr.x25_net;
lcp -> lcd_flags |= sa -> x25_opts.op_flags;
lcp -> lcd_stime = time.tv_sec;
}
pk_connect (lcp, sa)
register struct pklcd *lcp;
register struct sockaddr_x25 *sa;
{
register struct pkcb *pkp;
register struct rtentry *rt;
register struct rtentry *nrt;
struct rtentry *npaidb_enter ();
struct pkcb *pk_newlink ();
if (sa -> x25_addr[0] == '\0')
return (EDESTADDRREQ);
if (!(rt = rtalloc1 ((struct sockaddr *)sa, 1)))
return (ENETUNREACH);
if (!(pkp = XTRACTPKP(rt)))
pkp = pk_newlink ((struct x25_ifaddr *) (rt -> rt_ifa),
(caddr_t) 0);
if (nrt = npaidb_enter (rt -> rt_gateway, rt_key (rt), rt, 0))
pkp -> pk_llrt = nrt;
if (pkp -> pk_llnext == (caddr_t)0 && pkp -> pk_llctlinput) {
struct dll_ctlinfo ctlinfo;
ctlinfo.dlcti_rt = rt;
ctlinfo.dlcti_pcb = (caddr_t) pkp;
ctlinfo.dlcti_conf =
(struct dllconfig *) (&((struct x25_ifaddr *)(rt -> rt_ifa)) -> ia_xc);
pkp -> pk_llnext =
(pkp -> pk_llctlinput) (PRC_CONNECT_REQUEST, 0, &ctlinfo);
}
if (pkp -> pk_state != DTE_READY && pkp -> pk_state != DTE_WAITING)
return (ENETDOWN);
if ((lcp -> lcd_lcn = pk_getlcn (pkp)) == 0)
return (EMFILE);
lcp -> lcd_faddr = *sa;
lcp -> lcd_ceaddr = & lcp -> lcd_faddr;
pk_assoc (pkp, lcp, lcp -> lcd_ceaddr);
if (pkp -> pk_state == DTE_WAITING) {
pkp -> pk_dxerole |= DTE_CONNECTPENDING;
pk_ctlinput (PRC_LINKUP, (struct sockaddr *)0, pkp);
if (lcp -> lcd_so)
soisconnecting (lcp -> lcd_so);
return 0;
}
if (lcp -> lcd_so)
soisconnecting (lcp -> lcd_so);
lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL);
pk_callrequest (lcp, lcp -> lcd_ceaddr, pkp -> pk_xcp);
return (*pkp -> pk_ia -> ia_start) (lcp);
}
#define RESHUFFLELCN(maxlcn, lcn) ((maxlcn) - (lcn) + 1)
pk_callcomplete (pkp)
register struct pkcb *pkp;
{
register struct pklcd *lcp;
register int i;
register int ni;
if (pkp -> pk_dxerole & DTE_CONNECTPENDING)
pkp -> pk_dxerole &= ~DTE_CONNECTPENDING;
else return;
if (pkp -> pk_chan == 0)
return;
if (pkp -> pk_dxerole & DTE_PLAYDCE) {
for (i = pkp -> pk_maxlcn; i > 0; --i)
if (pkp -> pk_chan[i]) {
ni = RESHUFFLELCN(pkp -> pk_maxlcn, i);
pkp -> pk_chan[ni] = pkp -> pk_chan[i];
pkp -> pk_chan[i] = NULL;
pkp -> pk_chan[ni] -> lcd_lcn = ni;
}
}
for (i = 1; i <= pkp -> pk_maxlcn; ++i)
if ((lcp = pkp -> pk_chan[i]) != NULL) {
lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL);
pk_callrequest (lcp, lcp -> lcd_ceaddr, pkp -> pk_xcp);
(*pkp -> pk_ia -> ia_start) (lcp);
}
}
struct bcdinfo {
octet *cp;
unsigned posn;
};
pk_callrequest (lcp, sa, xcp)
struct pklcd *lcp;
register struct sockaddr_x25 *sa;
register struct x25config *xcp;
{
register struct x25_calladdr *a;
register struct mbuf *m = lcp -> lcd_template;
register struct x25_packet *xp = mtod (m, struct x25_packet *);
struct bcdinfo b;
if (lcp -> lcd_flags & X25_DBIT)
X25SBITS(xp -> bits, d_bit, 1);
a = (struct x25_calladdr *) &xp -> packet_data;
b.cp = (octet *) a -> address_field;
b.posn = 0;
X25SBITS(a -> addrlens, called_addrlen, to_bcd (&b, sa, xcp));
X25SBITS(a -> addrlens, calling_addrlen, to_bcd (&b, &xcp -> xc_addr, xcp));
if (b.posn & 0x01)
*b.cp++ &= 0xf0;
m -> m_pkthdr.len = m -> m_len += b.cp - (octet *) a;
if (lcp -> lcd_facilities) {
m -> m_pkthdr.len +=
(m -> m_next = lcp -> lcd_facilities) -> m_pkthdr.len;
lcp -> lcd_facilities = 0;
} else
pk_build_facilities (m, sa, (int)xcp -> xc_type);
m_copyback (m, m -> m_pkthdr.len, sa -> x25_udlen, sa -> x25_udata);
}
pk_build_facilities (m, sa, type)
register struct mbuf *m;
struct sockaddr_x25 *sa;
{
register octet *cp;
register octet *fcp;
register int revcharge;
cp = mtod (m, octet *) + m -> m_len;
fcp = cp + 1;
revcharge = sa -> x25_opts.op_flags & X25_REVERSE_CHARGE ? 1 : 0;
if (type == X25_1976 && sa -> x25_opts.op_psize == X25_PS128)
revcharge |= 02;
if (revcharge) {
*fcp++ = FACILITIES_REVERSE_CHARGE;
*fcp++ = revcharge;
}
switch (type) {
case X25_1980:
case X25_1984:
*fcp++ = FACILITIES_PACKETSIZE;
*fcp++ = sa -> x25_opts.op_psize;
*fcp++ = sa -> x25_opts.op_psize;
*fcp++ = FACILITIES_WINDOWSIZE;
*fcp++ = sa -> x25_opts.op_wsize;
*fcp++ = sa -> x25_opts.op_wsize;
}
*cp = fcp - cp - 1;
m -> m_pkthdr.len = (m -> m_len += *cp + 1);
}
to_bcd (b, sa, xcp)
register struct bcdinfo *b;
struct sockaddr_x25 *sa;
register struct x25config *xcp;
{
register char *x = sa -> x25_addr;
unsigned start = b -> posn;
if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp -> xc_prepnd0)) {
char dnicname[sizeof (long) * NBBY/3 + 2];
register char *p = dnicname;
sprintf (p, "%d", xcp -> xc_addr.x25_net & 0x7fff);
for (; *p; p++)
if ((*p ^ *x++) & 0x0f)
break;
if (*p || xcp -> xc_nodnic == 0)
x = sa -> x25_addr;
if (*p && xcp -> xc_prepnd0) {
if ((b -> posn)++ & 0x01)
*(b -> cp)++;
else
*(b -> cp) = 0;
}
}
while (*x)
if ((b -> posn)++ & 0x01)
*(b -> cp)++ |= *x++ & 0x0F;
else
*(b -> cp) = *x++ << 4;
return ((b -> posn) - start);
}
pk_getlcn (pkp)
register struct pkcb *pkp;
{
register int i;
if (pkp -> pk_chan == 0)
return (0);
if ( pkp -> pk_dxerole & DTE_PLAYDCE ) {
for (i = 1; i <= pkp -> pk_maxlcn; ++i)
if (pkp -> pk_chan[i] == NULL)
break;
} else {
for (i = pkp -> pk_maxlcn; i > 0; --i)
if (pkp -> pk_chan[i] == NULL)
break;
}
i = ( i > pkp -> pk_maxlcn ? 0 : i );
return (i);
}
pk_clear (lcp, diagnostic, abortive)
register struct pklcd *lcp;
{
register struct mbuf *m = pk_template (lcp -> lcd_lcn, X25_CLEAR);
m -> m_len += 2;
m -> m_pkthdr.len += 2;
mtod (m, struct x25_packet *) -> packet_data = 0;
mtod (m, octet *)[4] = diagnostic;
if (lcp -> lcd_facilities) {
m -> m_next = lcp -> lcd_facilities;
m -> m_pkthdr.len += m -> m_next -> m_len;
lcp -> lcd_facilities = 0;
}
if (abortive)
lcp -> lcd_template = m;
else {
struct socket *so = lcp -> lcd_so;
struct sockbuf *sb = so ? & so -> so_snd : & lcp -> lcd_sb;
sbappendrecord (sb, m);
}
pk_output (lcp);
}
pk_flowcontrol (lcp, inhibit, forced)
register struct pklcd *lcp;
{
inhibit = (inhibit != 0);
if (lcp == 0 || lcp -> lcd_state != DATA_TRANSFER ||
(forced == 0 && lcp -> lcd_rxrnr_condition == inhibit))
return;
lcp -> lcd_rxrnr_condition = inhibit;
lcp -> lcd_template =
pk_template (lcp -> lcd_lcn, inhibit ? X25_RNR : X25_RR);
pk_output (lcp);
}
static
pk_reset (lcp, diagnostic)
register struct pklcd *lcp;
{
register struct mbuf *m;
register struct socket *so = lcp -> lcd_so;
if (lcp -> lcd_state != DATA_TRANSFER)
return;
if (so)
so -> so_error = ECONNRESET;
lcp -> lcd_reset_condition = TRUE;
pk_flush (lcp);
lcp -> lcd_window_condition = lcp -> lcd_rnr_condition =
lcp -> lcd_intrconf_pending = FALSE;
lcp -> lcd_rsn = MODULUS - 1;
lcp -> lcd_ssn = 0;
lcp -> lcd_output_window = lcp -> lcd_input_window =
lcp -> lcd_last_transmitted_pr = 0;
m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET);
m -> m_pkthdr.len = m -> m_len += 2;
mtod (m, struct x25_packet *) -> packet_data = 0;
mtod (m, octet *)[4] = diagnostic;
pk_output (lcp);
}
pk_flush (lcp)
register struct pklcd *lcp;
{
register struct socket *so;
if (lcp -> lcd_template)
m_freem (lcp -> lcd_template);
if (lcp -> lcd_cps) {
m_freem (lcp -> lcd_cps);
lcp -> lcd_cps = 0;
}
if (lcp -> lcd_facilities) {
m_freem (lcp -> lcd_facilities);
lcp -> lcd_facilities = 0;
}
if (so = lcp -> lcd_so)
sbflush (&so -> so_snd);
else
sbflush (&lcp -> lcd_sb);
}
pk_procerror (error, lcp, errstr, diagnostic)
register struct pklcd *lcp;
char *errstr;
{
pk_message (lcp -> lcd_lcn, lcp -> lcd_pkp -> pk_xcp, errstr);
switch (error) {
case CLEAR:
if (lcp -> lcd_so) {
lcp -> lcd_so -> so_error = ECONNABORTED;
soisdisconnecting (lcp -> lcd_so);
}
pk_clear (lcp, diagnostic, 1);
break;
case RESET:
pk_reset (lcp, diagnostic);
}
}
pk_ack (lcp, pr)
struct pklcd *lcp;
unsigned pr;
{
register struct socket *so = lcp -> lcd_so;
if (lcp -> lcd_output_window == pr)
return (PACKET_OK);
if (lcp -> lcd_output_window < lcp -> lcd_ssn) {
if (pr < lcp -> lcd_output_window || pr > lcp -> lcd_ssn) {
pk_procerror (RESET, lcp,
"p(r) flow control error", 2);
return (ERROR_PACKET);
}
}
else {
if (pr < lcp -> lcd_output_window && pr > lcp -> lcd_ssn) {
pk_procerror (RESET, lcp,
"p(r) flow control error #2", 2);
return (ERROR_PACKET);
}
}
lcp -> lcd_output_window = pr;
if (lcp -> lcd_window_condition == TRUE)
lcp -> lcd_window_condition = FALSE;
if (so && ((so -> so_snd.sb_flags & SB_WAIT) ||
(so -> so_snd.sb_flags & SB_NOTIFY)))
sowwakeup (so);
return (PACKET_OK);
}
pk_decode (xp)
register struct x25_packet *xp;
{
register int type;
if (X25GBITS(xp -> bits, fmt_identifier) != 1)
return (INVALID_PACKET);
#ifdef ancient_history
if (xp -> lc_group_number != 0)
return (INVALID_PACKET);
#endif
if (!(xp -> packet_type & DATA_PACKET_DESIGNATOR))
return (DATA);
if (!(xp -> packet_type & RR_OR_RNR_PACKET_DESIGNATOR))
switch (xp -> packet_type & 0x1f) {
case X25_RR:
return (RR);
case X25_RNR:
return (RNR);
case X25_REJECT:
return (REJECT);
}
switch (xp -> packet_type) {
case X25_CALL:
type = CALL;
break;
case X25_CALL_ACCEPTED:
type = CALL_ACCEPTED;
break;
case X25_CLEAR:
type = CLEAR;
break;
case X25_CLEAR_CONFIRM:
type = CLEAR_CONF;
break;
case X25_INTERRUPT:
type = INTERRUPT;
break;
case X25_INTERRUPT_CONFIRM:
type = INTERRUPT_CONF;
break;
case X25_RESET:
type = RESET;
break;
case X25_RESET_CONFIRM:
type = RESET_CONF;
break;
case X25_RESTART:
type = RESTART;
break;
case X25_RESTART_CONFIRM:
type = RESTART_CONF;
break;
case X25_DIAGNOSTIC:
type = DIAG_TYPE;
break;
default:
type = INVALID_PACKET;
}
return (type);
}
pk_restartcause (pkp, xp)
struct pkcb *pkp;
register struct x25_packet *xp;
{
register struct x25config *xcp = pkp -> pk_xcp;
register int lcn = LCN(xp);
switch (xp -> packet_data) {
case X25_RESTART_LOCAL_PROCEDURE_ERROR:
pk_message (lcn, xcp, "restart: local procedure error");
break;
case X25_RESTART_NETWORK_CONGESTION:
pk_message (lcn, xcp, "restart: network congestion");
break;
case X25_RESTART_NETWORK_OPERATIONAL:
pk_message (lcn, xcp, "restart: network operational");
break;
default:
pk_message (lcn, xcp, "restart: unknown cause");
}
}
#define MAXRESETCAUSE 7
int Reset_cause[] = {
EXRESET, EXROUT, 0, EXRRPE, 0, EXRLPE, 0, EXRNCG
};
pk_resetcause (pkp, xp)
struct pkcb *pkp;
register struct x25_packet *xp;
{
register struct pklcd *lcp =
pkp -> pk_chan[LCN(xp)];
register int code = xp -> packet_data;
if (code > MAXRESETCAUSE)
code = 7;
pk_message (LCN(xp), lcp -> lcd_pkp, "reset code 0x%x, diagnostic 0x%x",
xp -> packet_data, 4[(u_char *)xp]);
if (lcp -> lcd_so)
lcp -> lcd_so -> so_error = Reset_cause[code];
}
#define MAXCLEARCAUSE 25
int Clear_cause[] = {
EXCLEAR, EXCBUSY, 0, EXCINV, 0, EXCNCG, 0,
0, 0, EXCOUT, 0, EXCAB, 0, EXCNOB, 0, 0, 0, EXCRPE,
0, EXCLPE, 0, 0, 0, 0, 0, EXCRRC
};
pk_clearcause (pkp, xp)
struct pkcb *pkp;
register struct x25_packet *xp;
{
register struct pklcd *lcp =
pkp -> pk_chan[LCN(xp)];
register int code = xp -> packet_data;
if (code > MAXCLEARCAUSE)
code = 5;
if (lcp -> lcd_so)
lcp -> lcd_so -> so_error = Clear_cause[code];
}
char *
format_ntn (xcp)
register struct x25config *xcp;
{
return (xcp -> xc_addr.x25_addr);
}
pk_message (lcn, xcp, fmt, a1, a2, a3, a4, a5, a6)
struct x25config *xcp;
char *fmt;
{
if (lcn)
if (!PQEMPTY)
printf ("X.25(%s): lcn %d: ", format_ntn (xcp), lcn);
else
printf ("X.25: lcn %d: ", lcn);
else
if (!PQEMPTY)
printf ("X.25(%s): ", format_ntn (xcp));
else
printf ("X.25: ");
printf (fmt, a1, a2, a3, a4, a5, a6);
printf ("\n");
}
pk_fragment (lcp, m0, qbit, mbit, wait)
struct mbuf *m0;
register struct pklcd *lcp;
{
register struct mbuf *m = m0;
register struct x25_packet *xp;
register struct sockbuf *sb;
struct mbuf *head = 0, *next, **mp = &head, *m_split ();
int totlen, psize = 1 << (lcp -> lcd_packetsize);
if (m == 0)
return 0;
if (m -> m_flags & M_PKTHDR == 0)
panic ("pk_fragment");
totlen = m -> m_pkthdr.len;
m -> m_act = 0;
sb = lcp -> lcd_so ? &lcp -> lcd_so -> so_snd : & lcp -> lcd_sb;
do {
if (totlen > psize) {
if ((next = m_split (m, psize, wait)) == 0)
goto abort;
totlen -= psize;
} else
next = 0;
M_PREPEND(m, PKHEADERLN, wait);
if (m == 0)
goto abort;
*mp = m;
mp = & m -> m_act;
*mp = 0;
xp = mtod (m, struct x25_packet *);
0[(char *)xp] = 0;
if (qbit)
X25SBITS(xp -> bits, q_bit, 1);
if (lcp -> lcd_flags & X25_DBIT)
X25SBITS(xp -> bits, d_bit, 1);
X25SBITS(xp -> bits, fmt_identifier, 1);
xp -> packet_type = X25_DATA;
SET_LCN(xp, lcp -> lcd_lcn);
if (next || (mbit && (totlen == psize ||
(lcp -> lcd_flags & X25_DBIT))))
SMBIT(xp, 1);
} while (m = next);
for (m = head; m; m = next) {
next = m -> m_act;
m -> m_act = 0;
sbappendrecord (sb, m);
}
return 0;
abort:
if (wait)
panic ("pk_fragment null mbuf after wait");
if (next)
m_freem (next);
for (m = head; m; m = next) {
next = m -> m_act;
m_freem (m);
}
return ENOBUFS;
}