4.4BSD/usr/src/sys/vax/if/ACC/driver/if_dda.c
/*************************************************************************/
/* */
/* */
/* ________________________________________________________ */
/* / \ */
/* | AAA CCCCCCCCCCCCCC CCCCCCCCCCCCCC | */
/* | AAAAA CCCCCCCCCCCCCCCC CCCCCCCCCCCCCCCC | */
/* | AAAAAAA CCCCCCCCCCCCCCCCC CCCCCCCCCCCCCCCCC | */
/* | AAAA AAAA CCCC CCCC | */
/* | AAAA AAAA CCCC CCCC | */
/* | AAAA AAAA CCCC CCCC | */
/* | AAAA AAAA CCCC CCCC | */
/* | AAAA AAAAAAAAAAA CCCCCCCCCCCCCCCCC CCCCCCCCCCCCCCCCC | */
/* | AAAA AAAAAAAAAAA CCCCCCCCCCCCCCCC CCCCCCCCCCCCCCCC | */
/* | AAAA AAAAAAAAA CCCCCCCCCCCCCC CCCCCCCCCCCCCC | */
/* \________________________________________________________/ */
/* */
/* Copyright (c) 1986 by Advanced Computer Communications */
/* 720 Santa Barbara Street, Santa Barbara, California 93101 */
/* (805) 963-9431 */
/* */
/* */
/* File: if_dda.c */
/* */
/* Project: DDN-X.25 Network Interface Driver for ACP 5250 */
/* and ACP 6250 */
/* */
/* Function: This is a network interface driver supporting */
/* the ACP5250/6250 under UNIX versions 4.2, 4.3, */
/* 4.3-tahoe, Ultrix versions 1.2 and 2.0, and */
/* under VMS, TWG WIN/VX and TGV Multinet. */
/* */
/* Components: required: if_dda.c, if_ddareg.h, if_ddavar.h, */
/* and one of: if_dda_uqbus.c if_dda_bibus.c */
/* optional: if_pi.c, if_pivar.h, if_x29.c, */
/* if_vmsx29.c */
/* */
/*************************************************************************/
#include "dda.h"
#if NDDA > 0
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% SYSTEM CONFIGURATION %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if !defined(ACC_ULTRIX) && !defined(ACC_BSD) && !defined(ACC_VMS)
ERROR
an ACC OS specific option must be defined in your config file
ERROR
#endif
/*
* now define the un-set options to zero
*/
#if !defined(ACC_ULTRIX)
#define ACC_ULTRIX 00
#endif
#if !defined(ACC_BSD)
#define ACC_BSD 00
#endif
#if !defined(ACC_VMS)
#define ACC_VMS 00
#endif
/*
* the define DDA_MSGQ enables the message queue. this adds 2k to the
* data size of the driver. It should only be used during driver development
*/
/*#define DDA_MSGQ /* uncomment this to enable message queue */
/*
* The following line disables the use of the histogram facilities. This
* value (DDA_HISTOGRAM) is automatically undefined for all 4.2 and ULTRIX
* 1.2 systems which do not support the histogram facilities.
*/
#define DDA_HISTOGRAM /* comment this out to disable histogram */
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% INCLUDE FILES %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#ifndef SIMULATION /* real unix system */
#include "../machine/pte.h" /* page table entries */
#include "../h/param.h"
#include "../h/systm.h"
#include "../h/mbuf.h"
#include "../h/buf.h"
#include "../h/protosw.h"
#include "../h/socket.h"
#include "../h/vmmac.h"
#include "../h/errno.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/kernel.h"
#include "../h/ioctl.h"
#include "../vax/cpu.h"
#include "../vax/mtpr.h"
#include "../net/if.h"
#include "../net/netisr.h"
#include "../net/route.h"
#include "../netinet/in.h"
#include "../netinet/in_systm.h"
# if ACC_BSD > 42 || ACC_ULTRIX > 12
# include "../netinet/in_var.h"
# endif
#include "../netinet/ip.h"
#include "../netinet/ip_var.h"
#include "../vaxif/if_ddareg.h"
#include "../vaxif/if_ddavar.h"
#else SIMULATION
#include "machine/pte.h" /* page table entries */
#include "h/param.h"
#include "h/systm.h"
#include "h/mbuf.h"
#include "h/buf.h"
#include "h/protosw.h"
#include "h/socket.h"
#include "h/vmmac.h"
#include "h/errno.h"
#include "h/dir.h"
#include "h/user.h"
#include "h/kernel.h"
#include "h/ioctl.h"
#include "vax/cpu.h"
#include "vax/mtpr.h"
#include "net/if.h"
#include "net/netisr.h"
#include "net/route.h"
#include "netinet/in.h"
#include "netinet/in_systm.h"
# if ACC_BSD > 42 || ACC_ULTRIX > 12
# include "netinet/in_var.h"
# endif
#include "netinet/ip.h"
#include "netinet/ip_var.h"
#include "if_ddareg.h"
#include "if_ddavar.h"
# ifndef SIOCACPCONFIG
# define SIOCACPCONFIG _IOWR(i,40,struct ifreq)
# endif
# ifndef INET
# define INET 1
# endif
extern struct ifqueue ipintrq; /* IP input queue */
#endif SIMULATION
#if ACC_VMS > 00
# ifdef eunice
# define WINS
# else
# define MULTINET
# endif
#endif
#if ACC_VMS > 00
# ifdef WINS
# include <vms/adpdef.h> /* Define Adapters */
# include <vms/dcdef.h> /* Define AT$_UBA, adapter type */
# else MULTINET
# include "../vaxif/if_ddaioctl.h" /* not in ioctl.h */
# endif
#endif
/* disable histogram functions for BSD 4.2 and ULTRIX 1.2 */
#if ACC_BSD == 42 || ACC_ULTRIX == 12
# undef DDA_HISTOGRAM
#endif
/* Ultrix doesn't have syslog, so use printf instead. Since the two
* functions take different arg list formats, embed the open paren in
* the defined symbol; provide DDAELOG to close the call while keeping
* parentheses matched. The argument to DDALOG is ignored for printf;
* for log(), debugging messages use LOG_DEBUG, all others use LOG_ERR.
*/
#if (ACC_BSD > 42 || ACC_VMS > 00) && !defined(SIMULATION)
# include "syslog.h"
# define DDALOG(s) log( s,
#else
# define DDALOG(s) printf(
#endif
#define DDAELOG )
#ifndef DDADEBUG
#define PRIVATE static /* hide our internal functions */
#else
#define PRIVATE /* let the world see them */
#endif
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% GLOBAL FUNCTIONS %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
int ddaprobe();
int ddaattach();
int ddareset();
int ddainit();
int ddaoutput();
int ddatimer();
int ddaioctl();
int ddainta(); /* service interrupt "a" from front end */
int ddaintb(); /* service interrupt "b" from front end */
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% LOCAL FUNCTIONS %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void send_config();
PRIVATE struct dda_cb *locate_x25_lcn();
PRIVATE struct dda_cb *find_free_lcn();
PRIVATE boolean convert_ip_addr();
PRIVATE u_long convert_x25_addr();
PRIVATE boolean make_x25_call();
PRIVATE void dda_start();
PRIVATE void dda_rrq();
PRIVATE void dda_wrq();
PRIVATE int start_chn();
PRIVATE void dda_data();
PRIVATE void dda_supr();
PRIVATE void supr_msg();
PRIVATE boolean decode_ring();
PRIVATE void decode_answer();
PRIVATE void clear_lcn();
PRIVATE void send_restart();
PRIVATE void send_supr();
PRIVATE void start_supr();
PRIVATE void abort_io();
PRIVATE void prt_addr();
#ifdef DDA_PAD_OR_RAW
PRIVATE int dda_decode_type();
#endif
#ifdef DDA_PADOPT
PRIVATE void x29_data();
PRIVATE void x29_supr();
PRIVATE void x29_init();
#endif DDA_PADOPT
#ifdef DDA_RAWOPT
PRIVATE void pi_data();
PRIVATE void pi_supr();
PRIVATE void pi_init();
PRIVATE int pi_circuit_to_handle_protocol();
#endif DDA_RAWOPT
#ifdef DDADEBUG
PRIVATE void prt_bytes();
#endif
PRIVATE char *fmt_x25();
#ifdef DDA_HISTOGRAM
PRIVATE void hist_init(); /* histogram functions */
PRIVATE void hist_lcn_state();
PRIVATE void hist_all_lcns();
PRIVATE void hist_link_state();
PRIVATE void hist_read();
PRIVATE int hist_copyout();
#else DDA_HISTOGRAM /* make all histogram functions no-op's */
#define hist_init(a,b)
#define hist_lcn_state(a,b,c)
#define hist_all_lcns(a,b)
#define hist_link_state(a,b,c)
#define hist_read(a)
#define hist_copyout(a,b)
#endif DDA_HISTOGRAM
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% LOCAL VARIABLES %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE int tmo_data_idle = TMO_DATA_IDLE; /* idle circuit timeout for
* all boards */
PRIVATE int nddach[4] = { /* number of channels currently in use */
NDDACH_DEFAULT, NDDACH_DEFAULT,
NDDACH_DEFAULT, NDDACH_DEFAULT };
PRIVATE char *dda_product; /* name of product, like "ACP5250" */
PRIVATE int dda_hasmaint; /* do we have a maintenance board? */
/* the message bits are used in the DMESG macros defined in if_ddavar.h */
/* word 1 and 2 (msgs 0 - 63) are reserved for the IP interface */
/* word 3 (msgs 64 - 95) are reserved for the PI interface */
/* word 4 (msgs 96 - 127) are reserved for the X.29 interface */
/* word 5 and 6 (msgs 128 - 191) are reserved for debugging main module*/
/* word 7 (msgs 192 - 223) are reserved for debugging the PI */
/* word 8 (msgs 224 - 255) are reserved for debugging X29 */
/* word 9 (msgs 256 - 287) are reserved for call logging */
#define NDMESGWORDS 9
#define MAXDMSGS (NDMESGWORDS * 32)
PRIVATE long ddamsgs[NDDA][NDMESGWORDS];
/* | | | | | | | | |
* default: all informational messages on, /--/--/--/ | | | | |
* all debug messages off, --------------------/---/---/---/ |
* log busys, but not calls or I/O aborts ---------------------/
*/
/* Must be as large as the larger of (trtab, ddactl, dnload): */
char dda_iobuf[sizeof(struct ddactl)];
struct dda_softc dda_softc[NDDA]; /* per device infomation */
/* header for building command to be sent to the front end in */
/* response to ACPCONFIG user command */
PRIVATE u_char acpconfig_msg[] = {
LINE_CNTL, /* set command code */
0x00, /* not used */
0x00, /* not used */
0x00, /* extension length (set at runtime) */
0x00, /* cmd space */
0x00,
0x00,
0x00,
0x00
};
PRIVATE u_char bfr_size_msg[] =
{
SET_BFR_SIZE, /* set command code */
0x00, /* not used */
0x00, /* not used */
0x01, /* extension length */
0x00, /* cmd space */
0x00,
0x00,
0x00,
0x00
};
PRIVATE u_char ddacb_cmnd[4] = { CALL, 0, 0, 0 };
PRIVATE u_char ddacb_called_addr[16] = {0};
PRIVATE u_char ddacb_calling_addr[16] = {0};
PRIVATE u_char ddacb_facilities[64] = {0};
PRIVATE u_char ddacb_protocol[5] = {0};
PRIVATE u_char ddacb_user_data[64] = {0};
#ifdef DDADEBUG
u_char dda_silo_counter;
u_char dda_debug_silo[256];
#endif
/* Table of baud rate values and the associated parameter for the Set */
/* System Parameters message, ddainit_msg. The 'parameter1' is nonzero */
/* for valid baud rate divisors. These are nominal baud rates. */
PRIVATE struct baud {
char b_value;
u_char parameter1; /* first byte of baud rate setting */
u_char parameter2; /* second byte of baud rate setting */
} ddabaud_rate[] = {
{ 1, 0x02, 0x00 }, /* 2.00M */
{ 2, 0x03, 0x00 }, /* 1.33M */
{ 3, 0x04, 0x00 }, /* 1.00M */
{ 4, 0x08, 0x00 }, /* 500K */
{ 5, 0x10, 0x00 }, /* 250K */
{ 6, 0x28, 0x00 }, /* 100K */
{ 7, 0x3e, 0x00 }, /* 64K */
{ 8, 0x47, 0x00 }, /* 56K */
{ 9, 0x85, 0x00 }, /* 30K */
{ 10, 0xd0, 0x00 }, /* 19.2K */
{ 11, 0xa1, 0x01 }, /* 9600 */
{ 12, 0x41, 0x03 }, /* 4800 */
{ 13, 0x83, 0x06 }, /* 2400 */
{ 14, 0x05, 0x0d }, /* 1200 */
{ 0, 0, 0 }
};
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% Address Translation Table for Internet <-> X.25 addresses %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#define DDANATT 32 /* number of addr translation table entries */
PRIVATE int dda_num_addr_tr[NDDA] = {0}; /* number of address
* translations */
/* currently stored */
PRIVATE struct dda_addr_tr { /* X.25 PDN address translation table */
u_long ip_addr; /* internet address */
u_char x25_addr[MAXADDRLEN]; /* X.25 address */
} dda_addr_tr[NDDA][DDANATT] = {{ 0L, ""}}; /* null */
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% Aliasing of IP address for 4.2 ==> 4.3 compatibility %%*/
/*%% Note: this union is not required in 4.2, since the s_net %%*/
/*%% field and its friends are in an include file. We use it to %%*/
/*%% minimize the number of #ifdef dependencies in the code. %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#ifdef s_net /* 4.2 */
# undef s_net
# undef s_host
# undef s_lh
# undef s_impno
#endif
union imp_addr {
struct in_addr ip;
struct imp {
u_char s_net;
u_char s_host;
u_char s_lh;
u_char s_impno;
} imp;
};
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% GLOBAL ROUTINES %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#ifdef ACP_BI
#include "if_dda_bibus.c"
#else
#include "if_dda_uqbus.c"
#endif
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DDAIOCTL() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine processes device dependent ioctl's. Supported */
/* ioctls set the host's internet address for this network */
/* interface, or send Set System Parameters Message to the ACP. */
/* The logic for setting the interface address must remain */
/* compatible with both ifconfig and acpconfig programs. */
/* If the ioctl comes from the acpconfig program, the front end */
/* is not initialized because the user will specify explicitly */
/* what parameters are desired. If the ioctl comes from the */
/* ifconfig program, the fron end is initialized with default */
/* parameters in the ddainit_msg array. */
/* */
/* Call: ddaioctl(ifp, cmd, data) */
/* Argument: ifp: pointer to the network interface data */
/* structure, ifnet */
/* cmd: identifies the type of ioctl */
/* data: information for the ioctl */
/* Returns: 0 for success, or the nonzero error value: */
/* EINVAL invalid ioctl request */
/* Called by: network software, address of this routine is */
/* defined in af_inet network interface struct */
/* Calls to: splimp() */
/* if_rtinit() */
/* in_netof() */
/* in_lnaof() */
/* ddainit() */
/* send_config() */
/* DDALOG() */
/* splx() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#ifdef MULTINET
volatile int StatQuery_Completed; /* Polled for board stat ioctl */
#endif
ddaioctl(ifp, cmd, data)
register struct ifnet *ifp;
int cmd;
caddr_t data;
{
register struct dda_softc *ds = &dda_softc[ifp->if_unit];
struct ifreq *ifr = (struct ifreq *) data;
#if defined(DDA_PADOPT) && defined(WINS)
int prealloc_x29(); /* Preallocate UCBs for X29 */
#endif
#if ACC_BSD == 42 || ACC_ULTRIX == 12
struct sockaddr_in *sin = (struct sockaddr_in *) & ifr->ifr_addr;
#else
struct ifaddr *ifa = ds->dda_if.if_addrlist;
#endif
int s;
int error = 0;
int i;
register struct dda_addr_tr *atp, *btp;
struct trtab *tr;
struct ddactl *da;
char arg2[MAXADDRLEN], code;
#ifdef DDADEBUG
if (DDADBCH(4, ifp->if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: ioctl()\n", ifp->if_unit DDAELOG;
}
#endif DDADEBUG
/*
* This may not be necessary here, but under some flavors of BSDish
* systems (2.0ULTRIX) this routine is apparently called at splimp(). In
* the case that we are currently processing ioctls issued from acpconfig
* in /etc/rc, the board may not have come on line yet - so we need to be
* able to process the B interrupt while in the delay loop below.
*/
#ifndef MULTINET
s = spl0();
#endif
switch (cmd) {
case SIOCSIFADDR:
if (!suser())
return EACCES;
#if ACC_BSD == 42 || ACC_ULTRIX == 12
if (ifp->if_flags & IFF_RUNNING)
if_rtinit(ifp, -1); /* delete previous route */
ifp->if_addr = *(struct sockaddr *) sin;
ifp->if_net = in_netof(sin->sin_addr);
ifp->if_host[0] = in_lnaof(sin->sin_addr);
if (ifp->if_flags & IFF_RUNNING)
if_rtinit(ifp, RTF_UP);
else
ddainit(ifp->if_unit);
ds->dda_ipaddr.s_addr = ((struct sockaddr_in *) & ifp->if_addr)->sin_addr.s_addr;
#else /* 4.3 networking */
if (ifa->ifa_addr.sa_family != AF_INET)
return (EINVAL);
if ((ifp->if_flags & IFF_RUNNING) == 0)
ddainit(ifp->if_unit);
ds->dda_ipaddr = IA_SIN(ifa)->sin_addr;
#endif /* 4.3 networking */
break;
case SIOCACPCONFIG:
/* process ioctl from acpconfig program */
code = *(ifr->ifr_data);
/*********************************************************
* *
* Commands n, h, q, and r are non-privileged *
* *
*********************************************************/
if (!suser() && code != 'n' && code != 'h' && code != 'q' && code != 'r')
return EACCES;
#if ACC_BSD == 42 || ACC_ULTRIX == 12
sin = (struct sockaddr_in *) & ds->dda_if.if_addr;
if (in_netof(sin->sin_addr) == 0)
#else
if (ds->dda_if.if_addrlist == 0)
#endif
{
error = EDESTADDRREQ; /* error, no internet address */
goto exit;
}
/* for command to set baud rate, look up the value for the */
/* baud rate divisor in the ddabaud_rate table, put value */
/* in the Set System Parameters message, ddainit_msg */
if (code >= 1 && code <= 14) {
register struct baud *p;
if (error = diags_completed(ds))
goto exit;
for (p = ddabaud_rate; p->b_value; p++) {
if ((*(ifr->ifr_data) - p->b_value) == 0)
break;
}
/* if internal clock not set, do so */
if ((ds->dda_init & DDA_INTCLOCK) == 0) {
ds->dda_init |= DDA_INTCLOCK;
acpconfig_msg[MSG_OFFSET] = CLOCK_CNTL;
acpconfig_msg[MSG_OFFSET + 1] = INTERNAL_CLOCK;
acpconfig_msg[MSG_OFFSET + 2] = BAUD_CNTL;
acpconfig_msg[MSG_OFFSET + 3] = p->parameter1;
acpconfig_msg[MSG_OFFSET + 4] = p->parameter2;
acpconfig_msg[MSG_LENGTH] = 5;
} else {
acpconfig_msg[MSG_OFFSET] = BAUD_CNTL;
acpconfig_msg[MSG_OFFSET + 1] = p->parameter1;
acpconfig_msg[MSG_OFFSET + 2] = p->parameter2;
acpconfig_msg[MSG_LENGTH] = 3;
}
if ((p->b_value == 0) || (p->parameter1 == 0))
error = EINVAL; /* baud rate value invalid */
else
send_config(ds, acpconfig_msg); /* send message to front end */
goto exit;
}
switch (code) {
case 'a': /* Add address translation table entry */
if (error = diags_completed(ds))
goto exit;
if (dda_num_addr_tr[ifp->if_unit] >= DDANATT) { /* table already full */
error = ENOMEM;
goto exit;
}
/*
* Copy in user arguments and point "tr" at them. Then scan the
* translation table and either find location to insert or flag
* error
*/
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct trtab))) {
error = EFAULT;
goto exit;
}
tr = (struct trtab *) dda_iobuf;
for (i = 0, atp = &dda_addr_tr[ifp->if_unit][0];
i < dda_num_addr_tr[ifp->if_unit]; i++, atp++) {
if (atp->ip_addr == tr->ipaddr) {
if (bcmp((char *) atp->x25_addr,
(char *) tr->x25addr, MAXADDRLEN)) {
error = EADDRINUSE;
goto exit;
} else /* addresses are the same, just ignore ioctl */
goto exit;
}
if (atp->ip_addr > tr->ipaddr) /* insert entry here */
break;
}
for (btp = &dda_addr_tr[ifp->if_unit][dda_num_addr_tr[ifp->if_unit]];
btp > atp; btp--) { /* open up space for a new entry */
btp->ip_addr = (btp - 1)->ip_addr;
bcopy((btp - 1)->x25_addr, btp->x25_addr, MAXADDRLEN);
}
atp->ip_addr = tr->ipaddr;
bcopy(tr->x25addr, atp->x25_addr, MAXADDRLEN);
dda_num_addr_tr[ifp->if_unit]++; /* one more table entry */
goto exit;
case 'D':
if (error = diags_completed(ds))
goto exit;
/* clear table for use by 'r' flag of acpconfig */
for (i = 0, atp = &dda_addr_tr[ifp->if_unit][0];
i < dda_num_addr_tr[ifp->if_unit]; i++, atp++) {
atp->ip_addr = 0L;
atp->x25_addr[0] = 0;
}
dda_num_addr_tr[ifp->if_unit] = 0;
goto exit;
case 'd': /* Delete address translation table entry */
if (error = diags_completed(ds))
goto exit;
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct trtab))) {
error = EFAULT;
goto exit;
}
tr = (struct trtab *) dda_iobuf;
error = EFAULT; /* in case inet address not in table */
for (i = 0, atp = &dda_addr_tr[ifp->if_unit][0];
i < dda_num_addr_tr[ifp->if_unit]; i++, atp++) {
if (atp->ip_addr == tr->ipaddr) {
error = 0; /* found it: cancel error */
for (; i < dda_num_addr_tr[ifp->if_unit] - 1; i++, atp++) {
atp->ip_addr = (atp + 1)->ip_addr;
bcopy((atp + 1)->x25_addr, atp->x25_addr, MAXADDRLEN);
}
atp->ip_addr = 0L; /* clear last vacated entry */
atp->x25_addr[0] = 0;
dda_num_addr_tr[ifp->if_unit]--; /* one fewer table
* entries */
break;
}
}
goto exit;
case 'f': /* -f facility status */
/*
* The first byte of the "msg" selects the flow control parameter
* and the "drval" field holds the status (on or off).
*/
if (error = diags_completed(ds))
goto exit;
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
if (ds->dda_firmrev < 0x21) { /* need 2.0 or above ROMs */
error = ENOPROTOOPT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
switch (da->msg[0]) {
case 0: /* packet */
if (da->drval)
ds->dda_init |= DDA_PKTNEG;
else
ds->dda_init &= ~DDA_PKTNEG;
break;
case 1: /* window */
if (da->drval)
ds->dda_init |= DDA_WNDNEG;
else
ds->dda_init &= ~DDA_WNDNEG;
break;
}
goto exit;
case 'o': /* Set options */
if (error = diags_completed(ds))
goto exit;
if (ds->dda_firmrev < 0x21) { /* need 2.1 or above ROMs */
error = ENOPROTOOPT;
goto exit;
}
if (ds->dda_state != S_DISABLED) { /* must bring link down */
error = EINPROGRESS;
goto exit;
}
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
acpconfig_msg[MSG_OFFSET] = PKT_OPTIONS;
acpconfig_msg[MSG_OFFSET + 1] = da->msg[0];
acpconfig_msg[MSG_LENGTH] = 2;
#ifdef DDADEBUG
if (DDADBCH(4, ifp->if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: acpconfig_msg is %x %x %x\n",
ifp->if_unit, acpconfig_msg[MSG_LENGTH],
acpconfig_msg[MSG_OFFSET], acpconfig_msg[MSG_OFFSET + 1] DDAELOG;
}
#endif DDADEBUG
send_config(ds, acpconfig_msg);
goto exit;
case 'N': /* read network id */
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
ds->dda_net_id = da->drval;
goto exit;
case 'r': /* Read address translation table entry */
/*
* The value stored in "ipaddr" is not an address, but an index
* of a translation table entry to read out. The x25_addr field
* in the input structure is not used.
*/
if (error = diags_completed(ds))
goto exit;
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct trtab))) {
error = EFAULT;
goto exit;
}
tr = (struct trtab *) dda_iobuf;
i = tr->ipaddr;
if (i >= DDANATT) { /* scanned the whole table */
error = EFAULT;
goto exit;
}
tr->ipaddr = dda_addr_tr[ifp->if_unit][i].ip_addr;
bcopy(dda_addr_tr[ifp->if_unit][i].x25_addr, tr->x25addr, MAXADDRLEN);
if (copyout(tr, ifr->ifr_data, sizeof(struct trtab)))
error = EFAULT;
goto exit;
#ifdef DDA_HISTOGRAM
case 'h': /* read histogram */
if (error = diags_completed(ds))
goto exit;
hist_read(ifp->if_unit);
if (hist_copyout(ifp->if_unit, ifr->ifr_data))
error = EFAULT;
goto exit;
case 'H': /* read and reset histogram */
if (error = diags_completed(ds))
goto exit;
hist_read(ifp->if_unit);
if (hist_copyout(ifp->if_unit, ifr->ifr_data))
error = EFAULT;
else
hist_init(ifp->if_unit, 1);
goto exit;
#endif DDA_HISTOGRAM
case 'v': /* -v variable value */
/*
* There are two "variables" in the driver which can be set via
* ioctl: packet size, and window size. The "drval" field holds
* the value and the first byte of the "msg" selects the variable.
* Note that the selector is another little undocumented piece of
* the interface between here and the acpconfig program. It is
* coupled to the ordering of a little string table inside that
* program; new parameters should be added at the end, not the
* middle!
*/
/* No check to see if powerup diags are completed */
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
switch (da->msg[0]) {
case 0: /* set logging (obsolete) */
case 1: /* set debug (obsolete) */
case 2: /* set debug unit (obsolete) */
error = EINVAL;
break;
/*
* For both packet and window sizes, we check that the link
* is currently down. The new parameters will be sent to the
* FEP when the link is next brought up. See processing for
* -u flag.
*/
case 3: /* set packetsize */
if (error = diags_completed(ds))
goto exit;
if (ds->dda_firmrev < 0x21) { /* need 2.1 or above ROMs */
error = ENOPROTOOPT;
goto exit;
}
if (ds->dda_state != S_DISABLED) { /* must bring link down */
error = EINPROGRESS;
goto exit;
}
/*
* X.25 (1984) section 7.2.2.1.1 says 12 (4096 byte packets)
* BBN report 5760 (September 1984) 14.2.1.2 says 10. We just
* check for 12.
*/
if (da->drval < 4 || da->drval > 12)
error = EINVAL;
else {
int packetsize = 1 << da->drval;
acpconfig_msg[MSG_LENGTH] = 3;
acpconfig_msg[MSG_OFFSET] = MAX_PKT_SZ; /* Max negotiable */
/* pkt size */
acpconfig_msg[MSG_OFFSET + 1] = packetsize & 0xFF;
acpconfig_msg[MSG_OFFSET + 2] = (packetsize >> 8) & 0xFF;
send_config(ds, acpconfig_msg);
}
break;
case 4: /* set windowsize */
if (error = diags_completed(ds))
goto exit;
if (ds->dda_firmrev < 0x21) { /* need 2.0 or above ROMs */
error = ENOPROTOOPT;
goto exit;
}
if (ds->dda_state != S_DISABLED) { /* must bring link down */
error = EINPROGRESS;
goto exit;
}
if (da->drval < 1 || da->drval > 127)
error = EINVAL;
else {
acpconfig_msg[MSG_LENGTH] = 2;
acpconfig_msg[MSG_OFFSET] = MAX_PKT_WN; /* Max negotiable */
/* pkt window */
acpconfig_msg[MSG_OFFSET + 1] = da->drval;
send_config(ds, acpconfig_msg);
}
break;
}
goto exit;
case 'm': /* -m message */
if (error = diags_completed(ds))
goto exit;
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
send_config(ds, da->msg);
goto exit;
case 'n': /* -n svc_count */
if (error = diags_completed(ds))
goto exit;
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
if (ds->dda_firmrev < 0x21) { /* need 2.1 or above ROMs */
error = ENOPROTOOPT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
i = 0; /* i holds the return value */
if (da->drval == 0)
i = nddach[ifp->if_unit];
else if (ds->dda_state != S_DISABLED) { /* must bring link down */
error = EINPROGRESS;
goto exit;
} else {
if (!suser()) {
error = EACCES;
goto exit;
}
if (da->drval < 1 || da->drval > NDDACH)
error = EINVAL;
else {
acpconfig_msg[MSG_LENGTH] = 2;
acpconfig_msg[MSG_OFFSET] = SVC_LIMIT;
acpconfig_msg[MSG_OFFSET + 1] = da->drval;
nddach[ifp->if_unit] = da->drval;
send_config(ds, acpconfig_msg);
}
}
if (copyout(&i, ifr->ifr_data, sizeof(int)))
error = EFAULT;
goto exit;
case 'c': /* -c msgnum -- dis/enable driver mesg */
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
if (da->drval < 0 || da->drval >= MAXDMSGS)
error = EINVAL;
else {
u_char new_val;
DMESGTOG(ifp->if_unit, da->drval);
new_val = DMESGVAL(ifp->if_unit, da->drval) ? 1 : 0;
/* 1 means disabled, 0 means enabled */
if (copyout(&new_val, ifr->ifr_data, sizeof(u_char)))
error = EFAULT;
}
goto exit;
case 't': /* -t sec -- set data idle timeout */
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
if (da->drval < 1)
error = EINVAL;
else
tmo_data_idle = da->drval / DDA_TIMEOUT;
goto exit;
case 'q': /* driver/FE/shm/silo state queries */
if (copyin(ifr->ifr_data, dda_iobuf, sizeof(struct ddactl))) {
error = EFAULT;
goto exit;
}
da = (struct ddactl *) dda_iobuf;
switch (da->msg[0]) {
case 0: /* front end state query */
if ((error = diags_completed(ds)) == 0) {
int s2 = splimp();
/* need 2.0 or above ROMs */
if (ds->dda_firmrev < 0x21) {
error = ENOPROTOOPT;
splx(s2); /* We got it and woke up */
break;
}
#ifdef MULTINET
StatQuery_Completed = 0;
send_supr(ds, STATQUERY, 0, 0);
splx(s2); /* drop ioctl so we can be scheduled */
while (!StatQuery_Completed);
#else MULTINET
send_supr(ds, STATQUERY, 0, 0);
sleep(dda_iobuf, PSLEP); /* Interruptible with ^C */
splx(s2); /* We got it and woke up */
#endif MULTINET
if (copyout(dda_iobuf, ifr->ifr_data,
sizeof(struct ddactl)))
error = EFAULT;
}
break;
case 1: /* driver state query */
da->msg[0] = ds->dda_state;
da->msg[1] = ds->dda_init;
da->msg[2] = ds->dda_flags;
da->msg[3] = ds->dda_firmrev;
if (copyout(dda_iobuf, ifr->ifr_data,
sizeof(struct ddactl)))
error = EFAULT;
break;
#ifdef DDADEBUG
case 2: /* debug query */
if (copyout(dda_debug_silo, ifr->ifr_data, 256))
error = EFAULT;
break;
#endif
#if defined(DDADEBUG) && defined(ACP_BI)
case 3: /* shm/biic query (temporary) */
{
register struct uba_device *ui = ddainfo[ifp->if_unit];
dda_dump_shm((SYSGEN_BLOCK *) ds->dda_mapreg);
dda_dump_biic_regs((struct biic_regs *) ui->ui_addr);
}
break;
#endif
default:
error = EINVAL;
}
goto exit;
case '0': /* -u 0 */
if (error = diags_completed(ds))
goto exit;
acpconfig_msg[MSG_OFFSET] = LINK_DISABLE;
acpconfig_msg[MSG_LENGTH] = 1;
hist_link_state(ifp->if_unit, ds->dda_state, S_GOING_DOWN);
ds->dda_state = S_GOING_DOWN;
break;
case '1': /* -u 1 */
if (error = diags_completed(ds))
goto exit;
acpconfig_msg[MSG_OFFSET] = LINK_LOOPBACK;
acpconfig_msg[MSG_OFFSET + 1] = LOOP_NONE;
acpconfig_msg[MSG_OFFSET + 2] = DTE_DCE_MODE;
acpconfig_msg[MSG_OFFSET + 3] = DTE;
acpconfig_msg[MSG_OFFSET + 4] = LINK_ENABLE;
acpconfig_msg[MSG_LENGTH] = 5;
ds->dda_state = S_COMING_UP;
hist_init(ifp->if_unit, 0);
break;
case '2': /* -u 2 */
if (error = diags_completed(ds))
goto exit;
acpconfig_msg[MSG_OFFSET] = LINK_LOOPBACK;
acpconfig_msg[MSG_OFFSET + 1] = LOOP_NONE;
acpconfig_msg[MSG_OFFSET + 2] = DTE_DCE_MODE;
acpconfig_msg[MSG_OFFSET + 3] = DCE;
acpconfig_msg[MSG_OFFSET + 4] = LINK_ENABLE;
acpconfig_msg[MSG_LENGTH] = 5;
ds->dda_state = S_COMING_UP;
hist_init(ifp->if_unit, 0);
break;
case '3': /* -u 3 */
if (error = diags_completed(ds))
goto exit;
acpconfig_msg[MSG_OFFSET] = LINK_LOOPBACK;
acpconfig_msg[MSG_OFFSET + 1] = LOOP_EXTERNAL;
acpconfig_msg[MSG_OFFSET + 2] = LINK_ENABLE;
acpconfig_msg[MSG_LENGTH] = 3;
ds->dda_state = S_COMING_UP;
hist_init(ifp->if_unit, 0);
break;
case '4': /* -u 4 */
if (error = diags_completed(ds))
goto exit;
acpconfig_msg[MSG_OFFSET] = LINK_LOOPBACK;
acpconfig_msg[MSG_OFFSET + 1] = LOOP_INTERNAL;
acpconfig_msg[MSG_OFFSET + 2] = LINK_ENABLE;
acpconfig_msg[MSG_LENGTH] = 3;
ds->dda_state = S_COMING_UP;
hist_init(ifp->if_unit, 0);
break;
case 'b': /* -b 0 */
if (error = diags_completed(ds))
goto exit;
acpconfig_msg[MSG_OFFSET] = CLOCK_CNTL;
acpconfig_msg[MSG_OFFSET + 1] = EXTERNAL_CLOCK;
acpconfig_msg[MSG_LENGTH] = 2;
ds->dda_init &= ~DDA_INTCLOCK;
break;
case 'S': /* select DDN standard X.25 service */
/* -s 0 or -s standard */
if (error = diags_completed(ds))
goto exit;
if (ds->dda_if.if_flags & IFF_UP && ds->dda_init & DDA_PDN) {
error = EALREADY;
goto exit; /* no PDN->DDN mode change if running */
}
ds->dda_init &= ~(DDA_BASIC | DDA_PDN);
ds->dda_init |= DDA_STANDARD;
goto exit;
case 'T': /* select DDN basic X.25 service */
/* -s 1 or -s basic */
if (error = diags_completed(ds))
goto exit;
if (ds->dda_if.if_flags & IFF_UP && ds->dda_init & DDA_PDN) {
error = EALREADY;
goto exit; /* no PDN->DDN mode change if running */
}
ds->dda_init &= ~(DDA_PDN | DDA_STANDARD);
ds->dda_init |= DDA_BASIC;
goto exit;
case 'U': /* select X.25 Public Data Network service */
/* -s 2 or -s pdn */
if (error = diags_completed(ds))
goto exit;
if (ds->dda_if.if_flags & IFF_UP && (ds->dda_init &
(DDA_BASIC | DDA_STANDARD))) {
error = EALREADY;
goto exit; /* no DDN->PDN mode change if running */
}
ds->dda_init &= ~(DDA_BASIC | DDA_STANDARD);
ds->dda_init |= DDA_PDN;
goto exit;
case 'e': /* set buffer size */
/* -e size size is encoded in second byte */
if (error = diags_completed(ds))
goto exit;
/*
* check to see if we have newer at least version 2.2 roms.
*/
if (ds->dda_firmrev < 0x22) {
error = ENOPROTOOPT;
goto exit;
}
if (ds->dda_if.if_flags & IFF_UP) {
error = EALREADY;
goto exit; /* no PDN->DDN mode change if running */
}
bfr_size_msg[MSG_OFFSET] = ifr->ifr_data[1];
send_config(ds, bfr_size_msg);
bufreset(ifp->if_unit);
goto exit;
#ifdef ACP_BI
case 'L':
{ struct dda_dnload dl;
if (copyin(ifr->ifr_data, &dl, sizeof(struct dda_dnload))) {
error = EFAULT;
goto exit;
}
error = dda_dload(ifp->if_unit, &dl);
goto exit;
}
#endif
#if defined(DDA_PADOPT) && defined(WINS)
case 'x': /* Preallocate UCBs for X29 -- VMS only */
printf("Preallocated %d PTYs for X29\n", prealloc_x29());
goto exit;
#endif
case 'z': /* reset specified front-end device, -z */
/* second parm is supposed to be uban, but ddareset doesn't care about it */
ddareset(ifp->if_unit, 0);
goto exit;
default:
error = EINVAL;
goto exit;
}
if ((*(ifr->ifr_data) != '0') && (ds->dda_init & DDA_PDN) &&
#if ACC_BSD == 42 || ACC_ULTRIX == 12
(convert_ip_addr(sin->sin_addr, (u_char *) arg2, ds) == 0)
#else
(convert_ip_addr(ds->dda_ipaddr, (u_char *) arg2, ds) == 0)
#endif
) {
error = EADDRNOTAVAIL;
goto exit;
}
send_config(ds, acpconfig_msg);
break;
default:
error = EINVAL;
}
exit:
#ifndef MULTINET
splx(s);
#endif
return (error);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DDAOUTPUT() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine is called by the network software when it has an */
/* IP datagram to send out this interface. An attempt is made */
/* to find a LCN which has a virtual circuit open to the */
/* indicated host. If an LCN is found the packet is queued for */
/* output on that LCN. */
/* */
/* Call: ddaoutput(ifp, m0, dst) */
/* Arguments: ifp: locates the network interface, ifnet */
/* m0: locates an mbuf buffer */
/* dst: is the socket destination address */
/* Returns: 0 for success, or one of following nonzero */
/* error indications: */
/* ENETDOWN */
/* EAFNOSUPPORT */
/* ENOBUFS */
/* Called by: network software, address of this routine is */
/* defined in the dda_if network interface struct */
/* Calls to: DDALOG() */
/* m_freem() */
/* splimp() */
/* locate_x25_lcn() */
/* IF_QFULL() */
/* IF_DROP() */
/* splx() */
/* IF_ENQUEUE() */
/* dda_start() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
ddaoutput(ifp, m0, dst)
struct ifnet *ifp;
struct mbuf *m0;
struct sockaddr_in *dst;
{
register struct mbuf *m = m0;
register struct dda_softc *ds = &dda_softc[ifp->if_unit];
register struct dda_cb *dc;
register struct ifqueue *oq;
struct mbuf *prev;
int s;
union imp_addr imp_addr;
#ifdef DDADEBUG
if (DDADBCH(1, ifp->if_unit)) {
imp_addr.ip = dst->sin_addr;
DDALOG(LOG_DEBUG) "dda%d: ddaoutput: dst = %d.%d.%d.%d\n",
ifp->if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno DDAELOG;
}
#endif DDADEBUG
if ((ds->dda_if.if_flags & IFF_UP) == 0)
return (ENETDOWN);
switch (dst->sin_family) {
#ifdef INET
case AF_INET:
break;
#endif INET
default:
DMESG(ifp->if_unit, 2,
(DDALOG(LOG_ERR) "dda%d: can't handle af%d\n", ifp->if_unit,
dst->sin_family DDAELOG));
m_freem(m0);
return (EAFNOSUPPORT);
}
#ifdef DDADEBUG
if (DDADBCH(2, ifp->if_unit)) {
imp_addr.ip = dst->sin_addr;
DDALOG(LOG_DEBUG) "dda%d: ddaoutput: dst = %d.%d.%d.%d\n",
ifp->if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno DDAELOG;
}
#endif DDADEBUG
/* Mod to V1.5b ==> V1.5b1 */
/* In 4.3, the IP code may pass mbuf chains with 0-length mbufs */
/* This causes "transfer count = 0" messages and might even */
/* cause actual garbage data transmission if the mbuf is at the */
/* end of the chain (we don't think it ever will be, but one */
/* can't be too sure...so we scan the chain first). */
/* WE DO ASSUME that there is at least one nonempty mbuf! */
/* (ULTRIX: we don't know, but the code is at worst harmless) */
while (m0->m_len == 0) {
m = m0;
m0 = m0->m_next;
m->m_next = 0;
m_freem(m);
}
/* Now we know the first mbuf (at m0) is not zero length */
prev = m0;
m = m0->m_next;
while (m) {
if (m->m_len == 0) {
prev->m_next = m->m_next;
m->m_next = 0;
m_freem(m);
m = prev->m_next;
} else {
prev = m;
m = m->m_next;
}
}
m = m0; /* reset m to beginning of modified chain */
s = splimp(); /* disable interrrupts */
/* try to find an LCN */
if (dc = locate_x25_lcn(ds, dst->sin_addr)) { /* if found */
#ifdef DDADEBUG
if (DDADBCH(2, ifp->if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: ddaoutput: lcn found = %d\n", ifp->if_unit,
dc->dc_lcn DDAELOG;
}
#endif DDADEBUG
oq = &(dc->dc_oq); /* point to output queue */
if (IF_QFULL(oq)) { /* if q full */
IF_DROP(oq); /* drop the data */
m_freem(m);
ds->dda_if.if_collisions++; /* for netstat display */
splx(s);
return (ENOBUFS);
}
IF_ENQUEUE(oq, m); /* otherwise queue it */
dda_start(ds, dc); /* and try to output */
splx(s);
return (0);
} else { /* if no circuit available */
IF_DROP(&ifp->if_snd); /* drop the data */
m_freem(m);
splx(s);
return (EHOSTUNREACH);
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DDATIMER() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine is entered to perform timer management. The */
/* LCN table is scanned for active timers (nonzero) which are */
/* decremented. If a timer expires (becomes zero), the proper */
/* action is taken. */
/* */
/* */
/* Call: ddatimer(unit) */
/* Arguments: unit: ACP device unit number */
/* Returns: nothing */
/* Called by: ddainit() */
/* Calls to: splimp() */
/* send_restart() */
/* clear_lcn() */
/* splx() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
int
ddatimer(unit)
int unit;
{
register struct dda_softc *ds = &dda_softc[unit];
register struct dda_cb *dc;
register int s, lcn;
#ifdef DDADEBUG
if (DDADBCH(3, unit)) {
DDALOG(LOG_DEBUG) "dda%d: ddatimer()\n", unit DDAELOG;
}
#endif DDADEBUG
ds->dda_if.if_timer = DDA_TIMEOUT; /* restart timer */
dc = ds->dda_cb;
s = splimp();
/* LCNLINK */
for (lcn = 0; lcn <= nddach[unit]; lcn++) { /* scan all LCN's */
#ifdef DDADEBUG
if (dc->dc_out_t && lcn > 0 && (--(dc->dc_out_t) == 0)) {
DDALOG(LOG_DEBUG) "dda%d: write completion timeout lcn %d\n",
unit, lcn DDAELOG;
}
#endif
if (dc->dc_timer && (--(dc->dc_timer) == 0)) { /* if a timer expired */
if (dc->dc_state == LC_RESTART) { /* if a restart was out */
send_restart(ds); /* send another one */
break;
} else { /* otherwise */
#ifdef DDA_PAD_OR_RAW
/* if it is not an X.29 connection */
if ((dc->dc_flags & (DC_X29W | DC_X29 | DC_RAW)) == 0)
#endif
clear_lcn(ds, dc); /* clear the LCN */
}
}
dc++;
}
splx(s);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DIAGS_COMPLETED() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine checks to see that power up diagnostics have completed*/
/* It waits for a while if necessary. */
/* Call: diags_completed(ds) */
/* Argument: ds - pointer to softc structure; */
/* Returns: 0 if board is up, EINTR if it never came on line. */
/* Called by: ddaioctl() */
/* Calls to: */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
diags_completed(ds)
struct dda_softc *ds;
{
int nretries = 10;
/*
* It's overkill to check this on EVERY ioctl, because it only matters if
* we are going to touch the board. But the driver has had repeated
* problems with not checking it when it should have - overkill is
* preferred. The delays are here rather then in the acpconfig program
* due to a bug in acpconfig. They will only be executed during
* /etc/rc.local when the board has not had a chance to do the "B"
* interrupt yet. At that time the machine will be running essentially
* single thread so it won't really matter where the delays are. (ie, if
* we put the delay into acpconfig and kept calling here 10 times, the
* machine would not do anything else useful in the meantime - might as
* well loop here).
*/
while (((ds->dda_flags & DDAF_OK) == 0) && nretries-- > 0)
DELAY(3000000);
if ((ds->dda_flags & DDAF_OK) == 0) /* never came on line... */
return (EINTR);
else
return (0);
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% %%*/
/*%% LOCAL FUNCTIONS %%*/
/*%% %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% SEND_CONFIG() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* Send a Set System Parameters Message to the front end in */
/* response to an ACPCONFIG command from the user. */
/* */
/* Call: send_config(ds, p) */
/* Argument: ds: pointer to ACP device control structure */
/* p: pointer to the message */
/* Returns: nothing */
/* Called by: ddaioctl() */
/* Calls to: MGET() */
/* DDALOG() */
/* mtod() */
/* bcopy() */
/* sizeof() */
/* start_supr() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
send_config(ds, p)
struct dda_softc *ds;
u_char *p;
{
struct mbuf *m;
register u_char *bp;
int length;
#ifdef DDADEBUG
if (DDADBCH(7, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: send_config()\n", ds->dda_if.if_unit DDAELOG;
}
#endif DDADEBUG
MGET(m, M_DONTWAIT, MT_DATA);
if (m == 0) {
DMESG(ds->dda_if.if_unit, 18,
(DDALOG(LOG_ERR) "dda%d: can't get bfr for acpconfig msg\n",
ds->dda_if.if_unit DDAELOG));
return;
}
bp = mtod(m, u_char *); /* point to data section of mbuf */
length = p[MSG_LENGTH] + MSG_OFFSET; /* msg length */
if (length > MLEN - 1) {
/*
* Supervisory messages have to fit in a small mbuf. The driver
* itself is careful never to get in trouble this way, but now that
* we have "-m" the user could. Dropping such a message is not
* likely to cause any big problems, and the user can rephrase the
* request.
*/
DMESG(ds->dda_if.if_unit, 19,
(DDALOG(LOG_ERR) "dda%d: supervisor message too long\n",
ds->dda_if.if_unit DDAELOG));
m->m_next = 0;
m_freem(m);
return;
}
bcopy(p, bp, length);
m->m_len = length; /* set msg length */
#ifdef DDADEBUG
if (DDADBCH(8, ds->dda_if.if_unit)) {
prt_bytes(ds->dda_if.if_unit, "send_config", bp, length);
}
#endif DDADEBUG
start_supr(ds, m);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% LOCATE_X25_LCN() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine tries to locate an X25 LCN associated with a */
/* remote internet address. A linear search of the LCN table */
/* is made for a matching address. If the search succeeds, the */
/* LCN is returned. If the search fails, the LCN table is */
/* searched for an unused table entry. If an unused table */
/* entry is found, an X25 call is generated to the host */
/* specified in the destination internet address. If no LCN is */
/* available, zero is returned. */
/* */
/* Call: locate_x25_lcn(ds, ip_addr) */
/* Argument: ds: pointer to dev control block struct */
/* ip_addr: IP address */
/* Returns: pointer to the dda control block which */
/* contains LCN, else zero for failure */
/* Called by: ddaoutput() */
/* Calls to: convert_ip_addr() */
/* make_x25_call() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE struct dda_cb *
locate_x25_lcn(ds, ip_addr)
struct dda_softc *ds;
struct in_addr ip_addr;
{
register int lcn, maxlcn;
register struct dda_cb *dc;
union imp_addr imp_addr;
#ifdef DDADEBUG
if (DDADBCH(9, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: locate_x25_lcn()\n",
ds->dda_if.if_unit DDAELOG;
}
#endif DDADEBUG
imp_addr.ip = ip_addr; /* DDN X.25 doesn't know net number */
if (!(ds->dda_init & DDA_PDN)) {
if ((imp_addr.imp.s_net & 0x80) == 0x00) { /* class A */
imp_addr.imp.s_net = 0;
imp_addr.imp.s_lh = 0;
} else if ((imp_addr.imp.s_net & 0xc0) == 0x80) { /* class B */
imp_addr.imp.s_net = 0;
imp_addr.imp.s_host = 0;
} else { /* class C, should check for class C */
imp_addr.imp.s_net = 0;
imp_addr.imp.s_host = 0;
imp_addr.imp.s_lh = 0;
}
}
/* LCNLINK */
maxlcn = nddach[ds->dda_if.if_unit];
dc = &(ds->dda_cb[1]); /* scan LCN table for addr match */
for (lcn = 1; lcn <= maxlcn; lcn++) {
if ((dc->dc_key.key_addr.s_addr == imp_addr.ip.s_addr)
&& (dc->dc_state == LC_CALL_PENDING || dc->dc_state == LC_DATA_IDLE))
return (dc); /* return LCN */
dc++;
}
if ((dc = find_free_lcn(ds)) == 0)
return (0);
ddacb_user_data[0] = (u_char) 0; /* we have no user data */
if (convert_ip_addr(ip_addr, ddacb_called_addr, ds)
&& make_x25_call(ds, dc, ip_addr, X25_PROTO_IP)) {
/* addr can be converted */
dc->dc_inaddr = ip_addr; /* store dest ip addr */
dc->dc_key.key_addr.s_addr = imp_addr.ip.s_addr;
/* store match key */
#ifdef DDADEBUG
if (DDADBCH(9, ds->dda_if.if_unit)) {
imp_addr.ip = ip_addr;
DDALOG(LOG_DEBUG)
"dda%d: locate_x25_lcn: made call to %d.%d.%d.%d\n",
ds->dda_if.if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno DDAELOG;
}
#endif DDADEBUG
return (dc); /* and return the LCN */
} else {
return (0); /* give up */
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% FIND_FREE_LCN() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine tries to locate a free X25 LCN. */
/* The LCN table is searched for an unused entry. */
/* If no LCN is available, zero is returned. */
/* */
/* Call: find_free_lcn(ds) */
/* Argument: ds: pointer to dev control block struct */
/* Returns: pointer to the dda control block which */
/* contains LCN, else zero for failure */
/* Called by: locate_x25_lcn() */
/* supr_msg() */
/* xxcntl() */
/* Calls to: DDALOG() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE struct dda_cb *
find_free_lcn(ds)
struct dda_softc *ds;
{
struct dda_cb *dc;
register int lcn, maxlcn, dwnflg = 0;
/* LCNLINK */
dc = &(ds->dda_cb[1]); /* scan LCN table for free entry */
maxlcn = nddach[ds->dda_if.if_unit];
for (lcn = 1; lcn <= maxlcn; lcn++) {
#ifdef DDA_PAD_OR_RAW
if (dc->dc_state == LC_IDLE && (dc->dc_flags & (DC_X29W | DC_X29 | DC_RAW)) == 0)
#else
if (dc->dc_state == LC_IDLE)
#endif DDA_PAD_OR_RAW
break;
else if (dc->dc_state == LC_RESTART || dc->dc_state == LC_DOWN)
dwnflg = 1;
dc++;
}
/* LCNLINK */
if (lcn > maxlcn) { /* if we didn't find a free entry */
if (LOG_BUSY) {
if (dwnflg)
DDALOG(LOG_ERR) "dda%d: no circuits available (link not up)\n",
ds->dda_if.if_unit DDAELOG;
else
DDALOG(LOG_ERR) "dda%d: all circuits in use\n",
ds->dda_if.if_unit DDAELOG;
}
return (0); /* return empty handed */
}
return (dc);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% CONVERT_IP_ADDR() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* Based on the type of X.25 service, this routine performs */
/* one of two functions. For PDN X.25 service, the address */
/* translation table is searched for presence of local X.25 */
/* address (which was entered by the user via acpconfig). */
/* */
/* For DDN X.25 service, this routine accepts an internet */
/* address and attempts to translate to an equivalent X25 */
/* address. This follows the guidelines in the DDN X25 */
/* interface spec. The resultant X25 address is stored in the */
/* X25 called addr buffer. */
/* */
/* NOTE: Although front end was designed to accept ASCII coded */
/* digits for the address fields, we only supply the binary */
/* values. The front end only uses low four bits to extract */
/* the binary value from the ASCII digits, so this works out. */
/* */
/* */
/* */
/* */
/* */
/* */
/* Call: convert_ip_addr(ip_addr, x25addr, ds) */
/* Argument: ip_addr: IP address */
/* x25addr: X.25 address */
/* ds: &dda_softc[unit] */
/* Returns: 1 for success */
/* Called by: locate_x25_lcn() */
/* make_x25_call() */
/* ddaioctl() */
/* Calls to: bcopy() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE boolean
convert_ip_addr(ip_addr, x25addr, ds)
struct in_addr ip_addr;
u_char x25addr[];
struct dda_softc *ds;
{
register struct dda_addr_tr *atp, *hip, *lop;
register int temp;
union imp_addr imp_addr;
/****************************************************************/
/* processing for Public Data Network (PDN) X.25 service */
/* search address translation table for local address */
/****************************************************************/
if (ds->dda_init & DDA_PDN) {
x25addr[0] = 0; /* clear result X.25 address length */
lop = &dda_addr_tr[ds->dda_if.if_unit][0]; /* set up for binary
* search */
hip = &dda_addr_tr[ds->dda_if.if_unit][dda_num_addr_tr[ds->dda_if.if_unit]];
while (lop < hip - 1) { /* binary search loop */
atp = lop + (hip - lop) / 2;
if (atp->ip_addr > ip_addr.s_addr)
hip = atp;
else
lop = atp;
}
if (lop->ip_addr == ip_addr.s_addr)
bcopy(lop->x25_addr, x25addr, MAXADDRLEN);
}
/****************************************************************/
/* processing for DDN Standard or Basic X.25 service */
/* convert IP address to X.25 address */
/****************************************************************/
else {
int imp_no, imp_port;
imp_addr.ip = ip_addr;
if ((imp_addr.imp.s_net & 0x80) == 0x00) { /* class A */
imp_no = imp_addr.imp.s_impno;
imp_port = imp_addr.imp.s_host;
} else if ((imp_addr.imp.s_net & 0xc0) == 0x80) { /* class B */
imp_no = imp_addr.imp.s_impno;
imp_port = imp_addr.imp.s_lh;
} else { /* class C */
imp_no = imp_addr.imp.s_impno / 32;
imp_port = imp_addr.imp.s_impno % 32;
}
x25addr[0] = 12; /* set addr length */
x25addr[1] = 0; /* clear DNIC */
x25addr[2] = 0;
x25addr[3] = 0;
x25addr[4] = 0;
if (imp_port < 64) { /* Physical: 0000 0 IIIHH00 [SS] *//* s_impno
* -> III, s_host -> HH */
x25addr[5] = 0; /* set flag bit */
x25addr[6] = imp_no / 100;
x25addr[7] = (imp_no % 100) / 10;
x25addr[8] = imp_no % 10;
x25addr[9] = imp_port / 10;
x25addr[10] = imp_port % 10;
} else { /* Logical: 0000 1 RRRRR00 [SS] *//* s
* _host * 256 + s_impno -> RRRRR */
temp = (imp_port << 8) + imp_no;
x25addr[5] = 1;
x25addr[6] = temp / 10000;
x25addr[7] = (temp % 10000) / 1000;
x25addr[8] = (temp % 1000) / 100;
x25addr[9] = (temp % 100) / 10;
x25addr[10] = temp % 10;
}
x25addr[11] = 0; /* clear rest of addr */
x25addr[12] = 0;
}
#ifdef DDADEBUG
if (DDADBCH(11, ds->dda_if.if_unit)) {
imp_addr.ip = ip_addr;
DDALOG(LOG_DEBUG) "dda%d: convert_ip_addr: %d.%d.%d.%d ==> %s\n",
ds->dda_if.if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno,
fmt_x25(&x25addr[1], (int) x25addr[0]) DDAELOG;
}
#endif DDADEBUG
return (x25addr[0] ? 1 : 0);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% CONVERT_X25_ADDR() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine accepts an X25 address and attempts to */
/* translate to an equivalent internet address. For DDA this */
/* follows the guidelines in the DDA X25 interface spec. The */
/* resultant internet address is returned to the caller. */
/* */
/* Call: convert_x25_addr(x25addr, ds) */
/* Argument: x25addr: X.25 address */
/* ds: &dda_softc[unit] */
/* dc: pointer to allocated dda_cb structure */
/* Returns: IP address for success, else zero for fail */
/* Called by: supr_msg() */
/* Calls to: DDALOG() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE u_long
convert_x25_addr(x25addr, ds, dc)
u_char x25addr[];
struct dda_softc *ds;
struct dda_cb *dc;
{
register int cnt, temp;
union imp_addr imp_addr;
register struct dda_addr_tr *atp;
dc->dc_inaddr.s_addr = imp_addr.ip.s_addr = 0L;
if (ds->dda_init & DDA_PDN) {
for (atp = &dda_addr_tr[ds->dda_if.if_unit][0];
atp < &dda_addr_tr[ds->dda_if.if_unit][dda_num_addr_tr[ds->dda_if.if_unit]]; atp++) {
if (bcmp((char *) atp->x25_addr, (char *) x25addr, x25addr[0] + 1) == 0) {
/* set key address and print address up */
dc->dc_inaddr.s_addr = imp_addr.ip.s_addr = atp->ip_addr;
break;
}
}
} else {
int imp_no, imp_port;
struct in_addr my_addr;
my_addr = ds->dda_ipaddr;
if (((cnt = x25addr[0]) < MINADDRLEN - 1) || (cnt > MAXADDRLEN - 1)) {
DMESG(ds->dda_if.if_unit, 20,
(DDALOG(LOG_ERR) "dda%d: illegal X25 address length!\n",
ds->dda_if.if_unit DDAELOG));
return (0L);
}
switch (x25addr[5] & 0x0f) {
case 0: /* Physical: 0000 0 IIIHH00 [SS] */
imp_no =
((int) (x25addr[6] & 0x0f) * 100) +
((int) (x25addr[7] & 0x0f) * 10) +
((int) (x25addr[8] & 0x0f));
imp_port =
((int) (x25addr[9] & 0x0f) * 10) +
((int) (x25addr[10] & 0x0f));
break;
case 1: /* Logical: 0000 1 RRRRR00 [SS] */
temp = ((int) (x25addr[6] & 0x0f) * 10000)
+ ((int) (x25addr[7] & 0x0f) * 1000)
+ ((int) (x25addr[8] & 0x0f) * 100)
+ ((int) (x25addr[9] & 0x0f) * 10)
+ ((int) (x25addr[10] & 0x0f));
imp_port = temp >> 8;
imp_no = temp & 0xff;
break;
default:
DMESG(ds->dda_if.if_unit, 21,
(DDALOG(LOG_ERR) "dda%d: illegal X25 address format!\n",
ds->dda_if.if_unit DDAELOG));
return (0L);
}
dc->dc_inaddr = imp_addr.ip = my_addr; /* use local net number */
if ((imp_addr.imp.s_net & 0x80) == 0x00) { /* class A */
imp_addr.imp.s_net = 0; /* mask net number */
imp_addr.imp.s_lh = 0; /* mask logical host */
imp_addr.imp.s_host = imp_port;
((union imp_addr *) & dc->dc_inaddr.s_addr)->imp.s_host = imp_port;
imp_addr.imp.s_impno = imp_no;
((union imp_addr *) & dc->dc_inaddr.s_addr)->imp.s_impno = imp_no;
} else if ((imp_addr.imp.s_net & 0xc0) == 0x80) { /* class B */
imp_addr.imp.s_net = 0;
imp_addr.imp.s_lh = imp_port;
((union imp_addr *) & dc->dc_inaddr.s_addr)->imp.s_lh = imp_port;
imp_addr.imp.s_host = 0;
imp_addr.imp.s_impno = imp_no;
((union imp_addr *) & dc->dc_inaddr.s_addr)->imp.s_impno = imp_no;
} else { /* class C */
imp_addr.imp.s_impno = (imp_no << 5) + imp_port;
((union imp_addr *) & dc->dc_inaddr.s_addr)->imp.s_impno = imp_addr.imp.s_impno;
imp_addr.imp.s_lh = 0;
imp_addr.imp.s_host = 0;
imp_addr.imp.s_net = 0;
}
}
#ifdef DDADEBUG
if (DDADBCH(12, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: convert_x25_addr: %s ==> %d.%d.%d.%d\n",
ds->dda_if.if_unit, fmt_x25(&x25addr[1], (int) x25addr[0]),
imp_addr.imp.s_net, imp_addr.imp.s_host, imp_addr.imp.s_lh,
imp_addr.imp.s_impno DDAELOG;
}
#endif DDADEBUG
return (imp_addr.ip.s_addr);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% MAKE_X25_CALL() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine places an X25 call using the X25 Call Msg */
/* buffer. The calling LCN is placed in the appropriate state */
/* and a timer is started. Based on dda_init flag, implement */
/* DDN standard or basic service. (If PDN mode is set, then */
/* the logic for basic service is followed.) */
/* */
/* Call: make_x25_call(ds, dc, ip_addr, proto */
/* udlen, ud) */
/* Arguments: ds: pointer to device control structure */
/* dc: pointer to the Logical Channel control */
/* block structure */
/* ip_addr: callee's ip address */
/* proto: protocol identifier byte */
/* udlen: user data length */
/* ud: user data */
/* Returns: one for success, zero for failure */
/* Called by: locate_x25_lcn() */
/* Calls to: MGET() */
/* mtod() */
/* convert_ip_addr() */
/* bcopy() */
/* IF_ENQUEUE() */
/* start_supr() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE boolean
make_x25_call(ds, dc, ip_addr, proto, udlen, ud)
register struct dda_softc *ds;
register struct dda_cb *dc;
struct in_addr ip_addr;
u_char proto;
u_char udlen;
u_char *ud;
{
register struct mbuf *m_callbfr;
register u_char *cb;
union imp_addr imp_addr;
#if ACC_BSD == 42 || ACC_ULTRIX == 12
struct sockaddr_in *our_addr;
#endif
#ifdef DDADEBUG
if (DDADBCH(13, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: make_x25_call: lcn used = %d\n",
ds->dda_if.if_unit, dc->dc_lcn DDAELOG;
}
#endif DDADEBUG
MGET(m_callbfr, M_DONTWAIT, MT_DATA); /* try to get call cmnd
* buffer */
if (m_callbfr == 0) {
DMESG(ds->dda_if.if_unit, 22,
(DDALOG(LOG_ERR) "dda%d: couldn't get mbuf for call command\n",
ds->dda_if.if_unit DDAELOG));
return (0);
}
cb = mtod(m_callbfr, u_char *);
if (ds->dda_net_id == TRANSPAC) {
ddacb_calling_addr[0] = 0; /* send a 0 length calling address */
} else {
#if ACC_BSD == 42 || ACC_ULTRIX == 12
our_addr = (struct sockaddr_in *) & (ds->dda_if.if_addr);
(void) convert_ip_addr(our_addr->sin_addr, ddacb_calling_addr, ds);
#else
(void) convert_ip_addr(ds->dda_ipaddr, ddacb_calling_addr, ds);
#endif
}
ddacb_protocol[0] = 4;
ddacb_protocol[1] = proto; /* protocol type */
ddacb_protocol[2] = 0;
ddacb_protocol[3] = 0;
ddacb_protocol[4] = 0;
/*
* CCITT standard facilities must precede DDN specific facilities See BBN
* report 5476 section 2.1.2. Firmware preceding rev 0x20 does not
* support packet size / window negotiation.
*/
ddacb_facilities[0] = 0; /* initialize facilities length */
if (ds->dda_firmrev >= 0x21) {
ddacb_facilities[0] = 0;
if (ds->dda_init & DDA_PKTNEG) {
int n = ddacb_facilities[0]; /* length so far */
ddacb_facilities[n + 1] = X25_FACIL_PKTSIZE;
ddacb_facilities[n + 2] = PKTSIZE_LARGE;
ddacb_facilities[n + 3] = PKTSIZE_LARGE;
ddacb_facilities[0] += 3;
}
if (ds->dda_init & DDA_WNDNEG) {
int n = ddacb_facilities[0]; /* length so far */
ddacb_facilities[n + 1] = X25_FACIL_WINSIZE;
ddacb_facilities[n + 2] = WINSIZE_LARGE;
ddacb_facilities[n + 3] = WINSIZE_LARGE;
ddacb_facilities[0] += 3;
}
}
if ((ds->dda_init & (DDA_BASIC | DDA_PDN)) == 0) { /* DDN standard mode,
* tell callee */
int n = ddacb_facilities[0]; /* length so far */
ddacb_facilities[0] += 4; /* additional facility bytes */
ddacb_facilities[n + 1] = DDN_FACIL_MARKER; /* end of CCITT stuff, */
ddacb_facilities[n + 2] = DDN_FACIL_MARKER; /* and start DDN local */
ddacb_facilities[n + 3] = X25_FACIL_DDA; /* DDA standard mode */
ddacb_facilities[n + 4] = FAC_DDASTD;
}
ddacb_cmnd[0] = CALL; /* set command code */
ddacb_cmnd[1] = dc->dc_lcn << 1; /* set channel id */
ddacb_cmnd[2] = 0;
ddacb_cmnd[3] = (ddacb_called_addr[0] + 1) + /* tally cmnd ext len */
(ddacb_calling_addr[0] + 1) +
(ddacb_protocol[0] + 1) +
(ddacb_facilities[0] + 1) +
(ddacb_user_data[0] + 1);
if ((unsigned) ddacb_cmnd[3] + 4 > MLEN) {
DMESG(ds->dda_if.if_unit, 38, (DDALOG(LOG_ERR)
"dda%d: make_x25_call message too large for mbuf (%d bytes)\n",
ds->dda_if.if_unit, (unsigned) ddacb_cmnd[3] + 4 DDAELOG));
return 0; /* failure */
}
m_callbfr->m_len = ddacb_cmnd[3] + 4;
/* copy command header */
bcopy(ddacb_cmnd, cb, 4);
cb += 4;
/* copy called address */
bcopy(ddacb_called_addr, cb, ddacb_called_addr[0] + 1);
cb += (ddacb_called_addr[0] + 1);
/* copy calling address */
bcopy(ddacb_calling_addr, cb, ddacb_calling_addr[0] + 1);
cb += (ddacb_calling_addr[0] + 1);
/* copy protocol */
bcopy(ddacb_protocol, cb, ddacb_protocol[0] + 1);
cb += (ddacb_protocol[0] + 1);
/* copy facilities */
bcopy(ddacb_facilities, cb, ddacb_facilities[0] + 1);
cb += (ddacb_facilities[0] + 1);
/* copy user data */
bcopy(ddacb_user_data, cb, ddacb_user_data[0] + 1);
cb += (ddacb_user_data[0] + 1);
hist_lcn_state(ds->dda_if.if_unit, dc->dc_state, LC_CALL_PENDING);
dc->dc_state = LC_CALL_PENDING; /* set state */
dc->dc_timer = TMO_CALL_PENDING; /* start call timeout */
#ifdef DDADEBUG
if (DDADBCH(13, ds->dda_if.if_unit)) {
prt_bytes(ds->dda_if.if_unit, "make_x25_call: call_bfr",
mtod(m_callbfr, u_char *), m_callbfr->m_len);
}
#endif DDADEBUG
if (LOG_CALLS) {
imp_addr.ip = ip_addr;
DDALOG(LOG_ERR) "dda%d: Calling %d.%d.%d.%d (%s) on lcn %d\n",
ds->dda_if.if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno,
fmt_x25(&ddacb_called_addr[1], (int) ddacb_called_addr[0]),
dc->dc_lcn
DDAELOG;
}
start_supr(ds, m_callbfr);
return (1);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DDA_START() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine attempts to start output of data queued on a */
/* specific LCN. If the LCN was not already busy and data is */
/* available for output, the data is copied into the LCN's I/O */
/* buffer and a write request queued to the ACP device. Data */
/* is passed in mbuf(s) from IP to ddaoutput(), ddaoutput() */
/* queues the data, and the data is dequeued here. */
/* */
/* Call: dda_start(ds, dc) */
/* Arguments: ds: pointer to device control structure */
/* dc: pointer to the Logical Channel control */
/* block structure */
/* Returns: nothing */
/* Called by: ddaoutput() */
/* x25_init() */
/* make_x25_call() */
/* supr_msg() */
/* send_supr() */
/* dda_data() */
/* dda_supr() */
/* Calls to: IF_DEQUEUE() */
/* dda_wrq() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
dda_start(ds, dc)
register struct dda_softc *ds;
register struct dda_cb *dc;
{
register struct mbuf *m;
register struct hdx_chan *hc = &dc->dc_wchan;
register int s;
#ifdef DDADEBUG
if (DDADBCH(14, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: dda_start()\n", ds->dda_if.if_unit DDAELOG;
}
#endif DDADEBUG
/*
* If output isn't active, attempt to start sending a new packet.
*/
if ((dc->dc_flags & DC_OBUSY) || (dc->dc_oq.ifq_len == 0) ||
((dc->dc_lcn != 0) && (dc->dc_state != LC_DATA_IDLE))) {
return;
}
if (dc->dc_lcn != 0)
dc->dc_timer = tmo_data_idle;
/*
* Raise priority whenever touching dc_oq because
* the mbufs on this queue may be asynchronously
* freed upon receipt of a line status msg, restart,
* clear, or reset.
*/
s = splimp();
IF_DEQUEUE(&dc->dc_oq, m);
splx(s);
if (m == 0) { /* XXX this is a bug catcher XXX */
DMESG(ds->dda_if.if_unit, 24,
(DDALOG(LOG_ERR) "dda%d: dequeued NULL mbuf in IP output chain!\n",
ds->dda_if.if_unit DDAELOG));
DMESG(ds->dda_if.if_unit, 24,
(DDALOG(LOG_ERR) "RESET dda%d MANUALLY: use /etc/acpconfig dda%d -z\n",
ds->dda_if.if_unit, ds->dda_if.if_unit DDAELOG));
ds->dda_if.if_flags &= ~(IFF_RUNNING | IFF_UP);
hist_link_state(ds->dda_if.if_unit, ds->dda_state, S_DISABLED);
ds->dda_state = S_DISABLED;
dda_disable(ds->dda_if.if_unit);
return;
}
s = splimp();
hc->hc_mbuf = m;
hc->hc_curr = m;
#ifdef DDA_PAD_OR_RAW /* crufty kludge to get the Qbit */
if (dc->dc_flags & (DC_X29 | DC_X29W | DC_RAW)) { /* raw or x29? */
if (m->m_len < (MLEN - 1)) /* small mbuf? */
hc->hc_sbfc = m->m_dat[MLEN - 1]; /* ok, get the subfunc byte */
else
hc->hc_sbfc = 0; /* subfunc must be zero for large buffers */
} else
hc->hc_sbfc = 0; /* subfunc must be zero for ip buffers */
#else
hc->hc_sbfc = 0;
#endif
splx(s);
dc->dc_flags |= DC_OBUSY;
dda_wrq(ds, hc, 0); /* write request to ACP */
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DDA_DATA() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine is called when a data channel I/O completes. */
/* If the completion was for a write, an attempt is made to */
/* start output on the next packet waiting for output on that */
/* LCN. If the completion was for a read, the received packet */
/* is sent to the IP input queue (if no error) and another read */
/* is started on the LCN. */
/* */
/* Call: dda_data(ds, hc, cc, cnt) */
/* Argument: ds: device control block */
/* hc: half duplex channel control block */
/* cc: Mailbox I/O completion status */
/* cnt: byte count */
/* Returns: nothing */
/* Called by: ddainta() */
/* Calls to: m_freem() */
/* dda_start() */
/* IF_QFULL() */
/* IF_DROP() */
/* IF_ENQUEUE() */
/* schednetisr() */
/* dda_rrq() */
/* dda_wrq() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
dda_data(ds, hc, cc, cnt)
register struct dda_softc *ds;
register struct hdx_chan *hc;
int cc, cnt;
{
register struct dda_cb *dc = &(ds->dda_cb[hc->hc_chan / 2]);
struct ifqueue *inq = &ipintrq; /* IP input queue */
/* note that this routine is a weird case in which Ultrix 2.0 behaves like
* a 4.2 system rather than a 4.3 system. This is reflected in the structure
* of conditional compilation segments.
*/
#if ACC_BSD > 42 /* 4.3bsd or newer */
register struct mbuf *m, *mb;
struct ifnet *ifp;
#else /* 4.2, or all flavors of Ultrix */
register struct mbuf *m;
#endif
#ifdef DDADEBUG
if (DDADBCH(18, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: dda_data: chan=%d cc=%x cnt=%x\n",
ds->dda_if.if_unit, hc->hc_chan, cc, cnt DDAELOG;
}
#endif DDADEBUG
#if ACC_BSD > 42
ifp = &ds->dda_if;
#endif
if (hc->hc_chan & 0x01) { /* was it read or write? *//* write, fire up
* next output */
#ifdef DDADEBUG
dc->dc_out_t = TMO_OFF; /* turn off output completion timer */
#endif
hc = &dc->dc_wchan;
if ((hc->hc_func != DDAABT) && (hc->hc_curr = hc->hc_curr->m_next))
dda_wrq(ds, hc, 0);
else {
m_freem(hc->hc_mbuf);
hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
if (hc->hc_func == DDAABT) {
hc->hc_func &= ~DDAABT;
hc->hc_inv &= ~INVALID_MBUF;
} else
ds->dda_if.if_opackets++;
dc->dc_flags &= ~DC_OBUSY;
dda_start(ds, dc);
}
} else { /* read, process rcvd packet */
hc = &dc->dc_rchan;
#ifdef DDADEBUG
if (DDADBCH(19, ds->dda_if.if_unit)) {
u_char *p;
p = mtod(hc->hc_curr, u_char *);
prt_bytes(ds->dda_if.if_unit, "received data", p, (cnt < 64 ? cnt : 64));
}
#endif DDADEBUG
if (cc == DDAIOCOK) { /* Queue good packet for input */
#ifdef DDADEBUG
if (DDADBCH(19, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: dda_data: chan=%d DDAIOCOK\n",
ds->dda_if.if_unit, hc->hc_chan DDAELOG;
}
#endif DDADEBUG
ds->dda_if.if_ipackets++;
hist_lcn_state(ds->dda_if.if_unit, dc->dc_state, LC_DATA_IDLE);
if (dc->dc_state == LC_DATA_IDLE)
dc->dc_timer = tmo_data_idle;
hc->hc_curr->m_len += cnt; /* update byte count */
m = hc->hc_mbuf; /* que mbuf chain */
#if ACC_BSD > 42
/* Prepend ifp pointer for 4.3 */
MGET(mb, M_DONTWAIT, MT_DATA);
if (mb == 0) {
DMESG(ds->dda_if.if_unit, 26,
(DDALOG(LOG_ERR) "dda%d: couldn't get mbuf for ifp header\n",
ds->dda_if.if_unit DDAELOG));
m_freem(m);
return;
}
*(mtod(mb, struct ifnet **)) = ifp;
mb->m_len = sizeof(ifp);
mb->m_next = m;
if (IF_QFULL(inq)) {
IF_DROP(inq);
m_freem(mb);
} else {
IF_ENQUEUE(inq, mb);
schednetisr(NETISR_IP);
}
#else
if (IF_QFULL(inq)) {
IF_DROP(inq);
m_freem(m);
} else {
IF_ENQUEUE(inq, m);
schednetisr(NETISR_IP);
}
#endif
hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
} else if (cc == DDAIOCOKP) { /* good completion, more data pending */
hc->hc_curr->m_len += cnt;
} else {
m_freem(hc->hc_mbuf);
hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
}
/* hang a new data read */
dda_rrq(ds, hc);
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DDA_SUPR() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine is called when a supervisor I/O completes. */
/* If the completion was for a write, an attempt is made to */
/* start output on the next supervisor command waiting for */
/* output. If the completion was for a read, the received */
/* supervisor message is processed and another read is started. */
/* */
/* Call: dda_supr(ds, hc, cc) */
/* Argument: ds: device control block */
/* hc: half duplex channel control block */
/* cc: Mailbox I/O completion status */
/* Returns: nothing */
/* Called by: ddainta() */
/* Calls to: dda_start() */
/* mtod() */
/* supr_msg() */
/* m_free() */
/* dda_rrq() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
dda_supr(ds, hc, cc, cnt)
register struct dda_softc *ds;
struct hdx_chan *hc;
int cc;
int cnt;
{
register struct dda_cb *dc = &(ds->dda_cb[hc->hc_chan / 2]);
u_char *p;
#ifdef DDADEBUG
if (DDADBCH(20, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: dda_supr: chan=%d cc=%x\n",
ds->dda_if.if_unit, hc->hc_chan, cc DDAELOG;
}
#endif DDADEBUG
/* an odd-numbered channel indicates a write */
/* the supr msg is assumed to be in 1 mbuf */
if (hc->hc_chan & 0x01) {
m_freem(hc->hc_mbuf);
hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
dc->dc_flags &= ~DC_OBUSY;
dda_start(ds, dc);
}
/* otherwise, process the read */
else {
if (cc == DDAIOCOK) {
p = mtod(hc->hc_curr, u_char *); /* point to data in mbuf */
#ifdef DDA_PAD_OR_RAW
switch (dda_decode_type(ds, p)) {
# ifdef DDA_PADOPT
case 1:
# ifdef DDADEBUG
if (DDADBCH(20, ds->dda_if.if_unit)) {
printf("dda%d: dda_supr(): case 1: chan = %x, p = %x\n",
ds->dda_if.if_unit, hc->hc_chan, *p);
}
# endif DDADEBUG
x29_supr(ds, p);
break;
# endif
# ifdef DDA_RAWOPT
case 2:
# ifdef DDADEBUG
if (DDADBCH(20, ds->dda_if.if_unit)) {
printf("dda%d: dda_supr(): case 2: chan = %x, p = %x\n",
ds->dda_if.if_unit, hc->hc_chan, *p);
}
# endif DDADEBUG
hc->hc_curr->m_len += cnt;
pi_supr(ds, hc->hc_curr);
/* don't free mbuf here */
hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
dda_rrq(ds, hc);/* hang a new supr read */
return;
# endif
default:
supr_msg(ds, p);/* process supervisor message */
break;
}
#else DDA_PAD_OR_RAW
supr_msg(ds, p); /* process supervisor message */
#endif DDA_PAD_OR_RAW
} else if (cc == DDAIOCOKP) {
DMESG(ds->dda_if.if_unit, 28,
(DDALOG(LOG_ERR) "dda%d: truncated supervisor message\n",
ds->dda_if.if_unit DDAELOG));
}
m_freem(hc->hc_mbuf);
hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
dda_rrq(ds, hc); /* hang a new supr read */
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% SUPR_MSG() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine processes received supervisor messages. */
/* Depending on the message type, the appropriate action is */
/* taken. */
/* */
/* Call: supr_msg(ds, p) */
/* Arguments: ds: pointer to dev control block struct */
/* p: pointer to a character array */
/* containing the supervisor message */
/* Returns: nothing */
/* Called by: dda_supr() */
/* Calls to: DDALOG() */
/* IF_DEQUEUE() */
/* m_freem() */
/* send_restart() */
/* send_supr() */
/* dda_start() */
/* decode_ring() */
/* decode_answer() */
/* convert_x25_addr() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
supr_msg(ds, p)
struct dda_softc *ds;
u_char p[];
{
register struct dda_cb *dc;
register int lcn;
register int maxlcn;
union imp_addr imp_addr;
#ifdef DDADEBUG
if (DDADBCH(21, ds->dda_if.if_unit)) {
prt_bytes(ds->dda_if.if_unit, "supr_msg", p, (int) (4 + p[3]));
}
#endif DDADEBUG
maxlcn = nddach[ds->dda_if.if_unit]; /* obtain SVC limit */
switch (p[0]) {
case LINE_STATUS: /* link status msg */
if (p[2] == LINK_UP) { /* if link came up */
#ifdef DDADEBUG
if (DDADBCH(21, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: supr_msg: HDLC link up\n",
ds->dda_if.if_unit DDAELOG;
}
#endif DDADEBUG
send_restart(ds); /* send restart msg */
ds->dda_state = S_COMING_UP;
} else { /* if link went down */
ds->dda_if.if_flags &= ~IFF_UP; /* ? should call if_down() ? */
hist_link_state(ds->dda_if.if_unit, ds->dda_state, S_DISABLED);
ds->dda_state = S_DISABLED;
dc = ds->dda_cb;
/* LCNLINK */
for (lcn = 0; lcn <= maxlcn; lcn++) { /* for all LCN's */
dc->dc_inaddr.s_addr = 0; /* forget dest address */
dc->dc_key.key_addr.s_addr = 0;
dc->dc_wsizein = dc->dc_wsizeout = 0;
dc->dc_pktsizein = dc->dc_pktsizeout = 0;
dc->dc_state = LC_DOWN; /* set state */
dc->dc_timer = TMO_OFF; /* stop timer */
dc++;
}
hist_all_lcns(ds->dda_if.if_unit, LC_DOWN);
abort_io(ds->dda_if.if_unit, ALL_CHANS);
#ifdef DDA_PADOPT
x29_init(ds->dda_if.if_unit, 1);
#endif
if (p[2] == LINK_DISABLED) /* link disabled */
DMESG(ds->dda_if.if_unit, 29,
(DDALOG(LOG_ERR) "dda%d: link disabled\n",
ds->dda_if.if_unit DDAELOG));
else
DMESG(ds->dda_if.if_unit, 30,
(DDALOG(LOG_ERR) "dda%d: link down\n", ds->dda_if.if_unit DDAELOG));
}
break;
case RESTART: /* restart received */
if (ds->dda_cb[0].dc_state != LC_RESTART) { /* if not restarting */
#ifdef DDADEBUG
if (DDADBCH(21, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG)
"dda%d: supr_msg: RESTART rcvd, no RESTART pending\n",
ds->dda_if.if_unit DDAELOG;
}
#endif DDADEBUG
send_supr(ds, RSTRT_ACK, 0, 0); /* send restart ack */
}
/* fall thru */
case RSTRT_ACK: /* restart ack */
if ((ds->dda_state == S_COMING_UP) || (ds->dda_state == S_LINK_UP)) {
if (p[0] == RSTRT_ACK) {
DMESG(ds->dda_if.if_unit, 31,
(DDALOG(LOG_ERR) "dda%d: Restart Ack received\n",
ds->dda_if.if_unit DDAELOG));
} else { /* restart. print cause and diagnostic. */
DMESG(ds->dda_if.if_unit, 31,
(DDALOG(LOG_ERR) "dda%d: Restart (%x %x) received\n",
ds->dda_if.if_unit, p[2], p[3] ? p[4] : 0 DDAELOG));
}
ds->dda_if.if_flags |= IFF_UP;
hist_link_state(ds->dda_if.if_unit, ds->dda_state, S_LINK_UP);
ds->dda_state = S_LINK_UP;
dc = ds->dda_cb;
/* LCNLINK */
for (lcn = 0; lcn <= maxlcn; lcn++) { /* for all LCN's */
dc->dc_state = LC_IDLE; /* set state */
dc->dc_timer = TMO_OFF; /* stop timer */
dc->dc_inaddr.s_addr = 0; /* forget address */
dc->dc_key.key_addr.s_addr = 0;
dc->dc_wsizein = dc->dc_wsizeout = 0;
dc->dc_pktsizein = dc->dc_pktsizeout = 0;
dc++;
}
hist_all_lcns(ds->dda_if.if_unit, LC_IDLE);
abort_io(ds->dda_if.if_unit, ALL_CHANS);
DMESG(ds->dda_if.if_unit, 32,
(DDALOG(LOG_ERR) "dda%d: (%s rev %d.%d) link up\n",
ds->dda_if.if_unit, dda_product,
(ds->dda_firmrev >> 4) & 0xF, ds->dda_firmrev & 0xF DDAELOG));
#ifdef DDA_PAD_OR_RAW
x29_init(ds->dda_if.if_unit, 1);
/*
* wake up all processes that tried to open a x29 device but
* slept because the board was not up
*/
wakeup(&ds->dda_state);
#endif DDA_PAD_OR_RAW
} else
#ifdef DDADEBUG
if (DDADBCH(21, ds->dda_if.if_unit)) {
DDALOG(LOG_ERR) "dda%d: Unexpected RESTART in state %x\n",
ds->dda_if.if_unit, ds->dda_state DDAELOG;
}
#endif DDADEBUG
break;
case ANSWER: /* call answered */
lcn = p[1] / 2;
dc = &(ds->dda_cb[lcn]);
if (dc->dc_state == LC_CALL_PENDING) { /* if a call pending */
hist_lcn_state(ds->dda_if.if_unit, dc->dc_state, LC_DATA_IDLE);
decode_answer(p, dc);
dc->dc_state = LC_DATA_IDLE; /* set state */
dc->dc_timer = tmo_data_idle; /* start timer */
dda_start(ds, dc); /* try to send data */
}
if (LOG_CALLS) {
DDALOG(LOG_ERR) "dda%d: lcn %d connected\n",
ds->dda_if.if_unit, lcn DDAELOG;
}
break;
case RING: /* incoming call */
/* if ring looks ok, and we find a free LCN to assign */
if (decode_ring(p) && (dc = find_free_lcn(ds))) {
dc->dc_key.key_addr.s_addr =
convert_x25_addr(ddacb_calling_addr, ds, dc);
#ifdef DDADEBUG
if (DDADBCH(21, ds->dda_if.if_unit)) {
imp_addr.ip = dc->dc_inaddr;
DDALOG(LOG_DEBUG)
"dda%d: supr_msg: got call from %d.%d.%d.%d\n",
ds->dda_if.if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno DDAELOG;
}
#endif DDADEBUG
hist_lcn_state(ds->dda_if.if_unit, dc->dc_state, LC_DATA_IDLE);
dc->dc_state = LC_DATA_IDLE; /* set state */
dc->dc_timer = tmo_data_idle; /* start timer */
dc->dc_pktsizein = 0;
dc->dc_pktsizeout = 0;
dc->dc_wsizein = 0;
dc->dc_wsizeout = 0;
send_supr(ds, ANSWER, (int) dc->dc_lcn * 2,
(int) p[2]); /* send answer */
if (LOG_CALLS) {
imp_addr.ip = dc->dc_inaddr;
DDALOG(LOG_ERR)
"dda%d: Accepting call from %d.%d.%d.%d (%s) on lcn %d\n",
ds->dda_if.if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno,
fmt_x25(&ddacb_calling_addr[1],
(int) ddacb_calling_addr[0]), dc->dc_lcn DDAELOG;
}
} else { /* if no free LCN's */
send_supr(ds, CLEARVC, p[2], 0); /* clear call */
if (LOG_CALLS) {
DDALOG(LOG_ERR) "dda%d: Rejecting call from %s on VC 0x%x\n",
ds->dda_if.if_unit,
fmt_x25(&ddacb_calling_addr[1], ddacb_calling_addr[0]),
p[1] DDAELOG;
}
}
break;
case CLEARLC: /* clear by LCN */
/*
* This could mean one of three things: If we have a call request
* outstanding, this message means the call has failed. If we have a
* clear request outstanding, this message completes the cleanup; the
* channel is now available for reuse. If we have a call active, this
* message means the other side is closing the circuit.
*/
lcn = p[1] / 2; /* get LCN */
dc = &(ds->dda_cb[lcn]);
if (dc->dc_state != LC_CLR_PENDING) { /* if no clear pending */
send_supr(ds, CLEARLC, p[1], 0); /* ack the clear */
}
if (dc->dc_state == LC_CALL_PENDING /* if call is cleared */
&& (LOG_CALLS || DMESGVAL(ds->dda_if.if_unit, 33) == 0)) {
imp_addr.ip = dc->dc_inaddr;
DDALOG(LOG_ERR)
"dda%d: Call to %d.%d.%d.%d on lcn %d failed (%x %x)\n",
ds->dda_if.if_unit, imp_addr.imp.s_net, imp_addr.imp.s_host,
imp_addr.imp.s_lh, imp_addr.imp.s_impno, dc->dc_lcn, p[2], p[4]
DDAELOG;
} else if (LOG_CALLS) {
if (dc->dc_state == LC_CLR_PENDING) { /* did we clear it? *//* y
* es, IP address is
* already gone. Say
* channel is free. */
DDALOG(LOG_ERR) "dda%d: Cleared lcn %d\n",
ds->dda_if.if_unit, dc->dc_lcn DDAELOG;
} else { /* cleared by net, print more info */
imp_addr.ip = dc->dc_inaddr;
DDALOG(LOG_ERR)
"dda%d: Cleared lcn %d to %d.%d.%d.%d (%x %x)\n",
ds->dda_if.if_unit, dc->dc_lcn, imp_addr.imp.s_net,
imp_addr.imp.s_host, imp_addr.imp.s_lh, imp_addr.imp.s_impno,
p[2], p[4] DDAELOG;
}
}
hist_lcn_state(ds->dda_if.if_unit, dc->dc_state, LC_IDLE);
/* LCNLINK delete */
dc->dc_state = LC_IDLE; /* set state */
dc->dc_timer = TMO_OFF; /* stop timer */
dc->dc_inaddr.s_addr = 0; /* forget address */
dc->dc_key.key_addr.s_addr = 0;
dc->dc_wsizein = dc->dc_wsizeout = 0;
dc->dc_pktsizein = dc->dc_pktsizeout = 0;
abort_io(ds->dda_if.if_unit, lcn);
if (LOG_CALLS) {
printf("dda%d: Cleared LCN %d cause code %x diag code %x\n",
ds->dda_if.if_unit, dc->dc_lcn, p[2], p[4]);
}
break;
case CLEARVC: /* clear by VCN */
send_supr(ds, CLEARVC, p[1], 0); /* send clear ack */
if (LOG_CALLS) {
DDALOG(LOG_ERR) "dda%d: Network cleared VC %x (%x %x)\n",
ds->dda_if.if_unit, p[1], p[2], p[4] DDAELOG;
}
#ifdef DDADEBUG
else if (DDADBCH(21, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: supr_msg: CLEARVC VCN=%x\n",
ds->dda_if.if_unit, p[1] DDAELOG;
}
#endif DDADEBUG
break;
case RESET: /* X25 reset */
lcn = p[1] / 2; /* get LCN */
dc = &(ds->dda_cb[lcn]);
send_supr(ds, RESET_ACK, p[1], 0); /* send reset ack */
abort_io(ds->dda_if.if_unit, lcn);
imp_addr.ip = dc->dc_inaddr;
DMESG(ds->dda_if.if_unit, 34,
(DDALOG(LOG_ERR)
"dda%d: X25 RESET (%x %x) on lcn %d: %d.%d.%d.%d\n",
ds->dda_if.if_unit, p[2], p[4], lcn, imp_addr.imp.s_net,
imp_addr.imp.s_host, imp_addr.imp.s_lh, imp_addr.imp.s_impno
DDAELOG));
break;
case INTERRUPT: /* X25 interrupt */
lcn = p[1] / 2; /* get LCN */
dc = &(ds->dda_cb[lcn]);
imp_addr.ip = dc->dc_inaddr;
DMESG(ds->dda_if.if_unit, 35,
(DDALOG(LOG_ERR)
"dda%d: X25 INTERRUPT (%x) on lcn %d: %d.%d.%d.%d\n",
ds->dda_if.if_unit, p[2], lcn, imp_addr.imp.s_net,
imp_addr.imp.s_host, imp_addr.imp.s_lh, imp_addr.imp.s_impno
DDAELOG));
break;
case STATRESP: /* Statistics Response from FEP */
/*
* Copy the whole message into a static buffer, dda_iobuf. The buffer
* is viewed as a (struct ddactl). Wake up the ioctl thread which
* will copy the message out for acpconfig.
*/
{
struct ddactl *da = (struct ddactl *) dda_iobuf;
bcopy(p, da->msg, max(4 + p[3], sizeof(da->msg)));
#ifdef MULTINET
StatQuery_Completed = 1;
#else
wakeup(dda_iobuf);
#endif
break;
}
default:
DMESG(ds->dda_if.if_unit, 36,
(DDALOG(LOG_ERR) "dda%d: supervisor error (%x %x %x %x)\n",
ds->dda_if.if_unit, p[0], p[1], p[2], p[3] DDAELOG));
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DECODE_ANSWER() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* This routine looks at the answer message from the FE */
/* and decodes it to find the negtiated packet and window sizes */
/* if they are present. */
/* */
/* Call: decode_answer(p, dc) */
/* Argument: p: pointer to mbuf data for ANSWER message */
/* dc: pointer to relavant lcn structure */
/* Returns: nothing */
/* Called by: supr_msg() */
/* Calls to: */
/* DDALOG() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
decode_answer(p, dc)
u_char *p;
struct dda_cb *dc;
{
register u_char *cp;
int i, faclen;
dc->dc_pktsizein = 0;
dc->dc_pktsizeout = 0;
dc->dc_wsizein = 0;
dc->dc_wsizeout = 0;
cp = p + 4; /* skip over code, lcn, vcn and count in
* answer message */
/* cp now points to length of called address */
cp += *cp + 1; /* skip over called address and length byte */
/* cp now points to length of calling address */
cp += *cp + 1; /* skip over calling address and length byte */
/* cp now points to length of protocol */
cp += *cp + 1; /* skip over protocol and protocol length
* byte */
/* cp now points to the facilities length */
faclen = *cp++;
/* cp now points to start of facilities */
for (i = 0; i < faclen;) {
switch (*cp & 0xc0) {
case 0x00: /* single octet parameter field */
i += 2;
cp += 2;
break;
case 0x40: /* double octet parameter field */
switch (*cp) {
case X25_FACIL_PKTSIZE: /* 0x42, packet size */
dc->dc_pktsizein = *(cp + 1);
dc->dc_pktsizeout = *(cp + 2);
break;
case X25_FACIL_WINSIZE: /* 0x43, window size */
dc->dc_wsizein = *(cp + 1);
dc->dc_wsizeout = *(cp + 2);
break;
}
i += 3;
cp += 3;
break;
case 0x80: /* triple octet parameter field */
i += 4;
cp += 4;
break;
case 0xc0: /* variable-length parameter field */
cp++;
i += 2 + *cp;
cp += 1 + *cp;
break;
/* Note: No other cases (i.e., default) possible */
}
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% DECODE_RING() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine parses and validates the incoming call message. */
/* */
/* Call: decode_ring(p) */
/* Argument: p: pointer to the message */
/* Returns: 1 for success, else 0 for failure */
/* Called by: supr_msg() */
/* Calls to: bcopy() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE boolean
decode_ring(p)
register u_char *p;
{
register int cnt;
#ifdef DDADEBUG
if (DDADBCH(22, 0)) { /* no easy access to unit, assume unit 0 */
DDALOG(LOG_DEBUG) "dda: decode_ring()\n" DDAELOG;
}
#endif DDADEBUG
p += 3; /* skip to cmnd ext length */
if (*p++ < 5) /* is count appropriate */
return (0); /* return false if not */
/* called address */
if ((cnt = *p + 1) > 16) /* is called addr len legal? */
return (0); /* return false if not */
bcopy(p, ddacb_called_addr, cnt); /* copy field */
p += cnt;
/* calling address */
if ((cnt = *p + 1) > 16) /* is calling addr len legal? */
return (0); /* return false if not */
bcopy(p, ddacb_calling_addr, cnt); /* copy field */
p += cnt;
/* protocol part of user data */
if ((cnt = *p + 1) > 5) /* is protocol len legal? */
return (0); /* return false if not */
bcopy(p, ddacb_protocol, cnt); /* copy field */
p += cnt;
/* facilities */
if ((cnt = *p + 1) > 64) /* is facilities len legal? */
return (0); /* return false if not */
bcopy(p, ddacb_facilities, cnt); /* copy field */
p += cnt;
/* ignore rest of user data for now */
#ifdef DDA_PAD_OR_RAW
if (ddacb_protocol[0] == 0)
return (0);
#else DDA_PAD_OR_RAW
if ((ddacb_protocol[0] == 0) || (ddacb_protocol[1] != X25_PROTO_IP))
return (0); /* bad if not IP */
#endif DDA_PAD_OR_RAW
#ifndef DDA_PAD_OR_RAW
return (1); /* looks ok */
#else
# ifdef DDA_RAWOPT
return (1); /* anything is ok if we're PI interface */
# else
if (ddacb_protocol[1] == X25_PROTO_IP || ddacb_protocol[1] == X25_PROTO_X29)
return (1); /* looks ok */
else
return (0); /* bad if not IP or X29 */
# endif
#endif DDA_PAD_OR_RAW
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% CLEAR_LCN() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine clears an X25 circuit and releases any buffers */
/* queued for transmission. */
/* */
/* Call: clear_lcn(ds, dc) */
/* Argument: ds: pointer to dev control block struct */
/* dc: pointer to the Logical Channel control */
/* block structure */
/* Returns: nothing */
/* Called by: ddatimer() */
/* Calls to: IF_DEQUEUE() */
/* m_freem() */
/* send_supr() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
clear_lcn(ds, dc)
struct dda_softc *ds;
struct dda_cb *dc;
{
register struct mbuf *m;
register int s;
#ifdef DDADEBUG
if (DDADBCH(23, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: clear_lcn(%d)\n", ds->dda_if.if_unit,
dc->dc_lcn DDAELOG;
}
#endif DDADEBUG
if (dc->dc_state == LC_CLR_PENDING) { /* Unfortunately, we can't
* display the destination's
* IP address, as we cleared
* it when we entered
* clear-pending state (to
* prevent new data from
* being queued to this
* channel). */
DMESG(ds->dda_if.if_unit, 37,
(DDALOG(LOG_ERR) "dda%d: Clear request lost -- lcn %d\n",
ds->dda_if.if_unit, dc->dc_lcn DDAELOG));
return;
}
hist_lcn_state(ds->dda_if.if_unit, dc->dc_state, LC_CLR_PENDING);
dc->dc_state = LC_CLR_PENDING; /* set state */
dc->dc_timer = TMO_CLR_PENDING; /* start clear timer */
dc->dc_inaddr.s_addr = 0; /* clear associated address */
dc->dc_key.key_addr.s_addr = 0;
dc->dc_wsizein = dc->dc_wsizeout = 0;
dc->dc_pktsizein = dc->dc_pktsizeout = 0;
/*
* Raise priority whenever dc_oq is touched.
*/
s = splimp();
while (dc->dc_oq.ifq_len) { /* drop any pending data */
IF_DEQUEUE(&dc->dc_oq, m);
m_freem(m);
}
splx(s);
send_supr(ds, CLEARLC, (int) dc->dc_lcn * 2, 0); /* send clear msg */
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% SEND_RESTART() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine marks all LCNs as being in a restarting state */
/* and sends a restart command to X25. */
/* */
/* Call: send_restart(ds) */
/* Argument: ds: pointer to dev control block struct */
/* Returns: nothing */
/* Called by: ddatimer() */
/* supr_msg() */
/* Calls to: IF_DEQUEUE() */
/* m_freem() */
/* send_supr() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
send_restart(ds)
struct dda_softc *ds;
{
register struct dda_cb *dc;
register int lcn;
register int maxlcn;
#ifdef DDADEBUG
if (DDADBCH(24, ds->dda_if.if_unit)) {
DDALOG(LOG_DEBUG) "dda%d: send_restart()\n", ds->dda_if.if_unit DDAELOG;
}
#endif DDADEBUG
dc = ds->dda_cb;
/* LCNLINK */
maxlcn = nddach[ds->dda_if.if_unit];
for (lcn = 0; lcn <= maxlcn; lcn++) { /* for all LCN's */
dc->dc_state = LC_RESTART; /* set state */
dc->dc_timer = TMO_RESTART; /* start restart timeout */
dc->dc_inaddr.s_addr = 0; /* forget address */
dc->dc_key.key_addr.s_addr = 0;
dc->dc_wsizein = dc->dc_wsizeout = 0;
dc->dc_pktsizein = dc->dc_pktsizeout = 0;
dc++;
}
hist_all_lcns(ds->dda_if.if_unit, LC_RESTART);
abort_io(ds->dda_if.if_unit, ALL_CHANS);
send_supr(ds, RESTART, 0, 0); /* send restart msg */
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% SEND_SUPR() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine is used to send short (4 bytes only) supervisor */
/* commands, except that longer ANSWER messages may be sent. */
/* */
/* Call: send_supr(ds, cmd, p1, p2) */
/* Argument: ds: pointer to dev control block struct */
/* cmd: type of command */
/* p1: 2nd byte of supervisor message */
/* p2: 3rd byte of supervisor message */
/* Returns: nothing */
/* Called by: supr_msg() */
/* clear_lcn() */
/* send_restart() */
/* Calls to: MGET() */
/* DDALOG() */
/* mtod() */
/* IF_ENQUEUE() */
/* dda_start() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
send_supr(ds, cmd, p1, p2)
struct dda_softc *ds;
int cmd, p1, p2;
{
struct mbuf *m;
register u_char *cp;
u_char *savcp, *fp, *svcp;
int i, faclen;
MGET(m, M_DONTWAIT, MT_DATA);
if (m == 0) {
DMESG(ds->dda_if.if_unit, 23,
(DDALOG(LOG_ERR) "dda%d: failed to get supr msg bfr!\n",
ds->dda_if.if_unit DDAELOG));
return;
}
cp = savcp = mtod(m, u_char *);
/* build supervisor message */
*cp++ = (u_char) cmd;
*cp++ = (u_char) p1;
*cp++ = (u_char) p2;
*cp++ = 0;
m->m_len = 4;
if (cmd == ANSWER) {
register struct dda_cb *dc;
/* for answer messages p1 is (lcn * 2) */
dc = &(ds->dda_cb[p1 / 2]);
*cp++ = 0; /* zero length called address */
*cp++ = 0; /* zero length calling address */
*cp++ = 0; /* zero length protocol */
/* check and copy facilities */
faclen = 0;
svcp = cp++;
for (i = 0, fp = &ddacb_facilities[1]; i < ddacb_facilities[0];) {
switch (*fp & 0xc0) {
case 0x00: /* single octet parameter field */
i += 2;
fp += 2;
break;
case 0x40: /* double octet parameter field */
/*
* Note that this code can in some cases attempt to negotiate
* the packet size or window away from the default, which
* appears to violate the X.25 spec. In fact, the FEP
* examines these values and bounds them between the
* requested value and the default value thus satisfying X.25
*/
switch (*fp) {
case X25_FACIL_PKTSIZE: /* 0x42, packet size */
*cp++ = X25_FACIL_PKTSIZE;
if (ds->dda_firmrev < 0x21) {
*cp++ = PKTSIZE_DEF; /* Set incoming and outgoing */
*cp++ = PKTSIZE_DEF; /* packet size to default */
dc->dc_pktsizein = dc->dc_pktsizeout = PKTSIZE_DEF;
} else {
*cp++ = *(fp + 1); /* Answer with requested */
*cp++ = *(fp + 2); /* facilities */
dc->dc_pktsizeout = *(fp + 1);
dc->dc_pktsizein = *(fp + 2);
}
faclen += 3;
break;
case X25_FACIL_WINSIZE: /* 0x43, window size */
*cp++ = X25_FACIL_WINSIZE;
if (ds->dda_firmrev < 0x21) {
*cp++ = WINSIZE_DEF; /* Set incoming and outgoing */
*cp++ = WINSIZE_DEF; /* window size to default */
dc->dc_wsizein = dc->dc_wsizeout = WINSIZE_DEF;
} else {
*cp++ = *(fp + 1); /* Answer with requested */
*cp++ = *(fp + 2); /* facilities */
dc->dc_wsizeout = *(fp + 1);
dc->dc_wsizein = *(fp + 2);
}
faclen += 3;
break;
}
i += 3;
fp += 3;
break;
case 0x80: /* triple octet parameter field */
i += 4;
fp += 4;
break;
case 0xc0: /* variable-length parameter field */
fp++;
i += 2 + *fp;
fp += 1 + *fp;
break;
/* Note: No other cases (i.e., default) possible */
}
}
if (faclen) { /* Found facilities to negotiate! */
*svcp = faclen; /* facility length <- faclen */
*cp++ = 0; /* user data length <- 0 */
*(savcp + 3) = cp - savcp - 4; /* set supv message length */
m->m_len = cp - savcp; /* set mbuf message length */
}
} /* (end of answer message case) */
# ifdef DDADEBUG
if (DDADBCH(25, ds->dda_if.if_unit)) {
prt_bytes(ds->dda_if.if_unit, "send_supr", savcp, m->m_len);
}
#endif DDADEBUG
start_supr(ds, m);
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% START_SUPR() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* Start i/o on the supervisor channel, checking for queue full. */
/* Added to revision 2.0 so that "queue full" checking would be */
/* applied uniformly to all supervisory channel output. */
/* */
/* Call: start_supr(ds, m) */
/* Argument: ds: softc structure for board */
/* m: mbuf holding message */
/* Returns: nothing */
/* Called by: send_supr(), send_config(), make_x25_call() */
/* Calls to: DDALOG(), dda_start(), IF_ENQUEUE() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
start_supr(ds, m)
struct dda_softc *ds;
struct mbuf *m;
{
register int s;
#ifdef DDADEBUG
if (DDADBCH(27, ds->dda_if.if_unit))
DDALOG(LOG_DEBUG) "dda%d: start_supr\n", ds->dda_if.if_unit DDAELOG;
#endif DDADEBUG
if (IF_QFULL(&(ds->dda_cb[0].dc_oq))) {
DMESG(ds->dda_if.if_unit, 27,
(DDALOG(LOG_ERR) "dda%d: supervisory channel overflow (maxlen=%d)\n",
ds->dda_if.if_unit, ds->dda_cb[0].dc_oq.ifq_maxlen DDAELOG));
ds->dda_cb[0].dc_oq.ifq_maxlen += ds->dda_cb[0].dc_oq.ifq_maxlen;
}
/*
* Raise priority whenever you touch dc_oq.
* We do not want to be interrupted in the middle of adding
* an mbuf to the output queue because the interrupt may indicate
* a condition that will cause the mbuf to be freed.
* (The mbufs are freed on receipt of a line status msg, restart,
* clear, or reset.)
*/
s = splimp();
#ifdef DDA_PAD_OR_RAW
m->m_dat[MLEN - 1] = 0;
#endif
IF_ENQUEUE(&(ds->dda_cb[0].dc_oq), m);
splx(s);
dda_start(ds, &(ds->dda_cb[0]));
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% ABORT_IO() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* Abort outstanding I/O upon receipt of a line status message, */
/* restart, clear, or reset. */
/* The contents of the output queue (dc_oq) is cleared for each */
/* lcn; all I/O queued on either the read or write queue */
/* (dc_rchan and dc_wchan) is marked invalid; all I/O queued on */
/* the sioq is marked invalid; */
/* */
/* Call: abort_io() */
/* Argument: none */
/* Returns: nothing */
/* Called by: */
/* Calls to: IF_DEQUEUE() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
abort_io(unit, lcn)
int unit, lcn;
{
register struct dda_cb *dc;
register struct dda_softc *ds = &dda_softc[unit];
register struct hdx_chan *hc;
register struct mbuf *m;
register int lchan;
register int s;
register struct hdx_chan *ptr;
int start, end;
/* set up range of lcns affected */
if (lcn == ALL_CHANS) {
start = 1;
end = nddach[unit];
} else
start = end = lcn;
#ifdef DDADEBUG
if (DDADBCH(28, unit))
DDALOG(LOG_DEBUG) "dda%d: abort_io on lcn's %d - %d\n",
unit, start, end DDAELOG;
#endif DDADEBUG
s = splimp();
/*
* Invalidate writes on the sioq for specified channel(s)
*/
if (ptr = ds->dda_sioq.sq_head)
for (; ptr; ptr = ptr->hc_next) /* scan sioq */
if ((ptr->hc_chan & 0x01) &&
((lcn == ALL_CHANS) || (lcn == ptr->hc_chan >> 1))
&& (ptr->hc_chan != 1)) {
#ifdef DDADEBUG
if (DDADBCH(28, unit))
DDALOG(LOG_DEBUG)
"dda%d: abort_io--invalidating sioq lcn %d\n",
unit, ptr->hc_chan >> 1 DDAELOG;
#endif DDADEBUG
ptr->hc_inv |= INVALID_MBUF;
}
/*
* For each selected lcn, clear the output queue and
* add an hdx struct to the sioq that will generate an
* abort.
*/
for (lchan = start; lchan <= end; lchan++) { /* for selected LCNs */
dc = &dda_softc[unit].dda_cb[lchan];
hc = &dc->dc_wchan;
while (dc->dc_oq.ifq_len) {
IF_DEQUEUE(&dc->dc_oq, m);
m_freem(m);
}
if (hc->hc_mbuf && !(hc->hc_inv & INVALID_MBUF)) {
if (dc->dc_flags & DC_OBUSY) { /* output pending */
#ifdef DDADEBUG
if (DDADBCH(28, unit))
DDALOG(LOG_DEBUG)
"dda%d: abort_io--queueing abort: lcn %d\n",
unit, lchan DDAELOG;
#endif DDADEBUG
hc->hc_inv |= INVALID_MBUF;
hc->hc_func = DDAABT;
/*
* Add to the sioq
*/
dda_wrq(ds, hc, DDAABT);
}
}
}
splx(s);
}
#ifdef DDADEBUG
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% PRT_BYTES() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine is used to print a label, followed by the contents of */
/* a buffer in hex, 16 bytes per line. Each line is preceded by */
/* the device name and unit number. */
/* */
/* Call: prt_bytes(unit, label, bp, cnt) */
/* Argument: unit: dda unit number to be displayed */
/* label: pointer to string to be displayed */
/* bp: pointer to the buffer to be dumped */
/* cnt: number of bytes in buffer */
/* Returns: nothing */
/* Called by: dda_data() */
/* dda_supr() */
/* supr_msg() */
/* Calls to: DDALOG() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
prt_bytes(unit, label, bp, cnt)
int unit;
char *label;
u_char *bp;
int cnt;
{
char hexbuf[50]; /* (worst case: 3 * 16 + 1 = 49 bytes) */
char *p;
int i;
static char hex[] = "0123456789abcdef";
DDALOG(LOG_DEBUG) "dda%d: %s\n", unit, label DDAELOG;
while (cnt > 0) {
i = (cnt > 16) ? 16 : cnt;
cnt -= i;
p = hexbuf;
while (--i >= 0) {
*p++ = ' ';
*p++ = hex[*bp >> 4];
*p++ = hex[*bp++ & 0x0f];
}
*p++ = '\0';
DDALOG(LOG_DEBUG) "dda%d: %s\n", unit, hexbuf DDAELOG;
}
}
#endif
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% FMT_X25() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine is used to format an X.25 address for inclusion in */
/* an error message. The previous return value is invalidated each */
/* time the function is called, as it is stored in a static buffer */
/* Note: The X.25 address is apparently sometimes stored in */
/* BCD, and other times (PDN mode) in ASCII. So we mask */
/* off the high order bits to make ourselves immune. */
/* Call: fmt_x25(bp, cnt) */
/* Argument: bp: pointer to the string */
/* cnt: number of bytes (usually from address[0]) */
/* Returns: pointer to an internal buffer containing the string; */
/* string is 1 to 15 digits, null-terminated. */
/* Called by: make_x25_call() */
/* supr_msg() */
/* convert_x25_addr() */
/* Calls to: none */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE char *
fmt_x25(bp, cnt)
register u_char *bp;
register int cnt;
{
char *p;
static char x25buf[20]; /* worst case is 15 digits plus trailing null */
/* (Don't put this on the stack!) */
p = x25buf;
if (cnt >= sizeof(x25buf))
cnt = sizeof(x25buf) - 1; /* (oops!) */
while (cnt--)
*p++ = (*bp++ & 0x0f) + '0';
*p++ = '\0';
return (x25buf);
}
#ifdef DDA_HISTOGRAM
/*----------------------- HISTOGRAM SUPPORT ---------------------------------*/
/* the histogram array */
struct timeval histogram[NDDA][HISTSIZE];
/* these two structures save the time of the last change in the state of the
* lcn table or the board status.
*/
struct timeval last_lcn_time[NDDA] = {0L, 0L};
struct timeval last_brd_time[NDDA] = {0L, 0L};
/* h_lcn_level: the current number of active lcns */
int h_lcn_level[NDDA] = {0};
/*#define DDA_HIST_DEBUG 1 /* set this to debug history features */
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% HIST_INIT() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine initializes the histogram facility when coming up or */
/* after a reset. */
/* Call: hist_init(unit,reset) */
/* Argument: unit - board number to initialize. */
/* reset - set to 1 to force an init. */
/* Returns: nothing. */
/* Called by: ddaioctl() */
/* Calls to: microtime() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
hist_init(unit, reset)
int unit;
int reset;
{
int s;
register int i;
struct dda_cb *dc;
if (last_lcn_time[unit].tv_sec != 0L && !reset)
return; /* histogram for this unit already enabled */
bzero(histogram[unit], sizeof(struct timeval) * HISTSIZE);
h_lcn_level[unit] = 0;
dc = dda_softc[unit].dda_cb;
s = splimp();
for (i = 0; i < NDDACH + 1; i++) {
if (dc++->dc_state == LC_DATA_IDLE)
h_lcn_level[unit]++;
}
splx(s);
microtime(&histogram[unit][H_START]);
#ifdef DDA_HIST_DEBUG
DDALOG(LOG_DEBUG) "hist_init: starting at level %d\n",
h_lcn_level[unit] DDAELOG;
#endif
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% HIST_LCN_STATE() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine changes the histogram depending on how the state of */
/* a channel has changed. */
/* Call: hist_lcn_state(unit, old_state, new_state) */
/* Argument: old_state: the old state of the lcn. */
/* new_state: the state the lcn is changing to. */
/* unit: unit this applies to */
/* Returns: nothing. */
/* Called by: */
/* Calls to: timevalsub(), timevaladd(), microtime() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
hist_lcn_state(unit, old_state, new_state)
int unit;
u_char old_state;
u_char new_state;
{
struct timeval tv, tmpv;
/*
* this structure for determining state transitions is much more general
* than is necessary right now. However it allows easy changes to the
* state transition table for the histogram so I will leave it in until
* it settles down
*/
switch (old_state) {
case LC_DATA_IDLE:
switch (new_state) {
case LC_DATA_IDLE:
break;
default: /* all other states */
microtime(&tv);
tmpv = tv;
timevalsub(&tv, &last_lcn_time[unit]);
#ifdef DDA_HIST_DEBUG
DDALOG(LOG_DEBUG) "hist_lcn_state: adding %ld.%ld to level %d--\n",
tv.tv_sec, tv.tv_usec, h_lcn_level[unit] DDAELOG;
#endif
timevaladd(&histogram[unit][h_lcn_level[unit]], &tv);
last_lcn_time[unit] = tmpv;
if (--h_lcn_level[unit] < 0) /* safety net for driver
* errors */
h_lcn_level[unit] = 0;
break;
}
break;
default:
switch (new_state) {
case LC_DATA_IDLE:
microtime(&tv);
tmpv = tv;
timevalsub(&tv, &last_lcn_time[unit]);
#ifdef DDA_HIST_DEBUG
DDALOG(LOG_DEBUG) "hist_lcn_state: adding %ld.%ld to level %d++\n",
tv.tv_sec, tv.tv_usec, h_lcn_level[unit] DDAELOG;
#endif
timevaladd(&histogram[unit][h_lcn_level[unit]], &tv);
last_lcn_time[unit] = tmpv;
if (++h_lcn_level[unit] > NDDACH) /* safety net for driver
* errors */
h_lcn_level[unit] = NDDACH;
break;
default: /* all other states */
break;
}
break;
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% HIST_ALL_LCNS() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine changes the histogram when the state of all the lcns */
/* are changed as a group. */
/* Call: hist_lcn_state(unit, state) */
/* Argument: state: state that all lcn are going to. Currently not*/
/* used. */
/* unit: unit this applies to */
/* Returns: nothing. */
/* Called by: */
/* Calls to: timevalsub(), timevaladd(), microtime() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
hist_all_lcns(unit, state)
int unit, state;
{
struct timeval tmpv, tv;
#ifdef lint
state = state;
#endif
if (last_brd_time[unit].tv_sec == 0L
|| last_lcn_time[unit].tv_sec == 0L)
return; /* see if we have initialized yet */
microtime(&tv);
tmpv = tv;
timevalsub(&tv, &last_lcn_time[unit]);
#ifdef DDA_HIST_DEBUG
DDALOG(LOG_DEBUG) "hist_all_lcns: adding %ld.%ld to level %d\n",
tv.tv_sec, tv.tv_usec, h_lcn_level[unit] DDAELOG;
#endif
timevaladd(&histogram[unit][h_lcn_level[unit]], &tv);
last_lcn_time[unit] = tmpv;
h_lcn_level[unit] = 0;
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% HIST_LINK_STATE() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine changes the histogram depending on how the state of */
/* the link has changed. */
/* Call: hist_link_state(old_state, new_state) */
/* Argument: old_state: the old state of the link. */
/* new_state: the state the link is changing to. */
/* unit: unit this applies to */
/* Returns: nothing. */
/* Called by: */
/* Calls to: timevalsub(), timevaladd(), microtime() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
hist_link_state(unit, old_state, new_state)
int unit;
u_char old_state;
u_char new_state;
{
struct timeval tv, tmpv;
/*
* this structure for determining state transitions is much more general
* than is necessary right now. However it allows easy changes to the
* state transition table for the histogram so I will leave it in until
* it settles down
*/
switch (old_state) {
case S_LINK_UP:
switch (new_state) {
case S_LINK_UP:
break;
default: /* all other states */
#ifdef DDA_HIST_DEBUG
DDALOG(LOG_DEBUG) "hist_link_state: link down\n" DDAELOG;
#endif
microtime(&tv);
tmpv = tv;
timevalsub(&tv, &last_lcn_time[unit]);
timevaladd(&histogram[unit][h_lcn_level[unit]], &tv);
tv = tmpv;
timevalsub(&tv, &last_brd_time[unit]);
timevaladd(&histogram[unit][H_LINK_UP], &tv);
last_brd_time[unit].tv_sec = 0L;
break;
}
break;
default: /* all other states */
switch (new_state) {
case S_LINK_UP:
#ifdef DDA_HIST_DEBUG
DDALOG(LOG_DEBUG) "hist_link_state: link up\n" DDAELOG;
#endif
microtime(&last_brd_time[unit]);
/*
* reset last_lcn_time so 0 entry will not accumulate the time
* that we were down
*/
last_lcn_time[unit] = last_brd_time[unit];
break;
default:
break;
}
break;
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% HIST_READ() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine prepares the histogram table for reading by making */
/* all entries current. */
/* Call: hist_read(unit) */
/* Argument: unit : board to use. */
/* Returns: nothing */
/* Called by: ddaioctl() */
/* Calls to: timevalsub(), timevaladd(), microtime() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE void
hist_read(unit)
int unit;
{
struct timeval tmpv, tv;
microtime(&tv);
tmpv = tv;
histogram[unit][H_END] = tmpv;
histogram[unit][H_TMO].tv_sec = tmo_data_idle * DDA_TIMEOUT;
histogram[unit][H_TMO].tv_usec = 0L;
if (last_brd_time[unit].tv_sec) {
timevalsub(&tv, &last_lcn_time[unit]);
#ifdef DDA_HIST_DEBUG
DDALOG(LOG_DEBUG) "hist_read: adding %ld.%ld to level %d\n",
tv.tv_sec, tv.tv_usec, h_lcn_level[unit] DDAELOG;
#endif
timevaladd(&histogram[unit][h_lcn_level[unit]], &tv);
last_lcn_time[unit] = tmpv;
tv = tmpv;
timevalsub(&tv, &last_brd_time[unit]);
timevaladd(&histogram[unit][H_LINK_UP], &tv);
last_brd_time[unit] = tmpv;
}
}
/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%% HIST_COPYOUT() %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/* */
/* Purpose: */
/* */
/* This routine prepares the histogram table for reading by making */
/* all entries current. */
/* Call: hist_copyout(unit, to) */
/* Argument: unit : board to use. */
/* to : address in user space to copy to. */
/* Returns: return value from copyout */
/* Called by: ddaioctl() */
/* Calls to: copyout() */
/* */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
PRIVATE int
hist_copyout(unit, to)
int unit;
caddr_t to;
{
return ((copyout(histogram[unit], to, sizeof(struct timeval) * HISTSIZE)));
}
#endif DDA_HISTOGRAM
#ifdef DDA_PAD_OR_RAW
#if ACC_BSD > 42
# include "uba.h"
# include "bk.h"
# include "conf.h"
# include "proc.h"
# include "tty.h"
# include "map.h"
# include "vm.h"
# include "bkmac.h"
# include "clist.h"
# include "file.h"
# include "uio.h"
#endif
#if ACC_BSD == 42 || ACC_ULTRIX > 00
# include "bk.h"
# include "../h/conf.h"
# include "../h/proc.h"
# include "../h/tty.h"
# include "../h/map.h"
# include "../h/vm.h"
# if ACC_ULTRIX > 12
# include "uba.h"
# endif
# include "../h/bk.h"
# ifdef SIMULATION
# include "Clist.h"
# else
# include "../h/clist.h"
# endif
# include "../h/file.h"
# include "../h/uio.h"
#endif
PRIVATE int
dda_decode_type(ds, p)
struct dda_softc *ds;
u_char *p;
{
register u_char *cp;
int i, usrlen;
#ifdef DDADEBUG
if (DDADBCH(20, ds->dda_if.if_unit)) {
printf(" dda_decode_type(): p[0]= %x ", *p);
}
#endif DDADEBUG
switch (p[0]) {
case LINE_STATUS: /* link status msg */
case RESTART: /* restart received */
case RSTRT_ACK: /* restart ack */
case STATRESP: /* Statistics Response from FEP */
case CLEARVC: /* clear by VCN */
return (0);
case RESET: /* X25 reset */
return (1);
case ANSWER:
case CLEARLC:
case INTERRUPT:
case INTR_ACK:
i = p[1] / 2; /* get lcn */
if (ds->dda_cb[i].dc_flags & (DC_X29 | DC_X29W))
return (1);
else if (ds->dda_cb[i].dc_flags & (DC_RAW))
return (2);
else
return (0);
}
if (p[0] != RING) { /* let standard dda handle it */
return (0);
}
cp = p + 4; /* skip over code, lcn, vcn and count in
* (ring?) answer message */
/* cp now points to length of called address */
cp += *cp + 1; /* skip over called address and length byte */
/* cp now points to length of calling address */
cp += *cp + 1; /* skip over calling address and length byte */
/* cp now points to length of protocol */
if (*cp == 0)
return (0);
usrlen = *cp++;
if (usrlen) {
#ifdef DDA_RAWOPT
if (pi_circuit_to_handle_protocol(*cp))
return (2);
#endif
#ifdef DDADEBUG
if (DDADBCH(20, ds->dda_if.if_unit)) {
printf(" dda_decode_type(): return value = %x ", *cp);
}
#endif DDADEBUG
switch (*cp) {
case X25_PROTO_IP:
return (0);
case X25_PROTO_X29:
return (1);
default:
return (2);
}
} else
return (0);
}
#endif DDA_PAD_OR_RAW
#ifdef SIMULATION
# ifdef DDA_PADOPT
# include "if_x29.c"
# endif
# ifdef DDA_RAWOPT
# include "if_pi.c"
# endif
#else
# ifdef DDA_PADOPT
# if ACC_VMS > 00
# include "../vaxif/if_vmsx29.c"
# else
# include "../vaxif/if_x29.c"
# endif
# endif
# ifdef DDA_RAWOPT
# include "../vaxif/if_pi.c"
# endif
#endif
#ifdef DDA_MSGQ
u_char ddamsgq[MSGQSIZE];
PRIVATE u_char *mqptr = 0;
#define MSGQEND (ddamsgq+MSGQSIZE)
dda_mqstr(s)
char *s;
{
if (mqptr == 0)
mqptr = ddamsgq;
while (*s) {
*mqptr++ = *s++;
if (mqptr >= MSGQEND)
mqptr = ddamsgq;
}
*mqptr = '\0';
}
dda_mqnum(num, type)
int num, type;
{
if (mqptr == 0)
mqptr = ddamsgq;
if ((mqptr + sizeof(int) + 2) >= MSGQEND)
mqptr = ddamsgq;
*mqptr++ = type;
*((int *) mqptr) = num;
mqptr += sizeof(int);
*mqptr = '\0';
}
#endif DDA_MSGQ
/* link in support for steve's test-jig */
#ifdef SIMULATION
#include "if_dda_sim.c"
#endif
/*
Revision History:
18-Dec-87: V3.0 - Brad Engstrom
Added the -t flag to acpconfig and the 't' case in ddaioctl to allow
setting of the idle circuit timeout.
The constant TMO_DATA_IDLE was changed to a variable called
tmo_data_idle.
11-Mar-88: V3.0 - Brad Engstrom
Modified the history routine to return the current value of the
timeout. Also fixed bug so that level 0 records amount of time 0
circuits were in use only when link is up.
11-Mar-88: V3.0 - Brad Engstrom
Changed handling of supervisor channel overflows to double the max q
length each time it overflows. This Will prevent a flood of console
messages while still notifying the user that there has been an
overflow.
21-Mar-88: V3.0 - Brad Engstrom
Fixed bug in writing the facilities field for packet and window size
negotiation. This was in the routine make X.25 call. Previously
constants were used to index into the facilities buffer now offsets
from the current facilities length are used.
12-Apr-88: V3.0 - Brad Engstrom
Added ability to handle class b and class c addressing. The changes
affect locate_x25_lcn, convert_x25_addr, and convert_ip_addr. The
modifications came from fixes sent to Wollongong by Lars Poulson.
12-Apr-88: V3.0 - Brad Engstrom
Made modifications so the driver will work under Ultrix or BSD. In
cases where there are differences between 4.3 and 4.2 bsd (shown by
#ifdef BSD4_3) Ultrix 1.2 is exactly like a 4.2 system. Ultrix 2.0 is
like 4.3 in most cases. New macros were added to distinquish between
systems. These are BSD4_2 and BSD43_OR_ULTRIX20.
13-Apr-88: V3.0 - Brad Engstrom
ddareset() was called from ddaintb without arguments. This could
cause ddareset to return without doing anything. Proper arguments were
inserted. In ddaioctl the priority level s may be used without being
set. This was fixed.
18-Apr-88: V3.0 - Brad Engstrom
Added the use of a key field in the dda_cb structure. Previously the
dc_inaddr field was used both for printing the ip address (-l command)
and for searching for circuits that were open to a destination. Using
this for a cicuit matching address means that the network and local
host fields needed to be masked off, thus making this field less
usefull for printing. Now two fields are used dc_inaddr is used for
printing. dc_key is used for circuit matching. In PDN mode the
full ip address is used as the key. In DDN mode just the imp number
and host(port) number are used.
18-Apr-88: V3.0 - Brad Engstrom
Made histogram facilities a compile time option. The histogram is
enabled if DDA_HISTOGRAM is defined. The facilities are always
disabled when using 4.2 or ULTRIX 1.2 as the kernel does not have the
proper support routines available.
22-Apr-88: V3.0 - Brad Engstrom
Added new option to -v command to set the dda_db_unit variable.
22-Apr-88: V3.0 - Brad Engstrom
Added the DMESG macro and the msgbits array to allow selective
disabling of driver error messages. To enable or disable an error
message the -c command of acpconfig is used. The msgbits array holds
info about whether each message is enabled or disabled. Setting a bit
to 1 disables a message. Clearing a bit to 0 enables a message.
All messages start as enabled.
22-Apr-88: V3.0 - Brad Engstrom
Added check for DDAMAINT_BRD in probe routine. If DDAMAINT_BRD is
defined then assume we are using a maintenence board so don't try to
find the firmware id because it won't be there. Fake info that was
supposed to be contained in the firmware id.
25-Apr-88: V3.0 - Brad Engstrom
Added check in locate_x25_lcn to see if state of lc is LC_CALL_PENDING
or LC_DATA_IDLE in the loop that looks for an already open lc. This
will prevent an address of 0.0.0.0 from matching a circuit that is not
in use. If the address is invalid then the imp will kick it out.
26-Apr-88: V3.0 - Brad Engstrom
Changed the -n command case so that a command of the form "-n 0" will
return the number of channels currently available. This will be used
by the -l command and possible by the -h command to determine the
number of available circuits.
10-May-88: V3.0 - Brad Engstrom
Made all occurences of the length of and X.25 address refer to the
constants MAXADDRLEN and MINADDRLEN defined in if_ddavar.h. These
constants include the 1 byte for encoding the length.
02-Jun-88: V3.0 - Brad Engstrom
Change the check for the firmware revision level to 2.2 for the -e
command. This command will crash [56]250s that don't have at least
v2.2 firmware.
12-Jul-88: V3.0 - Brad Engstrom
Deleted case for class_b_c addressing.
20-Jul-88: V3.0 - Brad Engstrom
Fixed bug in parsing facilities that would cause the kernel to hang.
The bug was not incrmenting pointers when an urecognized 2 octet
facility was seen. Fixes were applied to send_supr() and
decode_answer()
30-Aug-88: V4.0 - Brad Engstrom
Modified driver to support X.29 and a programmers interface. Includes
files if_x29.c, if_pi.c, and if_pivar.h
30-Aug-88: V4.0 - Brad Engstrom
Added support for debug logging under the control of the DDA_MSGQ
define. Information is extracted using the new -p command of
acpconfig.
30-Aug-88: V4.0 - Brad Engstrom
Modified start_chan to check the ready bit before touching the
comregs. Also modified dda_rrq and dda_wrq to raise ipl before
touching the sioq. These changes fixed a bug where the FE was losing
I/O requests.
20-Oct-88: V4.0 - Steve Johnson
Added SIMULATION #ifdef for simulation support
08-Jan-89: V4.1 - Steve Johnson
MERGE 4.0 and 3.1
10-Oct-88: V3.1 - Charles Carvalho
Replace prt_x25 with fmt_x25, which returns a pointer to a formatted
message instead of printing its data; this allows error messages to be
output with a single call to DDALOG (or syslog). Move prt_addr
inline, for same reason. Add IP address to some error messages;
trim excess text from some error messages. Allocate channels
for incoming calls from lowest channel up; we do linear searches of
the lcn table, so it's to our advantage to use the lowest numbers for
all active circuits. (The lcn is not related to the virtual circuit
number, so there is no need to allocate incoming channels from the
top down.) Modify prt_bytes to take unit number and descriptive
string to be printed along with the buffer and byte count; it now
formats up to 16 bytes at a time and prints a full line with each call
to DDALOG rather than calling DDALOG for each byte.
17-Oct-88: V3.1 - Charles Carvalho
Add definitions for DDALOG and DDAELOG, which translate into a call to
DDALOG() or log().
26-Oct-88: V3.1 - Charles Carvalho
Change index for 'v' ioctl to preserve compatibility with previous
versions. Restrict maximum window size to 127, not 128.
7-Nov-88: V3.2 - Charles Carvalho
Fix check for no free circuits when processing RING
17-Feb-89: V4.3.0 - Paul Traina
Added TGV changes for Multinet.
8-Mar-89: V4.3.1 - Steve Johnson
Installed 'Q' ioctl to support obtaining an internal trace log used
for debugging only -- not documented for general user. acpconfig
dda0 -q 2 dumps 256 bytes from the dda_debug_silo[] array
13-Mar-89: V4.3.2 - Paul Traina
Updated Multinet support.
17-Apr-89: V4.3.3 - Steve Johnson
Split bus and simulation related code out to included files for first
shot at 7000 and tahoe design. Don't reset timeout counter in
dda_data() unless link really is in idle state.
28-Apr-89: V4.3.4 - Paul Traina
Modified changes of 17-Apr-89, added minimal tahoe support until
driver modified to use 4.3uba transfers.
Fixed timeout fix of 17-Apr-89 to do what was intended.
Fixed code dealing with maintenance board, reformatted with indent
to repair readablility.
09-May-89: V4.3.5 - Paul Traina
Minimal tahoe support completed, based on BSD4_3TAHOE define which
must be uncommented manually. Finalizing for ECO.
24-May-89: V4.3.6 - Paul Traina
Ultrix 3.0 support added. Revised 4.3 tahoe support for automatic
invocation.
*** NOTE: one of the three OS defines (ACC_BSD, ACC_ULTRIX, ACC_VMS)
in if_dda.c must be set to a non-zero value for the driver to
compile.
Attempting multiple-os support based upon weird variables from include
files is not acceptable with the latest proliferation of OS versions.
20-Jun-89: V4.3.7 - Paul Traina
Removed crufty old debug stuff and integrated it with the log-message
code. Now X29 and PI modules can be debuged properly (no #if 0's!).
22-Jun-89: - Paul Traina
Diddled ring-decode logic to check for proper ring packet decoding
before attempting to find a free lcn. This will make it easier to deal
with the race condition with find_free_lcn().
Modified ACC os specific equates to be set as options in the config
file. This way, most users won't ever edit if_dda.c.
18-Jul-89: - Paul Traina
Driver will no longer return errors if duplicate address-translation
entries are made. Errors will only happen if a redefiniton is
attempted.
Moved dc_key.ttyline out of union, creating dc_line.
26-Jul-89: - Paul Traina f/Brad Engstrom
Added support for called user-data field (two new params to
make_x25_call) to support extended pad mode in the X.29 module.
01-Aug-89: - Paul Traina
Made ddamsgs uninitialized -- it gets inited in ddaattach now.
03-Aug-89: - Paul Traina
Changed hist_copyout definition to PRIVATE.
15-Aug-89: - Paul Traina
Made dda_softc and dda_iobuf non-private.
18-Aug-89: - Paul Traina
Somehow, ddareset was removed from the 'z' ioctl.
28-Aug-89: - Paul Traina
Changed make_x25_call so that it checks length of data to be stuffed
into the mbuf before actually copying data in. Removed udlen and
ud parameters to the routine, as the public areas will be plugged
with data before being called. (May need to splimp()).
22-Sep-89: - Paul Traina
The order of the 'v' ioctl parameters was screwed up. This caused
window and packet size setting to fail.
23-Oct-89: - Paul Traina
Added further support for Steve's yetchy simulation. Updated main
module to work with BI version of dda board.
29-Oct-89: - Paul Traina
Acpconfig inconsistancy (again): removed the 'p', and 'Q' ioctls.
Since all of these are queries, I placed them under the 'q' ioctl
with a new switch. Some day we should just scrap the whole mess
and design a proper ioctl interface.
11-Nov-89: - Paul Traina
Moved rrq/wrq routines into bus modules because we can do several
queue reads and writes when working with the BI.
*/
#endif NDDA > 0