ldlconfig.c

7号信令功能代码,为开源代码

/*****************************************************************************

 @(#) ldlconfig.c,v LiS-2_16_18-8(1.1.1.1.8.1) 2004/01/12 23:33:15

 -----------------------------------------------------------------------------

 Copyright (c) 2003-2004  OpenSS7 Corporation <http://www.openss7.com>

 All Rights Reserved.

 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
 Foundation; either version 2 of the License, or (at your option) any later
 version.

 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 details.

 You should have received a copy of the GNU General Public License along with
 this program; if not, write to the Free Software Foundation, Inc., 675 Mass
 Ave, Cambridge, MA 02139, USA.

 -----------------------------------------------------------------------------

 U.S. GOVERNMENT RESTRICTED RIGHTS.  If you are licensing this Software on
 behalf of the U.S. Government ("Government"), the following provisions apply
 to you.  If the Software is supplied by the Department of Defense ("DoD"), it
 is classified as "Commercial Computer Software" under paragraph 252.227-7014
 of the DoD Supplement to the Federal Acquisition Regulations ("DFARS") (or any
 successor regulations) and the Government is acquiring only the license rights
 granted herein (the license rights customarily provided to non-Government
 users).  If the Software is supplied to any unit or agency of the Government
 other than DoD, it is classified as "Restricted Computer Software" and the
 Government's rights in the Software are defined in paragraph 52.227-19 of the
 Federal Acquisition Regulations ("FAR") (or any success regulations) or, in
 the cases of NASA, in paragraph 18.52.227-86 of the NASA Supplement to the FAR
 (or any successor regulations).

 -----------------------------------------------------------------------------

 Commercial licensing and support of this software is available from OpenSS7
 Corporation at a fee.  See http://www.openss7.com/

 -----------------------------------------------------------------------------

 Last Modified 2004/01/12 23:33:15 by brian

 -----------------------------------------------------------------------------
 ldlconfig.c,v
 Revision 1.1.1.1.8.1  2004/01/12 23:33:15  brian
 - Updated LiS-2.16.18 gcom release to autoconf.

 Revision 1.1.1.1.4.2  2003/12/15 23:35:06  brian
 - Tried to reduce number of patch lines.

 Revision 1.1.1.1.4.1  2003/12/10 11:09:29  brian
 Start of autoconf changes.

 *****************************************************************************/

#ident "@(#) ldlconfig.c,v LiS-2_16_18-8(1.1.1.1.8.1) 2004/01/12 23:33:15"

static char const ident[] =
    "ldlconfig.c,v LiS-2_16_18-8(1.1.1.1.8.1) 2004/01/12 23:33:15";

/*
 *  ldlconfig: A configuration helper for ldl clients
 *
 *  Copyright (C) 1998 Ole Husgaard ([e-mail])
 *  Copyright (C) 1999 David Grothe ([e-mail])
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#ident "@(#) LiS ldlconfig.c 1.4 12/11/00"

#include <stdio.h>
#include <fcntl.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

#ifdef _GNU_SOURCE
#include <getopt.h>
#endif				/* _GNU_SOURCE */

#include <sys/ioctl.h>
#include <sys/dlpi.h>
#include <sys/stropts.h>
#include <sys/ldl.h>

int             output = 1;

#define MAX_DL_ADDR_LEN 128
#define MAX_DL_SAP_LEN 64

typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;

unsigned char   my_addr[MAX_DL_ADDR_LEN];
unsigned char   my_brd_addr[MAX_DL_ADDR_LEN];
unsigned char   my_dlsap[MAX_DL_ADDR_LEN + MAX_DL_SAP_LEN];
unsigned char   my_sap[MAX_DL_SAP_LEN];

int             addr_len;	/* Data Link address length */
int             sap_len;	/* Data Link SAP length */
int             sap_first;	/* Flag: SAP first in DLSAP */
int             hw_type;	/* ARP hardware type */

int             filed = -1;
char           *if_name = "eth0";
unsigned long   bind_sap = 0xAA;
int             bind_specified;
unsigned long   flag_opts[32];
int             nxt_flag_opt;
unsigned long   promisc_opts[32];
int             nxt_promisc_opt;
unsigned long   framing = 0;
int             print_info = 0;

char           *hex(unsigned char c)
{
    static char     s[3];
    static char     h[16] = "0123456789abcdef";

    s[0] = h[c >> 4];
    s[1] = h[c & 15];
    s[2] = '\0';

    return s;
}

void dumpbuf(struct strbuf buf)
{
    int             i,
                    j;
    int             lines = (buf.len == 0) ? 0 : ((buf.len - 1) >> 4) + 1;
    char            s1[128],
                    s2[128];

    printf("  Len = %d  MaxLen = %d\n", buf.len, buf.maxlen);
    for (i = 0; i < lines; ++i)
    {
	strcpy(s1, "  ");
	strcpy(s2, "  ");
	for (j = 0; j < 16; ++j)
	{
	    if (16 * i + j < buf.len)
	    {
		unsigned char   c = buf.buf[16 * i + j];

		strcat(s1, hex(c));
		strcat(s1, " ");
		if (isprint(c))
		{
		    char            s3[2];

		    s3[0] = c;
		    s3[1] = '\0';
		    strcat(s2, s3);
		}
		else
		    strcat(s2, ".");

	    }
	    else
	    {
		strcat(s1, "   ");
		strcat(s2, " ");
	    }
	    if (j == 7)
	    {
		strcat(s1, " ");
		strcat(s2, " ");
	    }
	}
	printf("  %s  %s\n", s1, s2);
    }
}

void dumphex(unsigned char *data, int len)
{
    while (len--)
    {
	printf("%s%s", hex(*data), (len) ? ":" : "");
	++data;
    }
}

void dumpbytes(char *prompt, unsigned char *data, int len)
{
    printf("%s: ", prompt);
    dumphex(data, len);
    printf("\n");
}

void dumpaddr(char *prompt, unsigned char *addr, int addrlen)
{
    printf("%s: ", prompt);
    if (addrlen)
    {
	printf("%02x", (int) *addr++);
	--addrlen;
    }
    else
    {
	printf("(none)\n");
	return;
    }
    while (addrlen--)
	printf(":%02x", (int) *addr++);
    printf("\n");
}

void dump8022(char *prompt, unsigned char *buf, int length)
{
    int             i;
    int             ff_cnt = 0;

    for (i = 0; i < 6; i++)
    {
	if (buf[i] == 0xff)
	    ff_cnt++;
    }

    printf("%s: ", prompt);
    printf("daddr=");
    dumphex(buf, 6);
    printf(" saddr=");
    dumphex(buf + 6, 6);
    printf("\n    length=");
    dumphex(buf + 12, 2);
    printf(" dsap=%02x ssap=%02x ctl=%02x\n", buf[14], buf[15], buf[16]);
    if (length >= 17 && ff_cnt != 6)
    {
	dumpbytes("    data", buf + 17, length - 17);
    }
}

#ifdef TR
void dumptr(char *prompt, unsigned char *buf, int length)
{				/* dump token ring header/buffer */
    tr_hdr_t       *hdrp;
    rcf_t          *rcfp;
    tr_llc_frm_hdr_t *llcp;
    int             rtelgth = 0;
    int             hdrsize;

    hdrp = (tr_hdr_t *) buf;
    rcfp = (rcf_t *) (hdrp + 1);

    printf("%s: ", prompt);
    printf("acf=%02x fcf=%02x ", hdrp->acf, hdrp->fcf);
    printf("daddr=");
    dumphex(hdrp->dst_addr, sizeof(hdrp->dst_addr));
    printf(" saddr=");
    dumphex(hdrp->src_addr, sizeof(hdrp->src_addr));

    if (hdrp->src_addr[0] & SADDR_0_RTE_PRES)
    {
	rtelgth = rcfp->bl & RCF_0_LLLLL;
	printf(" bl=%02x df=%02x", rcfp->bl, rcfp->df);
	llcp = (tr_llc_frm_hdr_t *) (buf + sizeof(*hdrp) + rtelgth);
    }
    else
	llcp = (tr_llc_frm_hdr_t *) (buf + sizeof(*hdrp));

    printf(" dsap=%02x ssap=%02x ctl=%02x\n", llcp->llc_dsap, llcp->llc_ssap,
	   llcp->llc_ctl);

    hdrsize = sizeof(*hdrp) + sizeof(*llcp) + rtelgth;
    if (length >= hdrsize)
    {
	dumpbytes("    data", buf + hdrsize, length - hdrsize);
    }
}
#endif

unsigned long do_findppa(int fd, char *interface)
{
    union {
	char            interface[256];
	unsigned long   ppa;
    } data;
    struct strioctl strioctl;

    strioctl.ic_cmd = LDL_FINDPPA;
    strioctl.ic_timout = 3;
    strioctl.ic_len = sizeof(data);
    strioctl.ic_dp = (char *) &data;
    strcpy(data.interface, interface);

    if (ioctl(fd, I_STR, &strioctl) < 0)
    {
	perror("do_findppa: ioctl()");
	return (unsigned long) -1;
    }

    return data.ppa;
}

int do_set_flags(int fd, int flags)
{
    struct ldl_flags_ioctl ioc;
    struct strioctl strioctl;

    ioc.flags = flags;
    ioc.mask = 0xff;

    strioctl.ic_cmd = LDL_SETFLAGS;
    strioctl.ic_timout = 3;
    strioctl.ic_len = sizeof(ioc);
    strioctl.ic_dp = (char *) &ioc;

    if (ioctl(fd, I_STR, &strioctl) < 0)
    {
	perror("do_set_flags: ioctl()");
	return -1;
    }

    return 0;
}

int do_info(int fd)
{
    dl_info_req_t   request;
    struct {
	dl_info_ack_t   ack;
	unsigned char   extra[1024];
    } reply;
    int             flags;
    struct strbuf   ctlbuf;
    dl_error_ack_t *err_ack;

    if (output > 2)
	printf("do_info: Sending DL_INFO_REQ\n");

    request.dl_primitive = DL_INFO_REQ;
    ctlbuf.maxlen = ctlbuf.len = sizeof(request);
    ctlbuf.buf = (char *) &request;
    if (putmsg(fd, &ctlbuf, NULL, 0) < 0)
    {
	perror("do_info: putmsg()");
	return -1;
    }

    ctlbuf.maxlen = sizeof(reply);
    ctlbuf.len = 0;
    ctlbuf.buf = (char *) &reply;
    flags = RS_HIPRI;
    flags = 0;
    if (getmsg(fd, &ctlbuf, NULL, &flags) < 0)
    {
	perror("do_info: getmsg()");
	return -1;
    }

    if (output > 2)
    {
	printf("do_info: Buffer dump:\n");
	dumpbuf(ctlbuf);
    }

    if (ctlbuf.len < sizeof(dl_ulong))
    {
	fprintf(stderr, "do_info: Bad reply length %d\n", ctlbuf.len);
	return -1;
    }

    switch (reply.ack.dl_primitive)
    {
	case DL_ERROR_ACK:
	    printf("do_info: Got DL_ERROR_ACK\n");
	    if (ctlbuf.len < sizeof(dl_error_ack_t))
	    {
		fprintf(stderr, "do_info: Bad DL_ERROR_ACK length %d\n",
			ctlbuf.len);
		return -1;
	    }
	    err_ack = (dl_error_ack_t *) & reply;
	    printf("do_info: error ack:\n");
	    printf("\tprimitive=%lu, errno=%lu, unix_errno=%lu\n",
		   err_ack->dl_error_primitive, err_ack->dl_errno,
		   err_ack->dl_unix_errno);
	    return -1;

	case DL_INFO_ACK:
	    if (output > 2)
		printf("do_info: Got DL_INFO_ACK\n");
	    if (ctlbuf.len < sizeof(dl_info_ack_t))
	    {
		fprintf(stderr, "do_info: Bad DL_INFO_ACK length %d\n",
			ctlbuf.len);
		return -1;
	    }
	    if (output > 1)
	    {
		printf("do_info: info ack:\n");
		printf("\tprimitive=%lu\n", reply.ack.dl_primitive);
		printf("\tmin_sdu=%lu\n", reply.ack.dl_min_sdu);
		printf("\tmax_sdu=%lu\n", reply.ack.dl_max_sdu);
		printf("\taddr_length=%lu\n", reply.ack.dl_addr_length);
		printf("\tmac_type=%lu\n", reply.ack.dl_mac_type);
		printf("\treserved=%lu\n", reply.ack.dl_reserved);
		printf("\tcurrent_state=%lu\n", reply.ack.dl_current_state);
		printf("\tsap_length=%ld\n", reply.ack.dl_sap_length);
		printf("\tservice_mode=%lu\n", reply.ack.dl_service_mode);
		printf("\tqos_length=%lu\n", reply.ack.dl_qos_length);
		printf("\tqos_offset=%lu\n", reply.ack.dl_qos_offset);
		printf("\tqos_range_length=%lu\n",
		       reply.ack.dl_qos_range_length);
		printf("\tqos_range_offset=%lu\n",
		       reply.ack.dl_qos_range_offset);
		printf("\tprovider_style=%ld\n", reply.ack.dl_provider_style);
		printf("\taddr_offset=%lu\n", reply.ack.dl_addr_offset);
		printf("\tversion=%lu\n", reply.ack.dl_version);
		printf("\tbrdcst_addr_length=%lu\n",
		       reply.ack.dl_brdcst_addr_length);
		printf("\tbrdcst_addr_offset=%lu\n",
		       reply.ack.dl_brdcst_addr_offset);
		printf("\tgrowth=%lu\n", reply.ack.dl_growth);
		if (reply.ack.dl_addr_length && reply.ack.dl_addr_offset &&
		    reply.ack.dl_addr_offset + reply.ack.dl_addr_length <=
		    ctlbuf.len)
		    dumpaddr("\tAddress", &ctlbuf.buf[reply.ack.dl_addr_offset],
			     reply.ack.dl_addr_length);
		if (reply.ack.dl_brdcst_addr_length
		    && reply.ack.dl_brdcst_addr_offset
		    && reply.ack.dl_brdcst_addr_offset +
		    reply.ack.dl_brdcst_addr_length <= ctlbuf.len)
		    dumpaddr("\tBroadcast address",
			     &ctlbuf.buf[reply.ack.dl_brdcst_addr_offset],
			     reply.ack.dl_brdcst_addr_length);
		if (reply.ack.dl_qos_length >= sizeof(unsigned long)
		    && reply.ack.dl_qos_offset)
		{
		    dl_qos_cl_sel1_t *sel =
			(dl_qos_cl_sel1_t *) ((char *) &reply.ack +
					      reply.ack.dl_qos_offset);

		    printf("\tQOS selection:\n");
		    if (sel->dl_qos_type != DL_QOS_CL_SEL1)
			printf("\t\tUnknown type %lu, expected %lu\n",
			       sel->dl_qos_type, (dl_ulong) DL_QOS_CL_SEL1);
		    else
		    {
			printf("\t\ttrans_delay=%ld\n", sel->dl_trans_delay);
			printf("\t\tpriority=%ld\n", sel->dl_priority);
			printf("\t\tprotection=%ld\n", sel->dl_protection);
			printf("\t\tresidual_error=%ld\n",
			       sel->dl_residual_error);
		    }
		}
		if (reply.ack.dl_qos_range_length >= sizeof(unsigned long) &&
		    reply.ack.dl_qos_range_offset)
		{
		    dl_qos_cl_range1_t *range =
			(dl_qos_cl_range1_t *) ((char *) &reply.ack +
						reply.ack.dl_qos_range_offset);

		    printf("\tQOS range:\n");
		    if (range->dl_qos_type != DL_QOS_CL_RANGE1)
			printf("\t\tUnknown type %lu, expected %lu\n",
			       range->dl_qos_type, (dl_ulong) DL_QOS_CL_RANGE1);
		    else
		    {
			printf("\t\ttrans_delay(target, accept)=(%ld, %ld)\n",
			       range->dl_trans_delay.dl_target_value,
			       range->dl_trans_delay.dl_accept_value);
			printf("\t\tpriority(min, max)=(%ld, %ld)\n",
			       range->dl_priority.dl_min,
			       range->dl_priority.dl_max);
			printf("\t\tprotection(min, max)=(%ld, %ld)\n",
			       range->dl_protection.dl_min,
			       range->dl_protection.dl_max);
			printf("\t\tresidual_error=%ld\n",
			       range->dl_residual_error);
		    }
		}
	    }
	    if (reply.ack.dl_sap_length < 0)
	    {
		sap_len = -reply.ack.dl_sap_length;
		sap_first = 0;
	    }
	    else
	    {
		sap_len = reply.ack.dl_sap_length;
		sap_first = 1;
	    }
	    addr_len = reply.ack.dl_addr_length - sap_len;
	    if (reply.ack.dl_addr_length != 0 && reply.ack.dl_addr_offset != 0)
	    {
		memcpy(my_dlsap, &ctlbuf.buf[reply.ack.dl_addr_offset],
		       addr_len + sap_len);
		if (sap_first)
		{
		    memcpy(my_sap, &ctlbuf.buf[reply.ack.dl_addr_offset],
			   sap_len);
		    memcpy(my_addr,
			   &ctlbuf.buf[reply.ack.dl_addr_offset + sap_len],
			   addr_len);
		}
		else
		{
		    memcpy(my_addr, &ctlbuf.buf[reply.ack.dl_addr_offset],
			   addr_len);
		    memcpy(my_sap,
			   &ctlbuf.buf[reply.ack.dl_addr_offset + addr_len],
			   sap_len);
		}
	    }
	    if (reply.ack.dl_brdcst_addr_length != 0
		&& reply.ack.dl_brdcst_addr_offset != 0)
	    {
		assert(reply.ack.dl_addr_length == 0
		       || reply.ack.dl_brdcst_addr_length == addr_len);
		memcpy(my_brd_addr,
		       &ctlbuf.buf[reply.ack.dl_brdcst_addr_offset],
		       reply.ack.dl_brdcst_addr_length);
	    }
	    break;

	default:
	    fprintf(stderr, "do_info: Unknown reply primitive=%lu\n",
		    reply.ack.dl_primitive);
	    return -1;
    }
    return 0;
}

int do_attach(int fd, dl_ulong ppa)
{
    dl_attach_req_t request;
    struct {
	dl_ok_ack_t     ack;
	unsigned char   extra[1024];
    } reply;
    int             flags;
    struct strbuf   ctlbuf;
    dl_error_ack_t *err_ack;

    if (output > 2)