Compare commits

...

289 Commits

Author SHA1 Message Date
Harald Welte 5255769504 Initial support for trunkdev
The 'trunkdev' is a virtual DAHDI device driver that exposes the
multiplexed E1 frames on a /dev/dahdi/trunkdev device.  This is useful
for all kinds of simulated setup, as well as in  the context of
using osmo-e1d for OCTOI (Osmocom TDMoIP).

In order for the dahdi_trunkdev utility to be built, you will need
to have installed dahdi header files of dahdi-linux with trunkdev
support, currently located at
https://gitea.osmocom.org/retronetworking/dahdi-linux/src/branch/laforge/trunkdev

Change-Id: Ie05100c80fd978e7ac6f5a028e0ef6c828e0bcc3
2023-07-29 17:49:17 +02:00
Harald Welte e9a4598c1f dahdi_pcap: Allow caller to specify network / user mode
A LAPD dissector (such as the one in wireshark) needs to know if
the local side is the user or the network in order to properly
decode/display the trace.  This is encoded in the sll_addr field
whose first octet indicates if the local (capturing) node serves
as the network or user side of ISDN.

Change-Id: Ief575bc4118fe5f20ef4b374d29eca442b04dabb
2022-02-21 21:20:59 +01:00
Harald Welte de9bd096c9 dahdi_pcap: Fix the use of the pkttype field
* pkttype is big-endian, so '3' is not valid, but htons(3)
* let's not use magic numbers but the actual #define PACKET_*
* differentiate PACKET_HOST (rx) from PACKET_OUTGOING (tx),
  which makes wireshark properly show rx/tx packets, allows coloring
  or filtering based on direction, etc.

Change-Id: I8c66a011a0fa0c5275bf3d5cf6b42064f02e28c0
2022-02-21 21:20:59 +01:00
Harald Welte 89b6df7593 dahdi_pcap: Fix LAPD pseudo header hardware address length
the 'halen' field is the length of the hardware address (8 bytes),
and not the length of the payload.

Change-Id: I72e009f40c8e9e295bc1e1f4a0951cd1236cdf43
2022-02-21 21:20:59 +01:00
Harald Welte 68395096f0 Fix compilation with gcc-10.2.0
/bin/sh ../libtool  --tag=CC   --mode=link gcc -I. -I./xtalk/include  -Wall  -g -O2 -lusb-1.0  -o astribank_tool astribank_tool-astribank_tool.o libastribank.la -lpthread -lm
libtool: link: gcc -I. -I./xtalk/include -Wall -g -O2 -o astribank_tool astribank_tool-astribank_tool.o  ./.libs/libastribank.a -lusb-1.0 -lpthread -lm
/usr/bin/ld: ./.libs/libastribank.a(libxtalk_la-xtalk_sync.o):/space/home/laforge/projects/git/dahdi-tools/xpp/xtalk/xtalk_sync.c:63: multiple definition of `members'; ./.libs/libastribank.a(libastribank_la-mpptalk.o):/space/home/laforge/projects/git/dahdi-tools/xpp/mpptalk.c:240: first defined here

Change-Id: I1d6f46874f74e1dfc70cabf7c4a8b8cdae9af4fa
2022-02-21 21:20:59 +01:00
Harald Welte 3b90fdbba1 add contrib/jenkins.sh for jenkins.osmocom.org build verification
Change-Id: I47701be92476ba9adfdf9783747c6c511cec1903
2022-02-21 21:20:59 +01:00
Keith Morgan 31cca182bf Reported by Trent Creekmore
DAHTOOL-73
Changed the output to match the command needed for installing init scripts.
2018-09-20 17:54:03 +00:00
Tzafrir Cohen 75eedd6fa6 Ignore quilt .pc directory, used in deb packaging
Debian packaging uses quilt to manage patches. Book-keeping for them is
done using quilt (either directly, or in a compatible format), and
tracked in the directory .pc .

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2018-01-11 15:50:28 +02:00
Tzafrir Cohen b54ec6efd3 xpp: dahdi_registration: wait at end of assignments
Wait for assindments to end only after calling all of them.
Otherwise we are likely to get a timeout with multiple Astribanks.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-12-24 18:02:29 +02:00
Oron Peled 754d981621 Avoid a race between /etc/init.d/dahdi and hotplug scripts:
* On some systems/configurations, dahdi init script may kick in
  during the time that hotplug scripts are configuring spans.

* It may lead to a race since the init script runs "dahdi_auto_assign_compat"
  which calls "dahdi_registration" and that tries to run
  "dahdi_span_assignments auto ..."

* Use the newly-added "dahdi_span_assignments" "unmatched" operation.

* Now the "dahdi_auto_assign_compat" script only runs "dahdi_registration"
  if there are no "unmatched" Astribanks.

* This prevents the race in fully configured systems.
  The race may still exist on partially-configured systems.
2017-08-31 19:00:02 +03:00
Oron Peled dc95a1164f dahdi_span_assignments: matched and unmatched
Add two new subcommands to dahdi_span_assignments:
* matched: list all spans that are in devices that have been registered
  and are matched by span_assignments.conf lines.
* unmatched: list all such existing spans that have not been matched
  by span_assignments.conf lines.
2017-08-31 18:56:33 +03:00
Tzafrir Cohen 9631938e90 dahdi_span_types: compare
This adds an extra subcommand: compare: shows span that have been
configured (in /etc/dahdi/span_types.conf) to a different value than
the one currently active on the system.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-06-26 17:01:09 +03:00
Tzafrir Cohen 55679791b5 xpp_fxloader: Also look for udevadm in /bin
* udevadm is being moved to /bin. /sbin/udevadm will remain as a
  compatibility symlink.
* xpp_fxloader should also look for /bin/udevadm in addition to
  /sbin/udevadm and /sbin/udevsettle
* Reverse the order: look for newer ones first.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-06-26 17:01:01 +03:00
Tzafrir Cohen ba09742a3f xpp: prevent dracut from loading Astribank drivers
Prevent an early load of the Astribank (xpp) drivers at initrd time, as
they require some files from the root filesystem.

This installs a file in the dracut configuration directory that will
take effect the next time dracut generates an initrd image.

This installs an configuration file for dracut which is ignored if
dracut is not installed and is a no-op if xpp_usb is not loaded on your
system.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-03-22 17:07:27 +02:00
Tzafrir Cohen e4197cc499 xpp: README: libusb1
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-03-21 18:46:05 +02:00
Tzafrir Cohen abd139ae91 xpp: README: hwid attribute of the xpd sysfs node
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-03-21 18:45:54 +02:00
Dima Stoliarov 6b2c6d72d8 xpp_fxloader: Also load PIC of FXS module type 6
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-03-21 13:42:35 +02:00
Tzafrir Cohen f64500c986 xpp: run xpp_sync when an Astribank is connected
This was originally done in the init script after all Astribanks were
connected. But now there is no single point in the startup sequence
where we can guarantee all of them were loaded.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2017-03-02 11:11:54 +02:00
Tzafrir Cohen 424157834d Don't install xtalk_send
xtalk_send is a helper tool for xtalk, a low-level libary used by some
Xorcom DAHDI userspace tools. It is hardly needed by most people.
2016-11-15 15:39:28 +02:00
Tzafrir Cohen 95d03118cb Typos. Mostly by Lintian
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2016-06-26 22:54:58 +02:00
Oron Peled 99e3c572d1 build fix: external CFLAGS are ignored
* When passing CFLAGS to ./configure, they are ignored.
* The reason is that in Makefile.am CFLAGS are clobbered.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2016-03-13 14:05:46 +02:00
Tzafrir Cohen 6057ef25e9 xpp: perl man pages: Perl may be upper case
In file's output Perl scripts may be 'awk or perl script',
'/usr/bin/perl script' or 'Perl script' (with some minor variants). The
latter was not detected by current code and thus perld man pages were
not created.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2016-02-17 17:40:54 +02:00
Oron Peled e1da7b5284 link libtonezone directly to libm
* Now we properly '-lm' to libtonezone itself.
  Tools that link with libtonezone get it automatically without having
  to individually link it.
  - dahdi_cfg historically needed -lm, but no longer does.

* Also use "autoscan" to refresh "configure.ac":
  - Added missing tests
  - Move AC_CHECK_HEADERS() to their correct location (before testing
    libraries).
* Fixes the following (on Ubuntu-14.04):
      CCLD     dahdi_cfg
    ./.libs/libtonezone.so: undefined reference to `sin'
    ./.libs/libtonezone.so: undefined reference to `cos'
    ./.libs/libtonezone.so: undefined reference to `pow'
    collect2: error: ld returned 1 exit status
    make[2]: *** [dahdi_cfg] Error 1

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2016-02-15 17:22:21 +02:00
Tzafrir Cohen f105a09eda Remove rcsid: Unused since move to Git
* While technically Git can support $ID keywords, in practice they are not
  used.
* GCC now give a warning about ''rcsid' defined but not used' for some
  of those.

Let's just remove the unused rcsid.
2016-02-15 17:22:21 +02:00
Oron Peled 212b247e68 xpp: move tools man-pages into PBX_USB conditional
* Otherwise, they pull compilation of xpp tools via implicit rules.
* This breaks build without libusb/libusbx
* To test this scenario:
    ./configure .... --without-libusb --without-libusbx

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2015-12-22 11:24:52 -06:00
Oron Peled f225a5692c configure.ac: remove unused PKG_CONFIG_LIBUSB
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2015-12-22 11:24:52 -06:00
Tzafrir Cohen cffc5158cc dahdi_cfg: -S has assumtions on system.conf order
dahdi_cfg's -S (apply only to a specific span) uses the array chan2span
to map channel numbers to span numbers.

The problem is that it assumes that channels first appear in system.conf
immediately after the span line of a specific span. Thus the following
configuration breaks it:

span=1,...
span=2,...
clear=1-2,4-5
dchan=3,6

The best fix for that is to require -C to be used when -S is used (which
is already the case in our udev hooks).

Fixes DAHTOOL-69.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-16 15:54:23 +02:00
Oron Peled 42850dba35 xpp: refactor manual pages out of conditionals
* So they are always included in 'make dist' even if PBX_USB is false.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:06:25 +02:00
Oron Peled 06ae8473d7 xpp: Move astribank_license to libastribank
* So it's available to all utilities

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:06:06 +02:00
Oron Peled dbb5ba6db6 xpp: allow XTALK_OPTIONS from a file
* The file is defined as XTALK_OPTIONS_FILE (/etc/dahdi/xpp.conf):
  - Lines beginning with '#' are skipped.
  - Line beginning with "XTALK_OPTIONS" are used.
  - Anything after whitespaces (with optional "=" characters) is part
    of the value.

* An environment variable named "XTALK_OPTIONS" may override file contents.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:05:44 +02:00
Oron Peled 2097f1adc5 configure.ac: xpp: now libusbx is the default
* Fallback to old libusb-0.1 if libusbx isn't found.
* Can force either: --{with,without}-{libusb,libusbx}

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:05:21 +02:00
Oron Peled d02361e99f xpp: strict compilation flags in oct612x/
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:04:49 +02:00
Oron Peled 77a3d8b0a7 xpp: don't use USB "clear-halt" by default
* Problematic with USB3 controllers

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:04:41 +02:00
Oron Peled bd49fc9d95 xpp: xtalk -- no private status range
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:04:13 +02:00
Oron Peled 0e6b068e89 xpp: migrate everything to libxtalk
* Build new libxtalk as local convenience library
 * Have new mpptalk.[ch] and astribank.[ch] wrap the new API
 * Modify all tools to use the new API

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:04:04 +02:00
Oron Peled 9c61e40187 xpp: add all base libxtalk files
* Do not remove yet the old ones.
* So new files are built, but not used yet.
* Build as a "noinst_" convenience library.
* Also, compile with '-Wno-unknown-pragmas' because we use some pragmas.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:03:43 +02:00
Oron Peled 5ee15a2337 configure.ac: add libusb/libusbx support (for xpp)
* Use pkg-config
* For tight control have: --with-libusbx, --with-libusb
  - For now, we choose libusb (AKA libusb-0.1)
  - After committing support for libusbx (AKA libusb-1.0)
    we'll change the default.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:00:54 +02:00
Oron Peled 01faf597d6 xpp: automake: cleanup $man_MANS handling
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 18:00:14 +02:00
Tzafrir Cohen 48b25e849f xpp.rules: increase xpp_fxloader timeout to 180s
Allow firmware loading to take much longer (up to 180 seconds) before
it is killed. The default timeout is 30 seconds.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-05 17:59:42 +02:00
Tzafrir Cohen d239b8dc4d ignore: dahdi_pcap and .version
.version is generated in the git tree.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2015-11-05 17:53:40 +02:00
Tzafrir Cohen 4676ad6671 make_version: cut off slashes in git
If we are based on a git tag with a name (such as 'upstream/2.10.2'),
remove everything up to the slash.

While we're at it, remove a leading '1%' that gets into the version
string as part of the version tag (a Debian version with an epoch: '1:'
is converted to '1%').

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2015-11-05 17:53:25 +02:00
Tzafrir Cohen b471526700 Makefile: build asciidoc with TZ=UTC
In order to support a reproducable build, always run asciidoc with the
timezone UTC. This makes sure that the time shown in the file will be
the same, regardless of the location from which it is run.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-11-02 10:27:08 +02:00
Russ Meyerriecks 855772135c wcb4xxp: Adds support for b43x/b23x products
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2015-10-26 16:51:50 -05:00
Oron Peled ec1ebffa89 xpp: bugfix: waitfor_xpds twinstar, auto_assign_spans
Exposed in twinstar setups where dahdi has auto_assign_spans=1:
* We start configuration with an empty /etc/dahdi/xpp_order
* If "XPP_HOTPLUG_DAHDI=yes", the astribank_hook removes
  the asterisk_is_starting semaphore too early.
* There's no point in waiting for non-existant or empty /etc/dahdi/xpp_order

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-07-19 13:15:01 +03:00
Tzafrir Cohen 9afcde3f1e README: document the need for autoreconf
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-06-27 01:56:02 +03:00
Russ Meyerriecks 9a181ccfbc xpp: Fix a logical not being applied to the wrong operand
gcc 5 found this with the new -Werror=logical-not-parenthesis warning. Since we
have -Wall by default, it would also fail the compile.

Internal-Issue-ID: DAHLIN-347

Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>
2015-06-22 13:45:54 -05:00
Tzafrir Cohen 10c1cd196e Force-link libtonezone.so.2.0 on make install
Use ln -sf to create libtonezone.so.2.0 on the install target

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-06-14 16:29:30 +03:00
Tzafrir Cohen 65ba28fe4a A placeholder for the m4 directory
The m4/ directory needs to exist
2015-06-02 14:41:34 +03:00
Oron Peled 66e2c3ba11
autotools: now "make distcheck" also works.
* Fix distcheck by having all the targets installed under $prefix
* But by default (no prefix or prefix=/usr), revert to older pathes:
  - /etc/dahdi
  - udev rules in /etc/udev/rules.d
  - perl in perl sitelib
  - man pages in /usr/share/man
* Add configure options:
  --with-udevrules= (e.g.: /lib/udev/rules.d)
  --with-perllib= (e.g.: `perl -V:vendorlib)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-26 13:57:36 +03:00
Oron Peled 94ca4a1bb4
automake: remove unused stuff from Makefile.legacy
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-26 12:19:35 +03:00
Oron Peled af920cd079
automake: bugfix: fix installation paths
* Install to $datadir/dahdi and not $datadir/dahdi-tools
* Install to $includedir/dahdi and not $includedir/dahdi-tools

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-26 12:18:30 +03:00
Tzafrir Cohen b375bb80b8 Update README
Reflect recent changes as well as soem long-due fixes.
2015-05-19 20:58:50 +03:00
Oron Peled 0090086bce automake: handle "make dist"
* "make distcheck" still fails

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled f21b592f68 automake: migrate dahdi_pcap from Makefile.legacy
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled d63812bd73 automake: migrated "--enable-dev-mode"
* Fix small compile warnings (which are now errors):
  - hdlcgen.c
  - hdlcstress.c (remove return value which isn't checked)
  - patlooptest.c

* Also added dev-mode to xpp with relevant compile fixes.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled bf9500ab32 automake: migrate tools from Makefile.legacy
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled 703db3bcc3 automake: handle doc/ man-pages
* Install via doc/Makefile.am
* Remove relevant code from Makefile.legacy
* For now, leave the conversion to HTML in Makefile.legacy

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled b5b32a438f automake: xpp: remove xpp/Makefile.legacy
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled 4cc7df1089 automake: xpp: handle /usr/share/dahdi
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled ac6f437317 automake: xpp: handle udev rules
* Set udev installation directory to $sysconfdir/udev/rules.d
* Add definitions to xpp/Makefile.am and remove them from xpp/Makefile.legacy
* TODO: add "--with-udev-rulesdir=" for packagers (/lib/udev/rules.d)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:54:11 +03:00
Oron Peled b054abb7e9 automake: xpp: man-pages and perl-scripts
* Now man-pages and perl-script are handled by xpp/Makefile.am
* Removed from xpp/Makefile.legacy
* Detect perl and set perllibdir in configure.ac
* Handle modules in their own xpp/perl_modules/Makefile.am
* Enclose perl-related stuff in conditional
* Updates for "make dist"

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 19:52:15 +03:00
Oron Peled ee83afa669 automake: handle xpp/ compilation via Makefile.am:
* Added xpp/oct612x/Makefile.am:
  - Compile octasic sources into a convenience library (static, not installed)
  - Set OCTASIC_CFLAGS in configure.ac, as they are used in two
    Makefile.am's
  - Added relevant Makefile.in and Makefile into build_tools/make_dist

* In xpp/Makefile.am:
  - Have USE_OCTASIC conditional (currently configure.ac always set it to true)

* Added PBX_USB automake conditional, so we only build our tools if
  configure'd for libusb.

* Create two convenience libraries (libastribank and libecholoader)
  Statically link them into our tools.

* Handle man-pages for the tools.

* Remove all new functionality from xpp/Makefile.legacy -- it now
  contains:
  - All perl related tools and man-pages
  - Other misc stuff (udev files, etc.)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 17:01:55 +03:00
Oron Peled 5ac7fef4b2 automake: full ppp/ support
* Remove ppp/Makefile.legacy
* The ppp/Makefile.am includes complete functionality

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 16:31:57 +03:00
Oron Peled 6df9a492a0 automake: add basic libtool support
* Also:
  - Add libtool-related files into "make dist"
  - Update .gitignore

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 16:27:34 +03:00
Oron Peled fc620819b6 automake: add basic framwork
* Added needed boilerplate to configure.ac

* Wrap original Makefile's with automake:
  - Renamed all original Makefile -> Makefile.legacy
  - Force automake generated Makefile to call Makefile.legacy:
    Currently handle: all, install, clean, distclean, dist, docs, config
  - Note: our temporary 'dist' target conflicts with automake 'dist' target.

* Temporarily added extra dist files into build_tools/make_dist
  (until we move "make dist" functionality into automake)

* For now, we don't try to compile ppp/ as it wasn't compiled
  from the top-level Makefile before.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 16:22:10 +03:00
Oron Peled 723b3ce87f autoconf: rename "dahdi" to "dahdi-tools"
Autoconf use this name as the "PACKAGE_NAME":
 * Available as a macro to compiled code and Makefile's
 * With automake, this determines the name of the tarball
   produced in "make dist"

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 15:55:04 +03:00
Oron Peled 5fd1ce5ca0 build: remove unused "update" target from Makefile
The 'update' makefile target seems unused as it has not been
updated to use git.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 15:52:35 +03:00
Oron Peled 41532ca8a1 build: generate version.c during configure
The TOOLSVERSION was inconsistent in configure.ac and Makefile:
* Rename the second parameter to AC_INIT() into short_version
* Calculate TOOLSVERSION during configure and use it to
  generate version.c from version.c.in
* For now, leave duplicate TOOLSVERSION in Makefile (for make dist)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 14:32:44 +03:00
Oron Peled fbb6c1a17e build: xpp -- remove legacy usb-hotplug
Hotplug is the system that predated udev. No longer supported anywhere
sane.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 14:29:20 +03:00
Oron Peled 131d694054 build: fix ppp/Makefile CFLAGS
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 14:26:53 +03:00
Oron Peled 010c4d836c build: remove unused xpp/oct612x/Makefile
* Octasic sources are built from xpp/Makefile

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 14:25:30 +03:00
Oron Peled 025b9a5593 build: remove unused build_tools/menuselect-deps.in
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 14:24:37 +03:00
Oron Peled c863d1d2c2 build: remove autoconf generated files
* Remove autoconf related files
* Add needed ones to "dist"
* Ignore config.guess, config.sub (currently they aren't used)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-05-19 14:20:45 +03:00
Tzafrir Cohen 77730a9059 xpp_fxloader: handle empty span-type.conf
If we have /etc/dahdi/span-types.conf but it doesn't have any
line, we should avoid using the option -S to astribank_hexload.
Fix the test for this.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-03-31 22:37:10 +03:00
Tzafrir Cohen 3f55dd78de no astribank_is_starting with hotplug asterisk
Don't run the final astribank_is_starting if asterisk is hotpluggable.

Likewise, if there's no xpp_order file, waiting is pointless as the hook
can't count Astribanks.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2015-01-21 20:47:36 +02:00
Tzafrir Cohen 283f01bd67 astribank_hook: remove useless 'time'
* 'time' was added here for debugging and never actually needed.
* It actually causes a minor bashism issue.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-12-07 11:53:07 +02:00
Oron Peled 631d32680f xpp: waitfor_xpds: Always remove Astribank semaphore
If we waited -- no Astribanks are "in initialization"

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-11-06 13:29:19 +02:00
Oron Peled 44fe560f3b xpp/astribank_hook: remove Astribank initialization
If this is the last seen Astribank

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-11-06 13:29:19 +02:00
Oron Peled 1a78b71fac xpp: waitfor_xpds: documentation
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-11-06 13:29:19 +02:00
Oron Peled f11b937659 xpp: can use modern Asterisk hotplug support
* New asynchronous behavior is used only when two conditions are met:
  - Finding new $ASTERISK_SUPPORTS_DAHDI_HOTPLUG=yes in /etc/dahdi/init.conf
    This should be set only when Asterisk support hotplug and configured
    to use it (no_failed_channels==1).
  - DAHDI auto_assign_spans==0

* Adapt /usr/share/dahdi/astribank_hook:
  - Refactor old twinstar behavior into functions
  - Add new behavior in a function (just enable the Asrribank watchdog)
  - Call the correct function.

* Adapt init script:
  If asynchronous behavior is on, don't wait for all Astribanks to
  finish initialization (it's enough that we saw all/some of them)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-11-06 13:29:19 +02:00
Oron Peled cd6083b6ce xpp: waitfor_xpds: assume astribank_is_starting exists
It's in the same package (dahdi-tools) for a long time

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-11-06 13:29:19 +02:00
Oron Peled 0eb77e626e xpp: waitfor_xpds: expansion error with no ABs
Fix an exansion error in case there were no Astribanks on the system.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-11-06 13:29:19 +02:00
Oron Peled 2e1c15baa3 xpp: astribank_is_starting: improve '-v' output
Do print a message if no semaphore exists. It means that either there
are no Astribanks, or existing Astribanks were already initialized.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-11-06 13:29:19 +02:00
Russ Meyerriecks 094bb2c1e8 tonezone: Fix regression in Australian tone patch
Initialize db to 1.0 instead of doing it in a few, but not all, logic contexts.

Reported-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2014-09-16 19:07:17 -05:00
Oron Peled 9aee76a3a5 xpp: revert USB "clear_halt" change and better overrides.
Why:
 * Doing "clear_halt" is normally the right thing to do on startup.
 * The original observed problem is better fixed via USB bios settings.
 * Defaulting to no "clear_halt" cause more problems on other platform
   combinations (hardware/kernel).

The change:
 * We now reverted to do "clear_halt" by default.
 * The XTALK_OPTIONS may now contain either "use-clear-halt" (the default)
   or "no-use-clear-halt" to override for debugging/testing.

Original commit: ca7c04e9cb

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-08-18 15:15:06 +03:00
Tzafrir Cohen d4537e46ce xpp: astribank_hexload: allow empty span specs
DAHDI 2.9.2 added support for -S (span specs). However if this option
was not specified, it fails to run.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-08-04 09:35:52 +03:00
Tzafrir Cohen 60401c5f49 xpp_fxloader: rename variable: default_law -> law
The variable 'default_law' was the result of a partial renaming of the
original variable 'law'. Let's keep all of them in sync.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-08-04 09:35:52 +03:00
Armen Karlozian a109763160 tonezone: Fix congestion tone for Australia
The Congestion tone in Australia must be reduced by 10 to 15 dB
at every other cadence and the frequencies for both at cadences are 425 Hz.

From: Armen Karlozian <armeniki@hotmail.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-08-01 16:04:00 -05:00
Shaun Ruffell 6c40704fec zonedata: Ensure all zones have a default DAHDI_TONE_DIALRECALL.
The default 'us' tone is most likely better than silence when Asterisk tries to
generate the recall tone on a DAHDI channel.

Internal-Issue-ID: DAHTOOL-63
Reported-By: Igor Kravets
Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-08-01 15:53:48 -05:00
Russ Meyerriecks 95e9dd71d8 dahdi_cfg: Reduce mass ioctls on non-existing channels
Logic was calling DAHDI_SPECIFY ioctl on all channels up to maximum channel
limit. Added a short circuit to prevent the ioctl on channels that aren't
configured.

Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>
2014-07-23 16:53:38 -05:00
Russ Meyerriecks df47721962 dahdi_cfg: minor: Rename fo_real to dry_run
Minor readability change

Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>
2014-07-23 16:52:59 -05:00
Russ Meyerriecks 4e14561508 wcte43xp: Teach tools about te436 and te236 products
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2014-07-18 10:41:54 -05:00
Shaun Ruffell 49361e5ce7 dahdi_cfg: Warn if idle bits are set on invalid channel type.
Hopefully will save a little time in the future if anyone ever types into
/etc/dahdi/system.conf:

  bchan=1-15,17-30:1101

when they meant:

  cas=1-15,17-30:1101

in the future.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-07-09 15:55:37 -05:00
Shaun Ruffell 8045f7f493 dahdi_cfg: Unlink semaphore on early exit.
If dahdi_cfg is terminated while holding the named semaphore, it is possible to
leave it behind and all subsequenct invocations of dahdi_cfg will block waiting
for it.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-07-07 17:06:16 -05:00
Tzafrir Cohen 64e7c688d3 Makefile: A typo in a comment
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-06-30 13:47:23 +03:00
Oron Peled b28ec382bb added autoconfig.h to .gitignore
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-06-29 16:34:24 +03:00
Oron Peled 412c3f0fe3 xpp: support per-port E1/T1 EC
* Added optional '-S <span-spec>' argument to astribank_hexload:
  - Allow passing PRI span specification to EC firmware loader.
  - The span specifications is whitespace/comma separate list
    of items.
  - Each item is: <span>:<type> (Example: 3:T1)
  - The <span> may use shell-like globbing (e.g: *:E1 or [12]:T1)
  - Any span not matched in the span specification will be set
    as without the new '-S' option (i.e: depends on the '-A' option).

* Adapted xpp_fxloader:
  - Read specification for both device label and wildcard from
    /etc/dahdi/span-types.conf
  - If the result is non-empty, pass it as '-S <span-spec>' to
    the EC firmware loader.
2014-06-29 16:34:21 +03:00
Oron Peled fc459c374c xpp: set EC firmware according to PRI settings:
* Read first from modern configuration files
  (/etc/dahdi/span-types.conf)
  - Support either exact label match or complete '*' match in the
    configuration file.

* Fallback to legacy /etc/dahdi/xpp.conf

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-06-29 16:34:17 +03:00
Oron Peled ca09f327ed xpp: better dahdi_registration
Improvements to the xpp tool dahdi_registration:

* Use the new xpp driver with support for dahdi_registration sysfs
  attribute in each device.

* Wait for UDEV to finish handling span assignments (via
  dahdi_waitfor_span_assignments).

* Still supports legacy drivers without this, by falling back
  to old style iterative "registration" on each xpd.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-06-29 16:30:34 +03:00
Tzafrir Cohen b1d55683ae xpp: Don't generate .depends if there's no libusb
Creating the The .depends file requires libusb support.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-06-10 12:41:43 +03:00
Oron Peled 9285e86492 xpp: better error checking (echo_loader)
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-05-11 19:07:40 +03:00
Oron Peled ca7c04e9cb xpp: fix usb "clear_halt" problem
* Don't use "usb_clear_halt" by default anymore
   - It caused problems with specific devices in the past
   - Now it cause problems with specific servers as well (64 bits, USB3)

 * Add an "XTALK_OPTIONS" environment variable to pass options:
   - Use it to implement a "use-clear-halt" boolean option that
     restore original behavior.
   - Also use it for "no-lock" option which replace the legacy
     environment variable "XUSB_NOLOCK".
2014-05-11 18:03:11 +03:00
Oron Peled ae02edacb4 xpp: safer compilation
* Compile with "-Wall -Werror"
* Better dependency calculation:
  - Explicit listing of sources, don't use wildcards.
  - Pass various CFLAGS to dependency calculation as well.
  - Make sure a failure is propagated

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-05-11 18:03:11 +03:00
Shaun Ruffell 2abfd165ae system.conf.sample: Remove reference to single frequency signalling.
Single frequency signalling has not been supported in dahdi_cfg since the switch
to DAHDI. Before DAHDI, in the Zaptel days, it was only suported in the
ztcfg_dude utility which wasn't mainlined. So this removes references to those
signalling modes unless support is added back into the driver.

Internal-Issue-ID: DAHLIN-335
Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2014-05-05 09:45:02 -05:00
Oron Peled 1e6b2741db dahdi_genconf: remove hard-coded E1 default
* The "spantypes" generator had E1 default if no 'line-mode' parameter
  was passed.

* As a result the new logic in "dahdi_span_types dumpconfig" had no
  effect when called from dahdi_genconf, as it was always called
  with "--line-mode=" argument.

* Now "dahdi_genconf spantype" behaves just like
  "dahdi_span_types dumpconfig":
  - The "--line-mode=" forces generation of provided line-mode (E1/J1/T1)
  - Without this option, the generated config matches the current spans
    state according to new dahd_span_types default logic:
    - Wildcard rule if all spans have same line-mode.
    - Uncommented specific matches if spans have different line-modes.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-04-30 22:51:58 +03:00
Oron Peled 794c8eb048 xpp: waitfor_xpds: handle missing serial numbers
Fixes a regression since 949ea4ca9f
(2.7.0) - allows using an Astribank with no serial.

* Some of the olderst Astribanks don't have a serial number burned in
  them. Thus there is no serial attribute for the sysfs USB device node.

* waitfor_xpds identifies the Astribanks by their serial numbers.

* An lone Astribank without serial number would thus block waitfor_xpds
  (until timeout).

* Now we warn about them.

* We also try to handle it gracefully. As long as there's only one
  of thease, it would be counted as "NO-SERIAL".

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-04-30 22:48:06 +03:00
Oron Peled ffe36c63e0 xpp: dahdi_registration: force re-assignment
* The system state causing the bug:
  - DAHDI has auto_assign_spans==1
  - No /etc/dahdi/assigned-spans.conf

* The bug scenario:
  - During initial device detection, they are assigned by
    DAHDI driver.
  - Later we run "dahdi_span_assignment remove"
  - Then, a "dahdi_registration on" would not assign any span.

* The fix:
  - Using the '-R' option, force "dahdi_registration on" to also
    do "dahdi_span_assignment auto" on relevant devices.
  - This is the way it's called by /usr/share/dahdi/dahdi_auto_assign_compat

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>
2014-04-30 22:46:41 +03:00
Oron Peled f2628eeedd improved dahdi_span_types dumpconfig
* Better defaults:
  - A wildcard match:
    - If '--line-mode' option is given, generate a wildcard entry.
      (existing behavior).

    - Otherwise, if *all spans* are of the same type (E1/T1),
      generate a wildcard entry for this type.
      This is the most common use-case and now it work without
      any command line flags.

    - Otherwise (mixed E1/T1 spans), do not generate a wildcard entry.
      This isn't common case (except from our labs), but regardless
      without '--line-mode' any guess could be wrong.

  - Specific device matches:
    - If all spans are of the same type, generate commented out
      specific entries (for manual overrides).

    - If spans have mixed E1/T1 types, generate specific entries
      In this case, specific entries MUST NOT be commented out
      otherwise, the configuration file is wrong!

* Generated header with better organization:
  - Shows what is generated:
    - Generating wildcard / Not generating wildcard
    - Generating specific lines / Generating *commented-out* specific lines

  - For each decision, show *why* it was taken.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-04-01 21:23:28 +03:00
Oron Peled 1292ea9078 registration-order: Added dahdi_auto_assign_compat
Maintains the original registration order as was before span
assignments. Should allow seemless trannsition to
dahdi.auto_assign_spans=0

* The idea:
  - We stop handling in udev the case of missing
    /etc/dahdi/assigned-spans.conf
  - Instead we rely on "registration_time" dahdi_device attribute from
    DAHDI-linux
  - Then, we can sort the devices and assign their spans in
    /etc/init.d/dahdi
* Mechanics:
  - From /etc/init.d/dahdi, we run a new 'dahdi_auto_assign_compat'
    script (after "waitfor_xpds" etc.)
  - In this script we "auto" assign spans of non-Astribank devices
  - In the end of the script we run "dahdi_registration" which
    does the same for Astribank devices.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-03-25 14:51:29 +02:00
Oron Peled cfee27106b hotplug: call handle_device.d/ actions for remove
* Original actions didn't care about remove (10-span-types, 20-span-assignments)
* But others need to know about removals too.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-03-25 14:48:09 +02:00
Shaun Ruffell 066fa2aff3 dahdi_cfg: error()->perror() when sem_open fails.
This fixes a confusing error message. When sem_open failed, the system.conf line
number was being printed and the system error code was not.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2014-02-12 11:56:00 -06:00
Aslan Laoz bce5afacf1 waitfor_xpds: handle the case of a failing AB
If an Astribank failed initialization, don't keep waiting for it.
2014-02-07 14:23:19 +02:00
Tzafrir Cohen dd752529f0 auto_assign_spans may be true even if not '1'
auto_assign_spans is an int and may have legal values other than 1. It
is legal (though pointless) to use: modprobe dahdi auto_assign_spans=3.
Any value != 0 is true.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-02-07 14:22:49 +02:00
Shaun Ruffell 27d07446ef hotplug: Check for auto_assign_spans only when ACTION is add.
Removes a potentially confusing error message. This is a reapplication of
(4f259cd569 "dahdi_handle_device, dahdi_span_config: Check for
auto_assign_spans only when ACTION is add.") which appears to have been
accidentally removed when moving the hotplug scripts into a subdirectory.

From the original commit:

When dahdi.ko is unloaded, it may be possible for the driver to be removed from
the kernel before the udev scripts are run.  When this happens, you'll see
messages like the following which are not accurate:

    'dahdi_handle_device'[24567]: Old driver (no auto_assign_spans parameter). Skip /devices/pci0000:00/0000:00:1e.0/0000:11:01.0/pci:0000:11:01.0

Now instead you will see:

    'dahdi_handle_device'[28008]: remove: /devices/pci0000:00/0000:00:1e.0/0000:11:01.0/pci:0000:11:01.0

Also, all the udev events will be logged in the system log even when they are
ignored because of legacy auto span assignment. This will help show what is
going on during the transition period to full udev configuration of spans.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Oron Peled <oron.peled@xorcom.com>
2014-01-31 16:08:21 -06:00
Shaun Ruffell 8e2a5def27 hotplug: Do not run auto span configuration if spans are auto assigned.
This reapplies the change made in commit (6ed0adc08 "dahdi_span_config: Do not run auto
span configuration if spans are auto assigned.") which appears to have been
accidentally removed in (7f826a7d35 "hotplug modularization: split logic to
scriptlets").

To rationale from commit 6ed0adc08:

I have seen cases were users run:

  # modprobe <driver>; dahdi_cfg -c <custom config file>

and the spans end up misconfigured because dahdi_span_assignments ends up
running, via udev, after the user configured the span the way it wanted.

dahdi_span_assignments now looks at auto_assign_spans module parameter on
dahdi.ko, like dahdi_handle_device already does, to determine if legacy or udev
based configuration is being done.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2014-01-31 11:16:08 -06:00
Tzafrir Cohen e553ffde2b README: udev hooks run scripts from directories
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-28 11:42:33 +02:00
Tzafrir Cohen d1fb614ac8 hotplug: document asterisk scriptlet
A well-behaving distribution may choose not to install
span_config.d/50-asterisk as part of dahdi-tools, as it belongs in
asterisk. Still, it would be nice to be able to keep it as a documented
usage example. So just writ where this file needs to go and what it
does.

No other change: it is still installed by default.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-28 11:32:31 +02:00
Tzafrir Cohen 98ecc272d1 hyphen/minus fixes in man pages
in groff '-' creates a hyphen and for a minus (path, option, or similar)
you need '\-'.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-27 20:29:04 +02:00
Russ Meyerriecks 91768d360c dahdi.init: Don't exit on lack of /etc/dahdi/system.conf
auto_spans and dahdi_cfg -c are valid config methods which may not have a
/etc/dahdi/system.conf. We already check for the existance of the dahdi modules
before the case start, so I think it's safe to remove this section.

Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-23 16:25:56 -06:00
Tzafrir Cohen 63842cc4f3 bash_completion: fix dahdi_genconf
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-23 23:16:55 +02:00
Tzafrir Cohen b8d1e467e4 dahdi_perl: fix regression with an AB with no modules
Fixes a regression introduced in
3572bb5a13 (before 2.7.0) - most of the
dahdi_perl tools will fail for an Astribank with no modules claiming
"No XPDs for '/sys/bus/astribanks/devices/xbus-00'"

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-23 22:32:45 +02:00
Tzafrir Cohen de1ee8494a programmable bash completion for some commands
Programmable bash completion for dahdi_span_assignments,
dahdi_span_types and dahdi_genconf.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-By: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 22:30:47 +02:00
Tzafrir Cohen d3feed5c4c dahdi_span_types: hush warning of missing attribute
Don't warn when a sysfs attribute does not exist.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-By: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 21:33:10 +02:00
Oron Peled b621c02b7f Change span-type.conf generation policy
* Add '--line-mode=<E1|T1|J1>' option to dahdi_span_types:
  - Will first generate a wildcard entry (* *:<type>)
  - All later entries will be commented-out.
  - Manually uncommenting any of them will create an "override"
    (e.g: mixed system with all spans T1, but some E1)

* Now dahdi_genconf does not generate span-types.conf by default:
  - Added '--line-mode=<E1|T1|J1>' option to trigger generation
  - This parameter will be passed to "dahdi_span_types dumpconfig"
  - Also explicit specification of 'spantypes' as an argument will
    trigger a similar generation (with a default of 'E1').
  - The line-mode may also be passed to the generator directly
    with identical results. Example:
          dahdi_genconf spantypes=line-mode=T1

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-By: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 21:32:14 +02:00
Oron Peled 451a8b4d6f dahdi_span_types: allow defaults + overrides
* Allow wildcards for both device and span number (as before).
  Example:
     *        *:T1

* But now we are carefull to follow strict order in the configuration
  file. This means, if there are multiple matches -- last one wins.

* So we can use specialisation:
     *        *:T1	# Everything is T1
     FOO      [34]:T1	# Except spans 3,4 on the FOO device

* Added --dry-run and --verbose options.

* Updated the man-page:
  - Fixed "registered" => "assigned".
  - Use "line mode" for E1/J1/T1.
  - Document current changes.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-By: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 21:28:59 +02:00
Tzafrir Cohen 09fd3f53b1 dahdi_span_assignments.8: s/register/assign/
* Use the term "assignment" instead of "registration" (for spans).
* Further fixes.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-By: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 21:27:58 +02:00
Oron Peled c3b020a155 new "dahdi_waitfor_span_assignments" tool
* Allows waiting until all spans are "assigned" or "unassigned"
* Current implementation use a polling loop with sleep
* Future implementation may block on sysfs attribute
  (like waitfor_xpds is blocking on sysfs Astribanks attribute)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 12:35:59 +02:00
Oron Peled 7f826a7d35 hotplug modularization: split logic to scriptlets
* Device related operations are ordered in /usr/share/dahdi/handle_device.d/
* Span related operations are ordered in /usr/share/dahdi/span_config.d/
* In the future, span_config.d/50-asterisk should be moved to Asterisk.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 12:35:59 +02:00
Oron Peled cdedf024ae hotplug modularization: move sources to a subdir
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-23 12:35:59 +02:00
Russ Meyerriecks a6203e151f wcte13xp: Teach tools about te131 te132 products
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-22 17:45:58 -06:00
Shaun Ruffell 69ce6f07e0 dahdi_cfg: Allow dynamic spans to handle udev based span assignment.
Prior to this commit, if auto_assign_spans was set to 0, it was possible to
get in an endless loop creating and destroying spans. The primary reason was
that all dynamic spans are destroyed and recreated each time dahdi_cfg runs, BUT
dahdi_cfg was run each time a new span showed up in udev when auto_assign_spans
was set to 0.

Now dahdi_cfg will only destroy and recreate dynamic spans if dahdi_cfg is run
without a specifc span number. Also, while creating dynamic spans, dahdi_cfg
will pause for up to one second for the span to be assigned in order to ensure
that the spans are numbered consistently when auto span assignment is
configured.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-22 12:58:57 -06:00
Shaun Ruffell 9989b8779c dahdi_cfg: Add semaphore to prevent parallel execution.
When dahdi is configured for fully dynamic configuration on a device and
span basis via sysfs and udev it is possible for multiple instances of
dahdi_cfg to be run in parallel on different spans. If this happens it
is possible to see errors on the console that tone zones are already
registered since the check for the existence of a tone zone and the
re-registering needs to be atomic.

dahdi_cfg will now prevent itself from running in parallel.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2014-01-22 12:58:57 -06:00
Shaun Ruffell a4f79134c9 dahdi_handle_device: Auto assign only the device being added.
Eliminates trying to add spans multiple times as seen below:

    'dahdi_handle_device'[21993]: add: /devices/dynamic:loc:1
    'dahdi_handle_device'[21991]: add: /devices/dynamic:loc:0
    'dahdi_handle_device'[22001]: auto-assign /sys/bus/dahdi_devices/devices/dynamic:loc:0
    'dahdi_handle_device'[22001]: auto-assign /sys/bus/dahdi_devices/devices/dynamic:loc:1
    'dahdi_handle_device'[21999]: auto-assign /sys/bus/dahdi_devices/devices/dynamic:loc:0
    'dahdi_handle_device'[21999]: auto-assign /sys/bus/dahdi_devices/devices/dynamic:loc:1
    kernel: [ 3348.312534] dahdi_devices dynamic:loc:0: local span 1 is already assigned span 1
    kernel: [ 3348.312552] dahdi_devices dynamic:loc:1: local span 1 is already assigned span 2

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-20 19:22:57 +02:00
Shaun Ruffell d8074f434f dahdi_span_types: Show location of configuration file in help message.
Makes similar in for the dahdi_span_assignments in that the location of the
default configuration file is shown in the help screen.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-20 19:22:57 +02:00
Shaun Ruffell 15875924f0 dahdi_genconf: Add 'modules', 'spantypes', and 'assignedspans' to list of available generators.
This is a documentation change, that hopefully will help until I can remember
the names of the new generators.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-20 19:22:57 +02:00
Tzafrir Cohen a5bf1d3a2e dahdi_genconf: don't generate spantypes by default
A sane value for span-types.conf is either "all E1" or "all T1". Either
way it is not hardware-dependent, and hence no point in regenerating on
when the hardware changes.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-20 19:22:57 +02:00
Tzafrir Cohen bf960799ea span_types/assignments: no * in device list
If there are no dahdi devices, $devbase/* expans to have a literal '*',
which leads to warnings such as:
/usr/sbin/dahdi_span_types: 1: cd: can't cd to /sys/bus/dahdi_devices/devices/*

Let's just avoid those.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2014-01-20 19:22:03 +02:00
Shaun Ruffell 4f259cd569 dahdi_handle_device, dahdi_span_config: Check for auto_assign_spans only when ACTION is add.
When dahdi.ko is unloaded, it may be possible for the driver to be removed from
the kernel before the udev scripts are run.  When this happens, you'll see
messages like the following which are not accurate:

    'dahdi_handle_device'[24567]: Old driver (no auto_assign_spans parameter). Skip /devices/pci0000:00/0000:00:1e.0/0000:11:01.0/pci:0000:11:01.0

Now instead you will see:

    'dahdi_handle_device'[28008]: remove: /devices/pci0000:00/0000:00:1e.0/0000:11:01.0/pci:0000:11:01.0

Also, all the udev events will be logged in the system log even when they are
ignored because of legacy auto span assignment. This will help show what is
going on during the transition period to full udev configuration of spans.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Oron Peled <oron.peled@xorcom.com>
2014-01-08 17:56:52 -06:00
Tzafrir Cohen 4d5ca04ad6 README: Update the install targets
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-12-30 19:24:23 +02:00
Tzafrir Cohen 2d3580a3db README: document initialization
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-12-30 19:12:59 +02:00
Tzafrir Cohen d96be70986 README: indentation level for config samples
Indent the configuration samples one level deeper

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-12-29 20:32:12 +02:00
Tzafrir Cohen 41a725adea .gitignore: more generated files
Ignore test binaries and files generated by 'make docs'

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-12-29 13:53:53 +02:00
Shaun Ruffell 6ed0adc086 dahdi_span_config: Do not run auto span configuration if spans are auto assigned.
I have seen cases were users run:

  # modprobe <driver>; dahdi_cfg -c <custom config file>

and the spans end up misconfigured because dahdi_span_assignments ends up
running, via udev, after the user configured the span the way it wanted.

dahdi_span_assignments now looks at auto_assign_spans module parameter on
dahdi.ko, like dahdi_handle_device already does, to determine if legacy or udev
based configuration is being done.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Oron Peled <oron.peled@xorcom.com>
2013-12-21 00:02:22 -06:00
Tzafrir Cohen 5e75fa48f4 dahdi.rules: use += for RUN
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-12-12 23:47:50 +02:00
Tzafrir Cohen 4ab8e95d0b dahdi.rules: Replace SYSFS with ATTRS
SYSFS has been deprecated. Use ATTRS.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-12-12 23:47:50 +02:00
Shaun Ruffell 5ca600c7c7 dahdi_cfg: Wait for all spans to be assigned.
When auto span assignment is disabled, it's possible that simply running

  # /etc/init.d/dahdi restart

Will fail since dahdi_cfg can run in parallel with udev scripts that are
assigning spans, which results in /etc/dahdi/system.conf describing spans that
do not exist in the system.

This change sets up dahdi_cfg, when run without the -C or -S options, to look in
sysfs and make sure all spans for each device are assigned.  dahdi_cfg will wait
5 seconds for span assignment to happen before proceeding normally.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-12-12 09:08:51 -06:00
Oron Peled 98736e1add Makefile: do install all man-pages
Fixes a regression in 2.8 (ffced0ca) in the main Makefile:
MAN_PAGES gets assigned twice and thus most man pages will not get
installed.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-12-09 22:57:41 +02:00
Oron Peled a9338d9b74 Makefile: new 'make-dist' target
Creates a tar.gz:
* Identical results to Digium's distributed tarballs
* Named "dahdi-tools-<version>.tar.gz"
* Only from committed files (uses git-archive)
* Adds a .version file

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-12-02 23:01:17 +02:00
Shaun Ruffell c0e19d47e8 dahdi_span_assignments, dahdi_span_types: Allow conf file to be overridden.
The environment variables that specified the full path the the configuration
files for dahdi_span_types and dahdi_span_assignments was documented, but they
were not actually set from the environment.

Also, the case of the variable was changed to match the one for the directory
where the rest of the config files are located.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2013-11-26 13:50:02 -06:00
Shaun Ruffell ffced0cad2 Add dahdi_ prefix to handle_device, span_types, span_assignments, and span_config.
All new dahdi tools and utilities will be prefixed with "dahdi_" in order to
avoid any future conflicts with other packages.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Oron Peled <oron.peled@xorcom.com>
2013-11-26 13:50:02 -06:00
Shaun Ruffell e298eb1237 span_types: Fix bug that would prevent matching on devpath.
If a configuration file was specified that used the devpath, like:

  # Device: [] @Board_ID_Switch_0 /sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:08.0/pci:0000:02:08.0
  /sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:08.0/pci:0000:02:08.0 1:E1
  /sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:08.0/pci:0000:02:08.0 2:E1
  /sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:08.0/pci:0000:02:08.0 3:E1
  /sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:08.0/pci:0000:02:08.0 4:E1

Then the span_types script would silently fail to match the configuration lines
for the device and silently fail to change the linemodes.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Oron Peled <oron.peled@xorcom.com>
2013-11-25 16:11:37 -06:00
Tzafrir Cohen a97d373d95 configure: regenerate for 6d10525
Regenerate configure script following changes in commit
6d10525863.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-11-24 18:11:04 +02:00
Shaun Ruffell c27664dc1b dahdi.init: Remove spurious "Missing '/sys/bus/astribanks/drivers/xppdrv/sync'".
The xpp_sync will fail if there are not any Astribank devices loaded. Check for
existence of the tools before trying to sync.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-11-24 10:06:11 -06:00
Tzafrir Cohen 365a12f42a README: include pinned spans config files
Include pinned-spans.conf and span-types.conf in the generated
README.html. Reformat them to render properly.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-11-24 16:48:29 +02:00
Oron Peled 2a84216fe4 Terminology rename: "pinned" -> "assigned"
* File names fixed
* File contents fixed

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:42:15 +02:00
Oron Peled 791a596c07 dahdi.rules: add persistent channel names as well
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:39:33 +02:00
Oron Peled d145364c00 dahdi.rules: don't process "add" events unless needed
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:38:43 +02:00
Oron Peled 0afba16b2e hotplug: run fxotune from span_config:
* Use fxotune -b/-e options to run on wanted channel range
2013-11-24 16:36:01 +02:00
Oron Peled c163caca00 fxotune: Now options '-b/-e' also apply with '-s'
* Now we can limit fxotune "set" mode to specific channel range.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:35:10 +02:00
Oron Peled c9e8ec7499 dahdi.rules: use tools_rootdir from driver
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:30:49 +02:00
Oron Peled 1356a55d77 span_types: fix for white-space in hardware_id
* Sanitize hardware_id/location attributes, just like span_assignments
* Allow control of keys via SPAN_ASSIGNMENTS_KEY or '-k <key>' option
* In general, import most features/options from span_assignments

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:22:58 +02:00
Oron Peled 10a6622774 udev scripts now read /etc/dahdi/init.conf
Added two override variables in init.conf:
* DAHDI_UDEV_DISABLE_DEVICES
* DAHDI_UDEV_DISABLE_SPANS

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:20:08 +02:00
Oron Peled a4217f6977 sysfs: restored legacy names /etc/dahdi/<channo>:
Update dahdi.rules to create again the old fashioned device files
(/dev/dahdi/<channo>), but as symlinks to modern names.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:17:35 +02:00
Oron Peled fb1a2b5572 added udev rules and their install target:
* Added missing Makefile install rule for dahdi.rules
* Pulled xpp.rules from dahdi-linux and added install rules for it

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:16:33 +02:00
Oron Peled 6d10525863 pinned-spans: remove '--enable-pinned' from configure
pinned-spans utilities are now essential:
* Called by udev rules
* Called by dahdi_genconf

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:13:51 +02:00
Oron Peled a1d4355c20 pinned-spans: fix examples in configuration files
* Correctly use the new "location" attribute
* Document the possibility to match against sysfs devpath
  (used to be the "location")

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:08:31 +02:00
Oron Peled b303802658 pinned-spans: fix configuration file names
* Install them as *.conf.sample -- that's what they are
* Correctly rename spantype.conf to span-types.conf (new name)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-11-24 16:05:11 +02:00
Shaun Ruffell 8d9a6bdd80 dahdi_genconf: Do not fail if pinned/assigned span utilities were not installed.
If you installed dahdi tools and did not specify DAHDI_PINNED=yes on the
makefile, when you run dahdi_genconf you would get an error like the following:

  # dahdi_genconf
  sh: span_types: command not found
  Command failed (status=32512): 'span_types dumpconfig > /etc/dahdi/span-types.conf' at ...

This change allows the generator for span-types.conf and span-assignements.conf
check for the existence of the utilities before attempting to call them.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2013-11-22 11:12:12 -06:00
Shaun Ruffell bb19620c52 wcte43x: Teach tools about the wcte43x driver.
Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2013-11-11 15:40:11 -06:00
Shaun Ruffell 11310bde53 wcaxx: Teach tools about the wcaxx driver.
Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2013-11-11 15:39:51 -06:00
Tzafrir Cohen b123bc87dd xpp_fxloader: support loading AB with ID > 201
Support loading firmware for Astribanks with bcdDevice > 2.01, as we'll
have 2.02 soon.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-21 16:55:18 +03:00
Oron Peled 299d9d9d9c fix typos in man-page
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-14 15:45:21 +03:00
Tzafrir Cohen 5e30a1401f Man pages for span_types and span_assignments
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-13 23:28:46 +03:00
Tzafrir Cohen 2f688f83c4 Remove dahdi_map, obsoleted by span_assignments
dahdi_map can be replaced by span_assignments list / dumpconfig

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-13 11:03:00 -04:00
Oron Peled 680f3e1d1d dahdi_registration: adapt to pinned-spans
* If xpp.dahdi_autoreg parameter is 'Y' -- Skip actuall registration.
* If dahdi.auto_assign_spans is '0' and there's no /etc/dahdi/pinned-spans.conf
  Than use 'span_assignments auto ...' to assign device spans.
* Since dahdi_registration iterate in correct xpp_order, the span
  assignment logic provides migration path for users who did not
  generate their pinned-spans.conf configuration yet.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-13 11:02:47 -04:00
Oron Peled 60fca920bc span_assignments: -k / --keys and more
* New functionality (documented in the script header):
  - Alternative "keys" for device matching
  - Added new command line options: --help, --dry-run, --verbose, --key

* Clean sysfs attribute contents from special characters in every use-case.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-13 11:01:56 -04:00
Tzafrir Cohen c1e016fa33 Do the Right Thing when there's no config
Do the "right thing" (hopefully. At least for a system with a single
device) if there is are no configuration files:

* No span-types.conf: just ignore it as before. It is optional.
* No pinned-spans.conf: use span_assignments auto (same as having
  dahdi.auto_assign_spans=1).
* No system.conf: generate a temporary one with dahdi_genconf.

This will hopefully allow having a partially-working system, and help
making ut usable with 'span_assignments dumpconfig'. Or maybe just work
as-is.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-13 10:18:34 -04:00
Oron Peled dc5c7de9fc dahdi_cfg: can optionally read config from stdin
Allow for the convention of '-' marking stdin:

  dahdi_cfg -c -

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-08 10:05:09 -04:00
Oron Peled 1e81ed14cf Augment dahdi_genconf default generators list
Run Add spantypes and pinnedspans generators by default.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-01 22:01:35 +03:00
Oron Peled 44a5285454 add new dahdi_genconf generators
* pinnedspas: For /etc/dahdi/pinned-spans.conf
* spantypes: For /etc/dahdi/span-types.conf

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-01 21:58:04 +03:00
Oron Peled 7a1e222309 remove unused dahdi_cfg_device_args
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-01 21:57:42 +03:00
Tzafrir Cohen 52488d66fa handle_device: don't fail if no config files
Allow the udev rule to work well even if there's no span-types.conf

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-01 21:56:47 +03:00
Oron Peled 00af777a97 Newer version of DAHDI hotplug scripts
A newer version of the scripts fully adapted to pinned spans:
* handle_device does not run dahdi_cfg.
* A separate UDEV rule script for that: span_config. Should also work
  for the non-pinned case.
* span_assignments, span_types: add actions 'auto' (manually enable all)
  and 'dumpconfig' (dump current status in the format of configuration
  file).
* Fixed name of span_types and span_assignments (no '-').
* spantype.conf renamed span-types.conf: configuration files do have a
  dash.
* Those two are useful programs, insstalled to /usr/sbin.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
2013-10-01 21:51:46 +03:00
Shaun Ruffell 025985d9b7 build_tools/make_version: Teach version string about git.
This copies in the make_version script from DAHDI-Linux to allow the version to
be properly reported from builds in git checkouts.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-06-26 16:45:03 -05:00
Russ Meyerriecks 2380c99c5f Add support for Digium's new te13x line of cards
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-28 17:06:10 -05:00
Shaun Ruffell 8b493f5ee2 fxotune: Use DAHDI_SPECIFY when opening by integer channel number.
In DAHDI-Linux 2.7 the layout of the /dev/dahdi files changes so that they are
grouped by span. When opening channels by number all utilities need to use
DAHDI_SPECIFY now.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-28 15:17:28 -05:00
Shaun Ruffell 2889d6afee dahdi_cfg: Make -S option based on spannumber instead of order in config file.
If the config file has two spans defined:

  span=1,1,0,esf,b8zs
  bchan=1-23
  dchan=24
  echocanceller=mg2,1-23
  span=2,2,0,esf,b8zs
  bchan=25-47
  dchan=48

And you only want to configure span-2, you would need to pass -S 1 to
dahdi_cfg. Now make the -S option take the span number as assigned in the
config file.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-28 12:34:03 -05:00
Shaun Ruffell 7939579d9e fxstest: Use DAHDI_SPECIFY when opening by integer channel number.
In DAHDI-Linux 2.7 the layout of the /dev/dahdi files changes so that they are
grouped by span. When opening channels by number all utilities need to use
DAHDI_SPECIFY now.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-28 12:34:03 -05:00
Tzafrir Cohen bab1ac48f5 Update the configure script as well.
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-24 16:58:15 -05:00
Tzafrir Cohen 3d1fd71af2 optionally install pinned files: --enable-pinned
Add installation of the pinned-spans support to the Makefile. For the
moment, however, they are not installed unless you use ./configure
--enable-pinned or build with 'make DAHDI_PINNED=yes'

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-24 16:58:15 -05:00
Oron Peled ba3289ac9a Make udev run dahdi_cfg on each device:
* New script: dahdi_cfg_device_args:
   - Just like span_assignments, span_types: may be given
     one or more sysfs devpath's
   - Output the required options for dahdi_cfg. E.g:
       "-S 8 -C 15-28"
   - This may be passed (with any other wanted options)
     to the new dahdi_cfg (which supports '-S' and '-C')

 * Use dahdi_cfg_device_args in handle_device so we configure
   each span from udev.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-24 16:58:15 -05:00
Oron Peled 79fff3e278 basic user-space for pinned-spans
handle_device is the basic script intended to be called from udev.

It will call span_types on the span to apply optional
/etc/dahdi/spantype.conf onfiguration settings that need to be applied
before assignment (currently "pri" port types: E1/T1/J1).

Next it assigns span numbers to spans: if configured in
/etc/dahdi/pinned-spans.conf - use those settings. If not: by the order
of loading.

span_types and span_assignments can also be used to report the settings
they are used to configure.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-24 16:58:15 -05:00
Tzafrir Cohen de23ca9c1a Don't fail init script if no modules
No point in loading the modules if nobody built them yet. It is a common
case for one to install the userspace tools package but not (yet?) build
the modules. See, e.g.  http://bugs.debian.org/706046 .

With this changeset, we exit gracefully in such a case.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-23 17:16:27 -05:00
Tzafrir Cohen 1f26e30907 Ignore generated files
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-05-23 17:16:27 -05:00
Shaun Ruffell 17027df04b dahdi_scan: Support gaps in channel numbering.
If, via the sysfs attributed introduced in DAHDI-Linux 2.5.0, a user has
configured spans that do not have contiguous channel numbers, dahdi_scan will
not print several of the span attributes in addition to a bad basechan number.

This patch allows dahdi_scan to try and get the basechan for a span from sysfs
as opposed to calculating based on the number of channels in the previous span
scanned.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
2013-04-16 23:25:28 -05:00
Russ Meyerriecks eacc071afe xpp: Fix compile error with fedora 17
One line change to re-include a missing header

Reported-By: Anthony Messina
Internal-Issue-ID: DAHTOOL-60
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
2013-03-13 14:36:42 -05:00
Russ Meyerriecks b8d8cc4f8d menuselect: Remove last bits completely from the repo
menuselect has not been used in dahdi-tools since r10411 (7 months ago). This
patch removes menuselect from the repository completely.

Reported-by: Sean Bright
Internal-Issue-ID: DAHTOOL-61
Patches: kill-menuselect.patch by Sean Bright (license #5060)

Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>



git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10721 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-21 19:43:49 +00:00
Russ Meyerriecks 79ed81f9f5 dahdi-monitor: Fix broken control-C behavior and -F output option
After hitting control-C when writing a wav file, dahdi_monitor reports
"Failed to read in a full wav header. Expect bad things."

Also when using the -F output option, the wav header is not written.

Reported-by: Richard Miller
Internal-Issue-ID: DAHTOOL-59
Patch: dahdi_monitor.diff by Richard Miller (license #5685)
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10717 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-21 17:25:48 +00:00
Tzafrir Cohen 3114b89905 xpp: add missing include
git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10715 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-20 13:46:23 +00:00
Oron Peled 44eb7cbb2a dahdi-tools: xpp: cleanup dead code in xtalk
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10714 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-20 13:45:06 +00:00
Oron Peled 8b7c731fb6 xtalk: checkpatch clean (almost)
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

Origin: Xorcom xtalk (r10638)

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10713 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-20 13:43:41 +00:00
Oron Peled b440b2da8c xtalk: Demote one ERR() to DBG()
(caller should decide on policy)

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

Origin: Xorcom xtalk (r9304)

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10712 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-20 13:41:00 +00:00
Oron Peled ec71fef275 xtalk: Caller passes xusb_spec to xusb_find_iface()
* This xusb_spec:
  - Is a dummy struct used for this xusb instance only.
  - Is now passed by reference from caller.
  - So caller now manage the life cycle of this struct
* Also, demote one INFO() to DBG() (library should not print
  on its own)
* Also minor fix to DBG() output of spec initialization (leading 0)

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

Origin: Xorcom xtalk (r9303)

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10711 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-20 13:40:40 +00:00
Oron Peled 99ebb2a94c xtalk: allow dump_packet() without debug flags
xtalk: dump_packet() may now be used without debug flags by passing
mask == 0.

Origin: Xorcom xtalk (r9302)

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10710 17933a7a-c749-41c5-a318-cba88f637d49
2012-09-20 13:38:39 +00:00
Tzafrir Cohen 241e5e0144 README.Astribank: load module => module load
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10701 17933a7a-c749-41c5-a318-cba88f637d49
2012-07-29 11:31:39 +00:00
Shaun Ruffell 6e3da02523 dahdi_hardware: Detect the Digium TE820 card.
Adding the TE820 vendor and device ID into PCI.pm allows dahdi_hardware to
recognize the card.

Reported-by: Xavier Hienne
Internal-Issue-ID: DAHTOOL-58
Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10680 17933a7a-c749-41c5-a318-cba88f637d49
2012-05-14 16:11:06 +00:00
Shaun Ruffell 4873299399 blacklist: Add hfcmulti, hfcpci, and netjet.
If DAHDI is installed the vast majority of users will most likely not want
hfcmulti, hfcpci, or netjet loaded since they may conflict with DAHDI drivers
for the TDM400, B410P, and TE11XP cards.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10601 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-28 16:35:23 +00:00
Oron Peled 4c7786a696 xpp: astribank_hook: wait for udev to settle
When running the astribank_hook (only on Astribanks, in XPP_HOTPLUG_DAHDI
mode), wait for all other Astribanks to create all the required device
files.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10585 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-22 17:38:57 +00:00
Tzafrir Cohen 88818f66cb xpp: astribank_allow: useless debug on write
Remove a useless debug message in the "write" operation.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10549 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-20 10:43:00 +00:00
Tzafrir Cohen 617f45c795 xpp: fix build warnings
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10543 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-19 16:57:24 +00:00
Tzafrir Cohen 3d32d63163 xpp: oct612x: fix build warnings
git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10542 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-19 16:45:40 +00:00
Oron Peled cb4eae0e42 xpp: add forgotten include
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10506 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:46:48 +00:00
Oron Peled eff70f98dc xpp: Update product ID's in Dahdi::Hardware::USB
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10505 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:46:27 +00:00
Oron Peled 65066704be xpp: clobber fpga_load
* It was replaced long ago by astribank_hexload/astribank_tool/astribank_allow
* It hasn't been used for several releases now, nor updated.
* Time to move into the eternal bit-bucket.
* Left (very) few strings as a tribute...

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10504 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:45:57 +00:00
Oron Peled be70b5b347 xpp: fix manpage of astribank_hexload
* Fixed 'astribanks_tool' string

Signed-off-by: Oron Peled <oron.peled@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10503 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:45:36 +00:00
Oron Peled 5a123a50e5 xpp: Customizable license markers
* License strings markers (BEGIN.../END...) can be customized
* By default, generate a "generic" license markers
* We accept any (paired) markers from the valid list


Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10502 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:43:57 +00:00
Oron Peled d8213d2adf xpp: Add info to astribank_tool -Q
* In MPP serial protocol add support for SER_STAT_GET command
* Use it to query firmware for:
  - FPGA build configuration number (1 - old main, 2 - new main)
  - Watchdog timer state bit (ready/expired)
  - XPD Alive timer state bit (yes/no)
* Also cleanup the code in mpps_card_info():
  - In all MPP serial commands the send/recive buffers must
    have identical size
  - No need to alias struct pointers to byte-buffers, just use
    the structs themselves as buffers.


Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10501 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:43:18 +00:00
Oron Peled 273230b044 xpp: echo_loader: whitespace cleanup
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10500 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:42:56 +00:00
Oron Peled bccb264100 xpp: bugfix: handle echo_loader errors
* I/O errors of the device were not propagated up by echo_loader
* As a result, Octasic load failure did not prevented USB renumeration
* Make consistent return values:
  - In our functions: ret < 0 is error
  - In Octasic functions (UINT32): return Octasic error codes
* All error paths prints error messages (so we see how the error propagates)
* Also changed error order testing in init_octasic():
  Return status should be tested before the values of by-reference parameters


Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10499 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:42:33 +00:00
Oron Peled d7e24fde01 xpp: echo_loader.c: add AB id to messages
* Define new macros AB_INFO(), AB_ERR() that prefix their message
  with the astribank information (usb device + serial number)
* Replace all INFO()/ERR() messages in echo_loader.c with the new macros


Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10498 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:42:10 +00:00
Oron Peled 3d59ece9b6 improve build_tools/dump_sys_state
* Use the new dahdi_sysfs_copy script
* Clean old/unused code
* Add notification output
* Now always creates a tarball - the gzipped copy is many times smaller.
* Without arguments, tarball name is:
    sys_dump.<hostname>_<date>_<time>.tar.gz


Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10497 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:41:49 +00:00
Oron Peled d11559e143 new build_tools/dahdi_sysfs_copy
Short perl script to copy dahdi related sysfs trees
into a designated directory.


Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10496 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:40:52 +00:00
Oron Peled 9b96dab2c0 xpp: xpp_fxloader: improve output
* Replaced (almost) all $LOGGER to echo:
  - In interactive use -- that what we want anyway
  - When called from UDEV, the subprocess stdout/stderr is piped to
    $LOGGER anyway (at the end of the script)
  - No need for many $LOGGER instances (each with its own pid)


Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10495 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:36:33 +00:00
Oron Peled 3572bb5a13 xpp: sysfs access cleanups
With /proc/xpp code removed, some cleanup can be done.

* No need to search alternative attribute names, so xbus_attr_path() is
  redundant.

* Don't compose xbus sysfs directory in multiple code locations.
  Do it once in Xbus->new() and use the result ($xbus->sysfs_dir)

* Pass XPD directory strings directly to Xpd->new()
  - So we parse it for unit/subunit only in Xpd->new()

* Don't parse xbus sysfs name:
  - Toplevel scan, pass it as is to Xbus->new()
  - Xbus->new() deduce the xbus->num from the naming
    of Xpd's inside (nnⓂ️k) -- this is a hack until
    we add xbus number as an xbus sysfs attribute

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10494 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:32:27 +00:00
Oron Peled 6027d2d1d1 xpp: perl_modules: Remove /proc/xpp usage
* All references to old /proc/xpp interface were removed.
* Everything is now done via sysfs

Information has been available from /sys/bus/astribanks since before
Dahdi-linux 2.2 .

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10492 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:30:41 +00:00
Oron Peled 971a45a807 xpp: clean 'Extrainfo' EEPROM field
* Extrainfo field contains junk data
* Caused by:
  - The field is initialized to 0xFF values
  - There was no null termination (and no room to add it)
* New code:
  - Ensure that show_extrainfo() have null termination even if EEPROM
    field is full.
  - Replace trailing 0xFF characters with '\0' when reading this field
  - Since our default burned EEPROM contain Extrainfo field full of
    0xFF characters, this would make them look as null filled.

Internal Issue-Id: #1341
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10491 17933a7a-c749-41c5-a318-cba88f637d49
2012-03-15 20:29:09 +00:00
Oron Peled 949ea4ca9f xpp: improved waitfor_xpds
* Fix an issue due to long firmware load time:
  - When one Astribank has an echo canceler (long firmware loading) and
    and another one does not.
  - The EC-less Astribank finishes initialization before the Astribank
    with EC is detected.
  - Thus waitfor_xpds terminates too early.

* We now iteratively build two sets of serial numbers:
  - One from wha we see in all Xorcom (e4e4:11[3456]x) USB devices.
  - The other is those that were detected in the driver.
  - Only when the two sets are equal (and > 0) we know we are done.
  - This is resilient to many problems (e.g: disconnect/reconnect of
    same device during initialization).

* The progress output was also improved: Now each detected AB
  show the total number so far.

* The timeout was also increased to 100sec

* Woraround for an Astribank with no serial (but just a single one on
  the system).

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10465 17933a7a-c749-41c5-a318-cba88f637d49
2012-02-22 18:13:02 +00:00
Tzafrir Cohen ead0cfa9bd Disable menuselect in dahdi-tools
* Remove targets from the Makefile
* report PBX_HDLC in makeopts
* Only build sethdlc is PBX_HDLC is 1
* Only build dahdi_tool is PBX_NEWT is 1
* fxstest and dahdi_diag are not included in the default target

For now the only way to manually disable building a certain tool
is by changing the value of BINS in Makefile.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10411 17933a7a-c749-41c5-a318-cba88f637d49
2012-01-08 18:24:13 +00:00
Tzafrir Cohen dfa7a08ba3 xpp: two extra product IDs: 1112, 1164
Two extra USB product IDs used in some odd maintenance scenarios.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10368 17933a7a-c749-41c5-a318-cba88f637d49
2011-12-04 17:08:29 +00:00
Tzafrir Cohen 32b715d373 xpp: xpp_fxloader: regressions from r10348
* Avoid a duplicated run of udev on some systems.
* Fix usage of astribank_tool's output.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10366 17933a7a-c749-41c5-a318-cba88f637d49
2011-12-04 15:33:21 +00:00
Tzafrir Cohen 03c0afef41 DAHDI-perl: Fix PCI ID for Rhino R4T1 (0b0b:0305)
(Closes issue DAHTOOL-56)

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10358 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-30 20:15:33 +00:00
Tzafrir Cohen 1b9a64e43b xpp: recovery firmware in xpp_fxloader
USB_RECOV.hex is an extra firmware that may be useful for recovering
from certain Astribank hardware faults in some scenarios. This adds
support for either loading it manually
('/usr/share/dahdi/xpp_fxloader recover-sb') or through udev, *if*
the required udev rules were set on the system.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10349 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-29 23:40:50 +00:00
Tzafrir Cohen e6c2b1850d xpp: Serialized Parallel load; E-Main-3 firmware
This introduces support for loading multiple firmwares in parallel also
for the case of a manual load. This is anyway the case for an automatic
load from udev.

* libusb needs to scan the bus all too often. This causes occasional
  failures for opening devices.
* Thus introduce a semaphore to serialize uses of libusb.

E-Main-3 firmware differs by a different value of bcdDevice:

* Read this from the sysfs devices tree.
* Fall back to lsusb -v (much slower) is sysfs not available.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10348 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-29 23:40:21 +00:00
Tzafrir Cohen 29280a548c xpp: astribank_hexload: we need more lines
* Newer firmwares may have more lines.
* While we're at it, add better debug printing.
* Remove some unused debugging code.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10343 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-21 15:25:43 +00:00
Tzafrir Cohen b093554f54 Fix GCC 4.6 "set but not used" warnings
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10311 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-02 21:57:25 +00:00
Shaun Ruffell bc6250fe1f dahdi_genconf: Allow it to recognize the TE8xx 8-port cards.
Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10308 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-02 20:55:52 +00:00
Oron Peled ba070152fc dahdi_cfg: add '-S <spanno>' and '-C <chan-ranges>'
* dahdi_cfg -S <num>: only apply changes to span <num>.
* If span is analog (no 'span=<num>,<channels>,...' statement in
  system.conf), we need to set range: -C <channels>
* With the <basechan> and <channels> attributes in sysfs
  we easily configure each device on the fly.
  Simply run: dahdi_cfg -S <spanno> -C <basechan>+<channels>-1
  from udev script

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10306 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-02 20:10:06 +00:00
Torrey Searle 541435eac7 dahdi_pcap: Imported user space utility for managing pcap streams
This utility will export packet captures for channels in dahdi. It requires
CONFIG_DAHDI_MIRROR to be defined in dahdi-linux as it uses the unsupported
DAHDI_MIRROR ioctl interface.

Internal-Issue-ID: DAHTOOL-49
From: Torrey Searle <tsearle@gmail.com>
Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10293 17933a7a-c749-41c5-a318-cba88f637d49
2011-11-01 18:10:14 +00:00
Tzafrir Cohen 2457399d92 dahdi_perl: Use $Dahdi::sys_base for sysfs pathes
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10267 17933a7a-c749-41c5-a318-cba88f637d49
2011-10-23 14:43:27 +00:00
Tzafrir Cohen a81a43c9b6 xpp_order generator: ignore EC XPD
The xpp_order configuration generator should only loop over telephony
devices, not all spans.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10266 17933a7a-c749-41c5-a318-cba88f637d49
2011-10-23 14:28:40 +00:00
Tzafrir Cohen 5efd590aef chandahdi gen: extens can have any num of digits
Don't force extens we generate to have exactly 4 digits (simple
formatting limitation).

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10265 17933a7a-c749-41c5-a318-cba88f637d49
2011-10-23 14:23:17 +00:00
Tzafrir Cohen 1e21cb1356 Typos in man pages: toolyou
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10264 17933a7a-c749-41c5-a318-cba88f637d49
2011-10-23 14:22:05 +00:00
Shaun Ruffell 78584da122 dahdi_test: Enforce range from 0.0% - 100.0% for accuracy.
Also makes sure that the percentage output from the verbose and
non-verbose modes of timer_test are the same and print a cumulative
accuracy which smooths out the jitter for each pass.

If the time it takes to read in 1 second worth of data is longer than 1
second  accuracy will be 0%.

(closes issue #18573)
Reported by: smurfix

Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10216 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-29 17:00:59 +00:00
Shaun Ruffell cbb0252a6a dahdi_maint: Print 'unsupported' warning if framing errors is -1.
Warn the user if attempting to monitor a statistic that the particular
board driver does not appear to be collecting. The wcte12xp in r10212 in
now fills in -1 for any statistic it does not collect and other digital
cards can do the same.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Russ Meyerriecks <rmeyerriecks@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10215 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-29 17:00:55 +00:00
Shaun Ruffell 250bc06238 dahdi_genconf: Use 'dahdi_scan' to determine span_type for B410P cards.
The wcb4xxp driver does not put enough information in the proc filesystem to
determine if the ports are in TE or NT mode.  Previously the ports would
always just setup the dahdi-channels.conf file in TE mode. After this change
the dahdi_scan utility is used to detect if the ports are in TE or NT mode and
setup dahdi-channels.conf appropriately.

Internal-Issue-ID: DAHTOOL-54
Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10214 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-29 17:00:51 +00:00
Shaun Ruffell db9b649e03 dahdi_genconf: Assume spans with unknown term types are software selectable.
Resolves a regression on the 2.5 branch that would result in:

  $ dahdi_genconf
  dahdi_genconf: missing default group (termtype=UNKNOWN)

E1 / T1 spans use software configuration to set CPE / NET mode. This
patch will just assume that a termtype is software selectable if it was
"UNKNOWN" when first scanning the span.

Internal-Issue-ID: DAHTOOL-55
Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Tested-by: David Purdue <support@noojee.com.au>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10213 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-29 17:00:46 +00:00
Tzafrir Cohen 2d576dcea0 Man page for dahdi_maint
Fix dahdi_maint's usage message while we're at it.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10198 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-09 13:45:00 +00:00
Tzafrir Cohen b487a96ada Update the dahdi-monitor man page
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10196 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-09 12:04:34 +00:00
Tzafrir Cohen 67cc13f100 fix typos in some xpp utils
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10194 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-09 10:59:39 +00:00
Tzafrir Cohen 3482a25b84 xpp: waitfor_xpds: higher and configurable timeout
On several pathological cases we may need to wait more than 40 seconds.
Make that timeout configurable.

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10177 17933a7a-c749-41c5-a318-cba88f637d49
2011-09-05 09:05:48 +00:00
Oron Peled b23f3ca5a9 dahdi-perl: Also get USB loaded driver from usbfs
Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10153 17933a7a-c749-41c5-a318-cba88f637d49
2011-08-25 10:32:17 +00:00
Tzafrir Cohen a5c6e58b6e dahdi-perl: Freepbxdb config generator
Use 'dahdi_genconf freepbxdb' to generate the required astdb entries
for Asterisk to use the extensions generated by dahdi_genconf. Requires
asterisk to be running.

This module is intended for testing as it bypasses standard FreePBX
functions only and hence may not work properly with Freepbx.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10142 17933a7a-c749-41c5-a318-cba88f637d49
2011-08-18 15:38:45 +00:00
Tzafrir Cohen 12492f4e23 README.Astribank: HWEC and build instructions
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10104 17933a7a-c749-41c5-a318-cba88f637d49
2011-08-10 15:31:22 +00:00
Tzafrir Cohen 2061c6c359 xpp: pri_termtype: match complete SPAN patterns
Match complete span patterns, to avoid pattern 'SPAN/1' from matching
e.g. span 12 (SPAN/12).

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10101 17933a7a-c749-41c5-a318-cba88f637d49
2011-08-09 13:11:20 +00:00
Tzafrir Cohen bad2f86c11 Extra README fixes: 'th' and ztcfg
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10087 17933a7a-c749-41c5-a318-cba88f637d49
2011-08-02 17:28:23 +00:00
Tzafrir Cohen 13f0f2235d spelling: ocnfig.status and such
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10085 17933a7a-c749-41c5-a318-cba88f637d49
2011-08-02 17:20:01 +00:00
Russ Meyerriecks 505621a31c patlooptest: Ignore the first buffered event
Fixes the feature introduced in r9909 that allows patlooptest to
monitor channel events. Patlooptest was reporting events that we don't
care about, prior to reading from the channel. This fix ignore the first
event read on a channel and reports all subsequent events properly.

Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10071 17933a7a-c749-41c5-a318-cba88f637d49
2011-07-21 17:29:34 +00:00
Tzafrir Cohen f2152481e9 astribank_hook: startup lock and more
* Silently exit right away if user did not set XPP_HOTPLUG_DAHDI.
* Only one Astribank should be allowed to run the startup script:
  - Protect that section with a "lock" (symlinking a file).
  - Sadly we can't rely on /run and may have to wait for a r/w file-system.
  - And thus even this waiting needs to be run in the background
    as to not hold udev.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10068 17933a7a-c749-41c5-a318-cba88f637d49
2011-07-21 13:40:18 +00:00
Shaun Ruffell caa8c947b7 Span.pm: Process the /proc/dahdi/<x> files atomically.
It is possible that the contents of the proc files can change while the
perl modules are in the processing of processing them.

Specifically, if lsdahdi is called on boot before the channels are
configured, the channel will be "probed" to determine if it's an FXO or
FXS channel and that can result in the output of proc changing. When the
size of proc changes, the script can get confused about where the
beginning of the next line is.

This patch reads in the proc file completely into memory first, and then
starts processing each of the lines.

This resolves the "Unrecognized garbage 'INACTIVE)' in -" that is
displayed on boot with the recent trunk of DAHDI.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10040 17933a7a-c749-41c5-a318-cba88f637d49
2011-07-12 23:01:02 +00:00
Tzafrir Cohen b4aa63049f xpp: astribank_hexload: yes, we HAVE_OCTASIC
Hardwire this for now, as this does not come from autoconf.

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10034 17933a7a-c749-41c5-a318-cba88f637d49
2011-07-11 18:02:29 +00:00
Tzafrir Cohen ccd13cfd47 xpp: support loading Octasic EC firmware
Echo Cancellation firmware is loaded by xpp/stribank_hexload
(Using the oct612x code).

* astribank_hexload: options -O/-o/-A for handling the Octasic echo
  cancellation firmware.
* astribank_tool: report that.
* xpp_fxloader: Run astribank_hexload, if needed.
* dahdi_perl: The EC module is an extra XPD, but not a "telephony device"
  and hence not a span. Deal with that.
* waitfor_xpds: may need to wait a bit longer for firmware loading.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10032 17933a7a-c749-41c5-a318-cba88f637d49
2011-07-10 16:25:18 +00:00
Tzafrir Cohen d3cadf5352 xpp: A copy of oct612x in dahdi-tools
Include a copy of the oct612x Octasic echo canceller interface to be used
by astribank_hexload to load the echo canceller firmware to a Xorcom
Astribank.


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10030 17933a7a-c749-41c5-a318-cba88f637d49
2011-07-10 16:10:32 +00:00
Shaun Ruffell 52b37fa5f1 system.conf.sample: Add note regarding cross connecting spans on B410P.
There is an issue with the hardware on the B410P that makes it unreliable to
connect one of the ports to another port for testing.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10026 17933a7a-c749-41c5-a318-cba88f637d49
2011-07-05 20:13:49 +00:00
Tzafrir Cohen 9ae57618d3 fix registration order for more than 9 Astribanks
The sorting function for SORT_XPPORDER accidentally sorted the Astribank
priorities from the xpp_order file (/etc/dahdi/xpp_order) lexicographically
instead of numerically, that is: 10 before 2.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9986 17933a7a-c749-41c5-a318-cba88f637d49
2011-06-23 17:33:43 +00:00
Tzafrir Cohen f46df849da dahdi_genconf: apply termtype to Digium HA8 BRI
Make the pri_termtype setting in genconf_parameters apply to any BRI/PRI
carddeclared as "soft NT". ATM, this is only the Xorcom E1/T1 device
and the Digium HA8 (BRI) module of the TDM card.

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9979 17933a7a-c749-41c5-a318-cba88f637d49
2011-06-16 09:35:32 +00:00
Kinsey Moore 178ae27825 tools: Allow pattern tools to access channels above the device file limit
pattest and patgen already had this capability, but there were cases in which
they would act unexpectedly.  Now, if the name specified is not a character
device file, it will be treated as a channel number if possible.

Acked-by: Shaun Ruffell <sruffell@digium.com>


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9975 17933a7a-c749-41c5-a318-cba88f637d49
2011-06-07 19:44:34 +00:00
Tzafrir Cohen 49a5fbfcd2 xpp: this is the right place for astribank_close()
git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9973 17933a7a-c749-41c5-a318-cba88f637d49
2011-06-07 10:28:31 +00:00
Shaun Ruffell 24015f717e zonedata: Add support for United Arab Emirates.
This was provided for interop with analog lines provided by Etisilat.

DAHDI-796.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9920 17933a7a-c749-41c5-a318-cba88f637d49
2011-05-24 15:14:32 +00:00
Shaun Ruffell 29a06509ec zonedata: Add support for Costa Rica.
Add in the costa Rica zonedata.

(closes issue #19069)
Reported by: desafiocostarica

Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9919 17933a7a-c749-41c5-a318-cba88f637d49
2011-05-24 15:14:25 +00:00
Kinsey Moore 4c177ef39c tools: Allow patlooptest to activate and handle buffer events
The new buffer events code introduced in revision 9905 gives userspace
processes an interface to activate detection of buffer over and underflows.
This change allows patlooptest to take advantage of that feature to better
inform users of the cause of pattern errors.

Acked-by: Shaun Ruffell <sruffell@digium.com>
(original patch by Matt Fredrickson)


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9909 17933a7a-c749-41c5-a318-cba88f637d49
2011-04-18 21:20:10 +00:00
Tzafrir Cohen ad02c5b314 astribank_is_starting.c: do have timeout (typo)
Due to a typo the option for not using a timeout was always used.

Regression since r9426.

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9831 17933a7a-c749-41c5-a318-cba88f637d49
2011-03-16 14:32:27 +00:00
Tzafrir Cohen ed3da234d7 dahdi.init: LSB short description
git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9830 17933a7a-c749-41c5-a318-cba88f637d49
2011-03-16 14:23:09 +00:00
Oron Peled 1c1fe1fd94 xpp: use 'xtalk' for the USB access code
* Move most of the USB access code from xpp/ to xpp/xtalk/ .
* astribank_tool and such tools can now use a shorter -D mmm/nnn rather
  than a full path.

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9825 17933a7a-c749-41c5-a318-cba88f637d49
2011-03-10 18:48:11 +00:00
Tzafrir Cohen 366eccb556 dahdi-perl: more left-over $span->xpd
Replace the remaining $span->xpd with xpd_of_span().

Following up on r9648.

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9731 17933a7a-c749-41c5-a318-cba88f637d49
2011-02-06 18:39:57 +00:00
Tzafrir Cohen d765176efd dahdi-perl: fix xpp driver in dahdi_hardware
Don't require 'dahdi_hardware -v' to show the driver for a USB device.
Only works when the usbfs is not used (when /proc/bus/usb is not mounted).

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9699 17933a7a-c749-41c5-a318-cba88f637d49
2011-01-25 10:11:36 +00:00
Tzafrir Cohen fae45054b1 dahdi-perl: left-over $span->xpd
Replace one remaining $span->{XPD} with xpd_of_span().

Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9648 17933a7a-c749-41c5-a318-cba88f637d49
2011-01-20 18:06:38 +00:00
Kinsey Moore 249baf1db3 README, UPGRADE.txt, system.conf.sample: Add documentation for using HWEC
Update documentation to the effect that HWEC is not enabled by default
and must be enabled manually if desired via "echocanceller" in system.conf.


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9528 17933a7a-c749-41c5-a318-cba88f637d49
2010-12-09 22:44:52 +00:00
Russ Meyerriecks d3d246b656 dahdi_maint: Added the loopup/loopdown functionality
Put back in the loopup and loopdown functionality which had been removed
from dahdi_tool

According to the spec AT&T TR 54016 we should keep the loopback
actuate and release signals on the line for 5 seconds.

Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
Acked-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9517 17933a7a-c749-41c5-a318-cba88f637d49
2010-12-08 22:14:29 +00:00
Jason Parker 3f57781f6e Add 'install-tests' Makefile target.
Acked-by: Shaun Ruffell <sruffell@digium.com>


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9499 17933a7a-c749-41c5-a318-cba88f637d49
2010-11-29 17:53:50 +00:00
Kinsey Moore 88035ea78c dahdi_genconf: Don't generate configurations that use channel 16 on E1 CAS
Attempting to use channel 16 on E1 CAS is disallowed since that channel is
reserved for RBS signaling.  Configurations should not be generated that
attempt to use it.

Closes DAHDI-763.

Patch by dmartinez.


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9485 17933a7a-c749-41c5-a318-cba88f637d49
2010-11-17 15:32:52 +00:00
Tzafrir Cohen e38b85fde9 xpp_fxloader: Don't try to load FPGA firmware twice
When called from udev to load the FPGA firmware, make sure that this is
not the event generated for the first end-point of the existing two, as
we need to talk with the second one.

This is probably better done in the udev rules, but will be slightly
more complicated to apply only to the FPGA loading and not to USB
firmware loading.


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9482 17933a7a-c749-41c5-a318-cba88f637d49
2010-11-16 10:56:54 +00:00
Russ Meyerriecks 55a9fd2da2 dahdi_maint: Minor name change for the error counters
Make the error counters a little more readable, removed the prbs
counters since they are not currently functioning

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9477 17933a7a-c749-41c5-a318-cba88f637d49
2010-11-11 22:32:27 +00:00
Shaun Ruffell 393aef02ef dahdi_scan: Show CAS framing on the framing line.
Also, always append "/CRC4" on any span where that was specified as an
option.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>
Acked-by: Kinsey Moore <kmoore@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9473 17933a7a-c749-41c5-a318-cba88f637d49
2010-11-10 16:19:36 +00:00
Russ Meyerriecks 3140dfc482 Fixed up the loss of crc4-multiframe alignment logic
Loss of crc4-multiframe alignment on an E1 link is not a condition which
brings the span down. The span will continue to run as long as it can
maintain double frame alignment. Because of this, we cannot place the
LMFA alarm in the usual spaninfo.alarms member, due to userspace
programs using this as a catch-all for a span being up or down.

We can detect the alarm by watching the frame error counter (fecount).
If it continuously increments, the span is configured for crc4, and the
span remains OK (alarms = 0), then we are in loss of crc4-multiframe
state.

In order to test this alarm, you'll need to synthesize a loss of crc4
alignment on the span. You can usually do this by configuring the local
span to use crc4 and the remote end to not use crc4. I used the Fireberd
6000 in my lab to do this.

dahdi-743 & dahdi-420

Acked-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9458 17933a7a-c749-41c5-a318-cba88f637d49
2010-10-25 18:58:17 +00:00
Tzafrir Cohen a3ae25141a Dahdi::Hardware: Support beroNet BN4S0e PCI Express card
Add extra PCI IDs to support "beroNet BN4S0e PCI Express 4x S0 Karte".

Origin: http://bugs.debian.org/600839


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9452 17933a7a-c749-41c5-a318-cba88f637d49
2010-10-20 18:02:35 +00:00
Tzafrir Cohen 81205b90f7 astribank_is_starting: use semop if no semtimedop
astribank_is_starting should use a timeout for the semaphore, but if the
GNU-specific semtimedop() is not available, we'll just fall back to using
semop with no time out. Not as good, but better than nothing.

(closes issue #16783)
Reported by: abelbeck


git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9426 17933a7a-c749-41c5-a318-cba88f637d49
2010-10-17 18:41:24 +00:00
Shaun Ruffell e878bc06dc dahdi_cfg: DAHDI_INDIRECT -> DAHDI_SPECIFY when configuring pciradio channels.
While slightly less efficient, this is only used when configuring the
channels initially (not the hot path) and allows dahdi-base.c to assume
that the open "file" pointer always refers to the channel on which to
perform the operation.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9352 17933a7a-c749-41c5-a318-cba88f637d49
2010-09-20 20:30:49 +00:00
Russ Meyerriecks 1462933a0d tonezone: Add Macao,China to tone zone data
Adding Macao tone zone data according to
http://www.itu.int/ITU-T/inr/forms/files/tones-0203.pdf

(closes issue #17744)
	Reported by: alfredtang
	Patches:
	      zonedata.patch uploaded by alfredtang (license 1094)

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9313 17933a7a-c749-41c5-a318-cba88f637d49
2010-09-08 22:15:22 +00:00
Shaun Ruffell 3122b143a3 dahdi.init: Remove reference to dahdi_dummy.
Module 'dahdi_dummy.ko' is no longer needed for DAHDI to provide timing,
therefore we can remove the explicit load of dahdi_dummy, which by
default is aliased to dahdi.ko anyway.  If you've edited the DAHDI
Kbuild file in order to build dahdi_dummy explicitly, then you should
add dahdi_dummy to /etc/dahdi/modules in order to load it, but this is
not needed for normal operation.

(issue #17959)
Reported by: glen201

git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@9309 17933a7a-c749-41c5-a318-cba88f637d49
2010-09-07 18:27:57 +00:00
308 changed files with 80669 additions and 48290 deletions

79
.gitignore vendored Normal file
View File

@ -0,0 +1,79 @@
*~
*.o
*.lo
*.a
*.so
*.la
.*.o.d
.*.lo.d
*.asciidoc
*.html
.deps
.libs
.dirstamp
.version
/.pc
Makefile
Makefile.in
auxdir/
build_tools/menuselect-deps
aclocal.m4
autom4te.cache/
autoconfig.h
autoconfig.h.in
config.log
config.status
config.guess
config.ignore
configure
dahdi_cfg
dahdi_diag
dahdi_maint
dahdi_monitor
dahdi_pcap
dahdi_scan
dahdi_speed
dahdi_test
dahdi_tool
fxotune
fxstest
genconf_parameters.sample
hdlcgen
hdlcstress
hdlctest
hdlcverify
libtool
m4/
makeopts
patgen
patlooptest
pattest
sethdlc
stamp-h1
timertest
tonezone.lo
tonezones.txt
version.c
xpp/*.check
xpp/.depend
xpp/.octasic.depend
xpp/.perlcheck
xpp/astribank_allow
xpp/astribank_hexload
xpp/astribank_is_starting
xpp/astribank_tool
xpp/dahdi_genconf.8
xpp/dahdi_hardware.8
xpp/dahdi_registration.8
xpp/lsdahdi.8
xpp/test_parse
xpp/twinstar.8
xpp/xpp_blink.8
xpp/xpp_sync.8
xpp/xtalk/xlist_test
xpp/xtalk/xtalk_raw_test
xpp/xtalk/xtalk_send
xpp/xtalk/xtalk_test
xpp/xtalk/xusb_test
xpp/xtalk/xusb_test_bypath
zonedata.lo

420
Makefile
View File

@ -1,420 +0,0 @@
#
# Makefile for DAHDI tools
#
# Copyright (C) 2001-2010 Digium, Inc.
#
#
# If the file .dahdi.makeopts is present in your home directory, you can
# include all of your favorite menuselect options so that every time you download
# a new version of Asterisk, you don't have to run menuselect to set them.
# The file /etc/dahdi.makeopts will also be included but can be overridden
# by the file in your home directory.
GLOBAL_MAKEOPTS=$(wildcard /etc/dahdi.makeopts)
USER_MAKEOPTS=$(wildcard ~/.dahdi.makeopts)
ifeq ($(strip $(foreach var,clean distclean dist-clean update,$(findstring $(var),$(MAKECMDGOALS)))),)
ifneq ($(wildcard menuselect.makeopts),)
include menuselect.makeopts
endif
endif
ifeq ($(strip $(foreach var,clean distclean dist-clean update,$(findstring $(var),$(MAKECMDGOALS)))),)
ifneq ($(wildcard makeopts),)
include makeopts
endif
endif
SUBDIRS_UTILS_ALL:= ppp
SUBDIRS_UTILS := xpp
OPTFLAGS=-O2
CFLAGS+=-I. $(OPTFLAGS) -g -fPIC -Wall -DBUILDING_TONEZONE #-DTONEZONE_DRIVER
ifneq (,$(findstring ppc,$(UNAME_M)))
CFLAGS+=-fsigned-char
endif
ifneq (,$(findstring x86_64,$(UNAME_M)))
CFLAGS+=-m64
endif
ifeq ($(DAHDI_DEVMODE),yes)
CFLAGS+=-Werror -Wunused -Wundef $(DAHDI_DECLARATION_AFTER_STATEMENT) -Wmissing-format-attribute -Wformat-security #-Wformat=2
endif
ROOT_PREFIX=
# extra cflags to build dependencies. Recursively expanded.
MAKE_DEPS= -MD -MT $@ -MF .$(subst /,_,$@).d -MP
CFLAGS+=$(DAHDI_INCLUDE)
CHKCONFIG := $(wildcard /sbin/chkconfig)
UPDATE_RCD := $(wildcard /usr/sbin/update-rc.d)
ifeq (,$(DESTDIR))
ifneq (,$(CHKCONFIG))
ADD_INITD := $(CHKCONFIG) --add dahdi
else
ifneq (,$(UPDATE_RCD))
ADD_INITD := $(UPDATE_RCD) dahdi defaults 15 30
endif
endif
endif
INITRD_DIR := $(firstword $(wildcard $(DESTDIR)/etc/rc.d/init.d $(DESTDIR)/etc/init.d))
ifneq (,$(INITRD_DIR))
INIT_TARGET := $(INITRD_DIR)/dahdi
COPY_INITD := install -D dahdi.init $(INIT_TARGET)
endif
RCCONF_FILE = /etc/dahdi/init.conf
MODULES_FILE = /etc/dahdi/modules
GENCONF_FILE = /etc/dahdi/genconf_parameters
MODPROBE_FILE = /etc/modprobe.d/dahdi.conf
BLACKLIST_FILE = /etc/modprobe.d/dahdi.blacklist.conf
NETSCR_DIR := $(firstword $(wildcard $(DESTDIR)/etc/sysconfig/network-scripts ))
ifneq (,$(NETSCR_DIR))
NETSCR_TARGET := $(NETSCR_DIR)/ifup-hdlc
COPY_NETSCR := install -D ifup-hdlc $(NETSCR_TARGET)
endif
ifneq ($(wildcard .version),)
TOOLSVERSION:=$(shell cat .version)
else
ifneq ($(wildcard .svn),)
TOOLSVERSION=$(shell build_tools/make_version . dahdi/tools)
endif
endif
LTZ_A:=libtonezone.a
LTZ_A_OBJS:=zonedata.o tonezone.o version.o
LTZ_SO:=libtonezone.so
LTZ_SO_OBJS:=zonedata.lo tonezone.lo version.o
LTZ_SO_MAJOR_VER:=2
LTZ_SO_MINOR_VER:=0
# sbindir, libdir, includedir and mandir are defined in makeopts
# (from configure).
BIN_DIR:=$(sbindir)
LIB_DIR:=$(libdir)
INC_DIR:=$(includedir)/dahdi
MAN_DIR:=$(mandir)/man8
CONFIG_DIR:=$(sysconfdir)/dahdi
CONFIG_FILE:=$(CONFIG_DIR)/system.conf
# Utilities we build with a standard build procedure:
UTILS = dahdi_tool dahdi_test dahdi_monitor dahdi_speed sethdlc dahdi_cfg \
fxstest fxotune dahdi_diag dahdi_scan
# some tests:
UTILS += patgen pattest patlooptest hdlcstress hdlctest hdlcgen \
hdlcverify timertest dahdi_maint
BINS:=fxotune fxstest sethdlc dahdi_cfg dahdi_diag dahdi_monitor dahdi_speed dahdi_test dahdi_scan dahdi_tool dahdi_maint
BINS:=$(filter-out $(MENUSELECT_UTILS),$(BINS))
MAN_PAGES:=$(wildcard $(BINS:%=doc/%.8))
TEST_BINS:=patgen pattest patlooptest hdlcstress hdlctest hdlcgen hdlcverify timertest dahdi_maint
# All the man pages. Not just installed ones:
GROFF_PAGES := $(wildcard doc/*.8 xpp/*.8)
GROFF_HTML := $(GROFF_PAGES:%=%.html)
GENERATED_DOCS := $(GROFF_HTML) README.html README.Astribank.html
all: menuselect.makeopts
@$(MAKE) _all
_all: prereq programs
libs: $(LTZ_SO) $(LTZ_A)
utils-subdirs:
@for dir in $(SUBDIRS_UTILS); do \
$(MAKE) -C $$dir; \
done
programs: libs utils
utils: $(BINS) utils-subdirs
version.c: FORCE
@TOOLSVERSION="${TOOLSVERSION}" build_tools/make_version_c > $@.tmp
@if cmp -s $@.tmp $@ ; then :; else \
mv $@.tmp $@ ; \
fi
@rm -f $@.tmp
tests: $(TEST_BINS)
$(UTILS): %: %.o
$(UTILS): version.o
%.o: %.c
$(CC) $(CFLAGS) $(MAKE_DEPS) -c -o $@ $<
%.lo: %.c
$(CC) $(CFLAGS) $(MAKE_DEPS) -c -o $@ $<
%: %.o
$(CC) $(LDFLAGS) $^ $(LIBS) -o $@
prereq: config.status
dahdi_tool: CFLAGS+=$(NEWT_INCLUDE)
dahdi_tool: LIBS+=$(NEWT_LIB)
dahdi_speed: CFLAGS+=-O0
$(LTZ_A): $(LTZ_A_OBJS)
ar rcs $@ $^
ranlib $@
$(LTZ_SO): $(LTZ_SO_OBJS)
$(CC) $(CFLAGS) -shared -Wl,-soname,$(LTZ_SO).$(LTZ_SO_MAJOR_VER).$(LTZ_SO_MINOR_VER) -o $@ $^ -lm
dahdi_cfg: $(LTZ_A)
dahdi_cfg: LIBS+=-lm
fxstest: $(LTZ_SO)
fxstest: LIBS+=-lm
fxotune: LIBS+=-lm
tonezones.txt: zonedata.c
perl -ne 'next unless (/\.(country|description) = *"([^"]*)/); \
print (($$1 eq "country")? "* $$2\t":"$$2\n");' $< \
>$@
%.asciidoc: %.sample
perl -n -e \
'if (/^#($$|\s)(.*)/){ if (!$$in_doc){print "\n"}; $$in_doc=1; print "$$2\n" } else { if ($$in_doc){print "\n"}; $$in_doc=0; print " $$_" }' \
$< \
| perl -p -e 'if (/^ #?(\w+)=/ && ! exists $$cfgs{$$1}){my $$cfg = $$1; $$cfgs{$$cfg} = 1; s/^/\n[[cfg_$$cfg]]\n/}' >$@
docs: $(GENERATED_DOCS)
genconf_parameters.sample: xpp/genconf_parameters
cp $< $@
README.html: README system.conf.asciidoc init.conf.asciidoc tonezones.txt \
UPGRADE.txt genconf_parameters.asciidoc
$(ASCIIDOC) -n -a toc -a toclevels=3 $<
README.Astribank.html: xpp/README.Astribank
$(ASCIIDOC) -o $@ -n -a toc -a toclevels=4 $<
# on Debian: this requires the full groof, not just groff-base.
%.8.html: %.8
man -Thtml $^ >$@
htmlman: $(GROFF_HTML)
install: all install-programs
@echo "###################################################"
@echo "###"
@echo "### DAHDI tools installed successfully."
@echo "### If you have not done so before, install init scripts with:"
@echo "###"
@echo "### make config"
@echo "###"
@echo "###################################################"
install-programs: install-utils install-libs
install-utils: utils install-utils-subdirs
ifneq (,$(BINS))
install -d $(DESTDIR)$(BIN_DIR)
install $(BINS) $(DESTDIR)$(BIN_DIR)/
install -d $(DESTDIR)$(MAN_DIR)
install -m 644 $(MAN_PAGES) $(DESTDIR)$(MAN_DIR)/
endif
ifeq (,$(wildcard $(DESTDIR)$(CONFIG_FILE)))
$(INSTALL) -d $(DESTDIR)$(CONFIG_DIR)
$(INSTALL) -m 644 system.conf.sample $(DESTDIR)$(CONFIG_FILE)
endif
install-libs: libs
$(INSTALL) -d -m 755 $(DESTDIR)/$(LIB_DIR)
$(INSTALL) -m 755 $(LTZ_A) $(DESTDIR)$(LIB_DIR)/
$(INSTALL) -m 755 $(LTZ_SO) $(DESTDIR)$(LIB_DIR)/$(LTZ_SO).$(LTZ_SO_MAJOR_VER).$(LTZ_SO_MINOR_VER)
ifeq (,$(DESTDIR))
if [ `id -u` = 0 ]; then \
/sbin/ldconfig || : ;\
fi
endif
rm -f $(DESTDIR)$(LIB_DIR)/$(LTZ_SO)
$(LN) -sf $(LTZ_SO).$(LTZ_SO_MAJOR_VER).$(LTZ_SO_MINOR_VER) \
$(DESTDIR)$(LIB_DIR)/$(LTZ_SO).$(LTZ_SO_MAJOR_VER)
$(LN) -sf $(LTZ_SO).$(LTZ_SO_MAJOR_VER).$(LTZ_SO_MINOR_VER) \
$(DESTDIR)$(LIB_DIR)/$(LTZ_SO)
# Overwrite the 1.0 links out there. dahdi-tools 2.0.0 installed
# 1.0 links but dahdi-tools changed them to 2.0 in order to explicitly
# break applications linked with zaptel. But, this also meant that
# applications linked with libtonezone.so.1.0 broke when dahdi-tools
# 2.1.0 was installed.
$(LN) -sf $(LTZ_SO).$(LTZ_SO_MAJOR_VER).$(LTZ_SO_MINOR_VER) \
$(DESTDIR)$(LIB_DIR)/$(LTZ_SO).1.0
$(LN) -sf $(LTZ_SO).$(LTZ_SO_MAJOR_VER).$(LTZ_SO_MINOR_VER) \
$(DESTDIR)$(LIB_DIR)/$(LTZ_SO).1
ifneq (no,$(USE_SELINUX))
ifeq (,$(DESTDIR))
/sbin/restorecon -v $(DESTDIR)$(LIB_DIR)/$(LTZ_SO)
endif
endif
$(INSTALL) -d -m 755 $(DESTDIR)/$(INC_DIR)
$(INSTALL) -m 644 tonezone.h $(DESTDIR)$(INC_DIR)/
install-utils-subdirs:
@for dir in $(SUBDIRS_UTILS); do \
$(MAKE) -C $$dir install; \
done
config:
ifneq (,$(COPY_INITD))
$(COPY_INITD)
endif
ifeq (,$(wildcard $(DESTDIR)$(RCCONF_FILE)))
$(INSTALL) -D -m 644 init.conf.sample $(DESTDIR)$(RCCONF_FILE)
endif
ifeq (,$(wildcard $(DESTDIR)$(MODULES_FILE)))
$(INSTALL) -D -m 644 modules.sample $(DESTDIR)$(MODULES_FILE)
endif
ifeq (,$(wildcard $(DESTDIR)$(GENCONF_FILE)))
$(INSTALL) -D -m 644 xpp/genconf_parameters $(DESTDIR)$(GENCONF_FILE)
endif
ifeq (,$(wildcard $(DESTDIR)$(MODPROBE_FILE)))
$(INSTALL) -D -m 644 modprobe.conf.sample $(DESTDIR)$(MODPROBE_FILE)
endif
ifeq (,$(wildcard $(DESTDIR)$(BLACKLIST_FILE)))
$(INSTALL) -D -m 644 blacklist.sample $(DESTDIR)$(BLACKLIST_FILE)
endif
ifneq (,$(COPY_NETSCR))
$(COPY_NETSCR)
endif
ifneq (,$(ADD_INITD))
$(ADD_INITD)
endif
@echo "DAHDI has been configured."
@echo ""
@echo "List of detected DAHDI devices:"
@echo ""
@if [ `xpp/dahdi_hardware | tee /dev/stderr | wc -l` -eq 0 ]; then \
echo "No hardware found"; \
else \
echo ""; \
echo "run 'dahdi_genconf modules' to load support for only " ;\
echo "the DAHDI hardware installed in this system. By "; \
echo "default support for all DAHDI hardware is loaded at "; \
echo "DAHDI start. "; \
fi
update:
@if [ -d .svn ]; then \
echo "Updating from Subversion..." ; \
svn update | tee update.out; \
rm -f .version; \
if [ `grep -c ^C update.out` -gt 0 ]; then \
echo ; echo "The following files have conflicts:" ; \
grep ^C update.out | cut -b4- ; \
fi ; \
rm -f update.out; \
else \
echo "Not under version control"; \
fi
clean:
-@$(MAKE) -C menuselect clean
rm -f $(BINS) $(TEST_BINS)
rm -f *.o dahdi_cfg tzdriver sethdlc
rm -f $(LTZ_SO) $(LTZ_A) *.lo
@for dir in $(SUBDIRS_UTILS_ALL); do \
$(MAKE) -C $$dir clean; \
done
@for dir in $(SUBDIRS_UTILS); do \
$(MAKE) -C $$dir clean; \
done
rm -f libtonezone*
rm -f fxotune
rm -f core
rm -f dahdi_cfg-shared fxstest
rm -rf $(GENERATED_DOCS) *.asciidoc tonezones.txt
distclean: dist-clean
dist-clean: clean
@$(MAKE) -C menuselect dist-clean
rm -f makeopts menuselect.makeopts menuselect-tree build_tools/menuselect-deps
rm -f config.log config.status
rm -f .*.d
config.status: configure
@CFLAGS="" ./configure
@echo "****"
@echo "**** The configure script was just executed, so 'make' needs to be"
@echo "**** restarted."
@echo "****"
@exit 1
menuselect.makeopts: menuselect/menuselect menuselect-tree makeopts
menuselect/menuselect --check-deps $@ $(GLOBAL_MAKEOPTS) $(USER_MAKEOPTS)
menuconfig: menuselect
cmenuconfig: cmenuselect
gmenuconfig: gmenuselect
nmenuconfig: nmenuselect
menuselect: menuselect/cmenuselect menuselect/nmenuselect menuselect/gmenuselect
@if [ -x menuselect/nmenuselect ]; then \
$(MAKE) nmenuselect; \
elif [ -x menuselect/cmenuselect ]; then \
$(MAKE) cmenuselect; \
elif [ -x menuselect/gmenuselect ]; then \
$(MAKE) gmenuselect; \
else \
echo "No menuselect user interface found. Install ncurses,"; \
echo "newt or GTK libraries to build one and re-rerun"; \
echo "'make menuselect'."; \
fi
cmenuselect: menuselect/cmenuselect menuselect-tree
-@menuselect/cmenuselect menuselect.makeopts $(GLOBAL_MAKEOPTS) $(USER_MAKEOPTS) && echo "menuselect changes saved!" || echo "menuselect changes NOT saved!"
gmenuselect: menuselect/gmenuselect menuselect-tree
-@menuselect/gmenuselect menuselect.makeopts $(GLOBAL_MAKEOPTS) $(USER_MAKEOPTS) && echo "menuselect changes saved!" || echo "menuselect changes NOT saved!"
nmenuselect: menuselect/nmenuselect menuselect-tree
-@menuselect/nmenuselect menuselect.makeopts $(GLOBAL_MAKEOPTS) $(USER_MAKEOPTS) && echo "menuselect changes saved!" || echo "menuselect changes NOT saved!"
# options for make in menuselect/
MAKE_MENUSELECT=CC="$(HOST_CC)" CXX="$(CXX)" LD="" AR="" RANLIB="" CFLAGS="" $(MAKE) -C menuselect CONFIGURE_SILENT="--silent"
menuselect/menuselect: menuselect/makeopts
+$(MAKE_MENUSELECT) menuselect
menuselect/cmenuselect: menuselect/makeopts
+$(MAKE_MENUSELECT) cmenuselect
menuselect/gmenuselect: menuselect/makeopts
+$(MAKE_MENUSELECT) gmenuselect
menuselect/nmenuselect: menuselect/makeopts
+$(MAKE_MENUSELECT) nmenuselect
menuselect/makeopts: makeopts
+$(MAKE_MENUSELECT) makeopts
menuselect-tree: dahdi.xml
@echo "Generating input for menuselect ..."
@build_tools/make_tree > $@
.PHONY: menuselect distclean dist-clean clean all _all install programs tests devel data config update install-programs install-libs install-utils-subdirs utils-subdirs prereq
FORCE:
ifneq ($(wildcard .*.d),)
include .*.d
endif

197
Makefile.am Normal file
View File

@ -0,0 +1,197 @@
ACLOCAL_AMFLAGS = -I m4
LEGACY_MAKE = \
$(MAKE) -f $(srcdir)/Makefile.legacy \
top_srcdir=$(top_srcdir) \
srcdir=$(srcdir)
CFLAGS += -g -Wall -O2 $(DAHDI_INCLUDE)
if DAHDI_DEVMODE
CFLAGS += \
-Werror \
-Wunused \
-Wundef \
$(DAHDI_DECLARATION_AFTER_STATEMENT) \
-Wmissing-format-attribute \
-Wformat-security \
#-Wformat=2
endif
SUBDIRS = xpp doc hotplug trunkdev
if PPPD
SUBDIRS += ppp
endif
noinst_HEADERS = \
bittest.h \
dahdi_tools_version.h \
fxotune.h \
wavformat.h \
#
sbin_PROGRAMS = \
dahdi_test \
dahdi_maint \
dahdi_monitor \
dahdi_cfg \
dahdi_speed \
dahdi_scan \
fxotune
noinst_PROGRAMS = \
fxstest \
patgen \
pattest \
patlooptest \
dahdi_diag \
timertest
dist_sbin_SCRIPTS = \
dahdi_span_assignments \
dahdi_waitfor_span_assignments \
dahdi_span_types
if PBX_HDLC
sbin_PROGRAMS += sethdlc
noinst_PROGRAMS += hdlcstress hdlctest hdlcgen hdlcverify
endif
# Libtool versioning for libtonezone:
# Bump when interface changes
LTZ_CURRENT = 2
# Bump if interface change is backward compatible
LTZ_AGE = 0
# Bump if only implementation change
LTZ_REVISION = 0
lib_LTLIBRARIES = libtonezone.la
libtonezone_la_SOURCES = \
zonedata.c \
tonezone.c \
version.c
dahdiinclude_HEADERS = tonezone.h
libtonezone_la_CFLAGS = $(CFLAGS) -I$(srcdir) -DBUILDING_TONEZONE
libtonezone_la_LDFLAGS = -version-info "$(LTZ_CURRENT):$(LTZ_REVISION):$(LTZ_AGE)"
libtonezone_la_LIBADD = -lm
if PBX_PCAP
noinst_PROGRAMS += dahdi_pcap
dahdi_pcap_LDADD = -lpcap
endif
patlooptest_LDADD = libtonezone.la
fxstest_LDADD = libtonezone.la
fxotune_LDADD = -lm
dahdi_speed_CFLAGS = -O2
dahdi_maint_SOURCES = dahdi_maint.c version.c
if PBX_NEWT
sbin_PROGRAMS += dahdi_tool
dahdi_tool_CFLAGS = $(CFLAGS) $(NEWT_INCLUDE)
dahdi_tool_LDADD = $(NEWT_LIB)
endif
dahdi_cfg_LDFLAGS = -lpthread
dahdi_cfg_LDADD = libtonezone.la
udevrulesdir = @udevrulesdir@
udevrules_DATA = dahdi.rules
all-local:
$(LEGACY_MAKE) all
clean-local:
$(LEGACY_MAKE) clean
install-exec-hook:
$(LEGACY_MAKE) install
@echo "Compatibility symlinks (should be removed in the future)"
ln -sf libtonezone.so.2.0.0 $(DESTDIR)$(libdir)/libtonezone.so.2.0
bashcompdir = $(sysconfdir)/bash_completion.d
install-data-hook:
mkdir -p $(DESTDIR)$(bashcompdir)
install -m 644 $(srcdir)/dahdi-bash-completion $(DESTDIR)$(bashcompdir)/dahdi
# Handle these files specially -- install them only with 'install-config'
special_config_files = \
init.conf.sample \
blacklist.sample \
modprobe.conf.sample \
#
install-config:
mkdir -p $(DESTDIR)$(dahdiconfdir)
mkdir -p $(DESTDIR)$(sysconfdir)/modprobe.d
install -m644 xpp/genconf_parameters $(DESTDIR)$(dahdiconfdir)/genconf_parameters
install -m644 init.conf.sample $(DESTDIR)$(dahdiconfdir)/init.conf
install -m644 blacklist.sample $(DESTDIR)$(sysconfdir)/modprobe.d/dahdi-blacklist.conf
install -m644 modprobe.conf.sample $(DESTDIR)$(sysconfdir)/modprobe.d/dahdi.conf
$(LEGACY_MAKE) config
dahdiconfdir = @sysconfdir@/dahdi
dahdiconf_DATA = \
system.conf.sample \
assigned-spans.conf.sample \
span-types.conf.sample \
modules.sample \
#
build_scripts = \
build_tools/dahdi_svn_tarball \
build_tools/dahdi_sysfs_copy \
build_tools/dump_sys_state \
build_tools/make_firmware_object.in \
build_tools/make_tree \
build_tools/make_version \
build_tools/test_kernel_git \
build_tools/uninstall-modules \
#
.version:
if ./build_tools/make_version . dahdi/tools > $@.tmp; then \
mv "$@.tmp" "$@"; \
fi
uninstall-hook:
$(RM) $(DESTDIR)$(sysconfdir)/dahdi/span-types.conf.sample
$(RM) $(DESTDIR)$(sysconfdir)/dahdi/assigned-spans.conf.sample
$(RM) $(DESTDIR)$(sysconfdir)/dahdi/system.conf
$(RM) $(DESTDIR)$(bashcompdir)/dahdi
docs:
$(LEGACY_MAKE) $@
DISTCLEANFILES = makeopts config.log config.status .*.d
MAINTAINERCLEANFILES = \
m4/libtool.m4 \
m4/ltoptions.m4 \
m4/ltsugar.m4 \
m4/ltversion.m4 \
m4/lt~obsolete.m4 \
#
EXTRA_DIST = \
.version \
LICENSE \
LICENSE.LGPL \
UPGRADE.txt \
bootstrap.sh \
Makefile.legacy \
dahdi.init \
dahdi.xml \
dahdi_pcap.c \
ifup-hdlc \
dahdi-bash-completion \
$(special_config_files) \
$(dahdiconf_DATA) \
$(udevrules_DATA) \
$(build_scripts) \
#
.PHONY: docs config

133
Makefile.legacy Normal file
View File

@ -0,0 +1,133 @@
#
# Makefile for DAHDI tools
#
# Copyright (C) 2001-2010 Digium, Inc.
#
#
ifeq ($(strip $(foreach var,clean,$(findstring $(var),$(MAKECMDGOALS)))),)
endif
ifeq ($(strip $(foreach var,clean,$(findstring $(var),$(MAKECMDGOALS)))),)
ifneq ($(wildcard makeopts),)
include makeopts
endif
endif
CHKCONFIG := $(wildcard /sbin/chkconfig)
UPDATE_RCD := $(wildcard /usr/sbin/update-rc.d)
ifeq (,$(DESTDIR))
ifneq (,$(CHKCONFIG))
ADD_INITD := $(CHKCONFIG) --add dahdi
else
ifneq (,$(UPDATE_RCD))
ADD_INITD := $(UPDATE_RCD) dahdi defaults 15 30
endif
endif
endif
INITRD_DIR := $(firstword $(wildcard $(DESTDIR)/etc/rc.d/init.d $(DESTDIR)/etc/init.d))
ifneq (,$(INITRD_DIR))
INIT_TARGET := $(INITRD_DIR)/dahdi
COPY_INITD := install -D dahdi.init $(INIT_TARGET)
endif
NETSCR_DIR := $(firstword $(wildcard $(DESTDIR)/etc/sysconfig/network-scripts ))
ifneq (,$(NETSCR_DIR))
NETSCR_TARGET := $(NETSCR_DIR)/ifup-hdlc
COPY_NETSCR := install -D ifup-hdlc $(NETSCR_TARGET)
endif
# sbindir, libdir, includedir and mandir are defined in makeopts
# (from configure).
LIB_DIR:=$(libdir)
# All the man pages. Not just installed ones:
GROFF_PAGES := $(wildcard doc/*.8 xpp/*.8)
GROFF_HTML := $(GROFF_PAGES:%=%.html)
GENERATED_DOCS := $(GROFF_HTML) README.html README.Astribank.html
all:
tonezones.txt: zonedata.c
perl -ne 'next unless (/\.(country|description) = *"([^"]*)/); \
print (($$1 eq "country")? "* $$2\t":"$$2\n");' $< \
>$@
%.asciidoc: %.sample
perl -n -e \
'if (/^#($$|\s)(.*)/){ if (!$$in_doc){print "\n"}; $$in_doc=1; print "$$2\n" } else { if ($$in_doc){print "\n"}; $$in_doc=0; print " $$_" }' \
$< \
| perl -p -e 'if (/^ #?(\w+)=/ && ! exists $$cfgs{$$1}){my $$cfg = $$1; $$cfgs{$$cfg} = 1; s/^/\n[[cfg_$$cfg]]\n/}' >$@
docs: $(GENERATED_DOCS)
genconf_parameters.sample: xpp/genconf_parameters
cp $< $@
README.html: README system.conf.asciidoc init.conf.asciidoc tonezones.txt \
UPGRADE.txt genconf_parameters.asciidoc assigned-spans.conf.asciidoc \
span-types.conf.asciidoc
TZ=UTC $(ASCIIDOC) -n -a toc -a toclevels=4 $<
README.Astribank.html: xpp/README.Astribank
TZ=UTC $(ASCIIDOC) -o $@ -n -a toc -a toclevels=4 $<
# on Debian: this requires the full groff, not just groff-base.
%.8.html: %.8
man -Thtml $^ >$@
htmlman: $(GROFF_HTML)
install: all install-programs
@echo "###################################################"
@echo "###"
@echo "### DAHDI tools installed successfully."
@echo "### If you have not done so before, install init scripts with:"
@echo "###"
@echo "### make install-config"
@echo "###"
@echo "###################################################"
install-programs: install-libs
install-libs:
ifneq (no,$(USE_SELINUX))
ifeq (,$(DESTDIR))
/sbin/restorecon -v $(DESTDIR)$(LIB_DIR)/$(LTZ_SO)
endif
endif
config:
ifneq (,$(COPY_INITD))
$(COPY_INITD)
endif
ifneq (,$(COPY_NETSCR))
$(COPY_NETSCR)
endif
ifneq (,$(ADD_INITD))
$(ADD_INITD)
endif
@echo "DAHDI has been configured."
@echo ""
@echo "List of detected DAHDI devices:"
@echo ""
@if [ `xpp/dahdi_hardware | tee /dev/stderr | wc -l` -eq 0 ]; then \
echo "No hardware found"; \
else \
echo ""; \
echo "run 'dahdi_genconf modules' to load support for only " ;\
echo "the DAHDI hardware installed in this system. By "; \
echo "default support for all DAHDI hardware is loaded at "; \
echo "DAHDI start. "; \
fi
clean:
rm -f *.o tzdriver
rm -f core
rm -rf $(GENERATED_DOCS) *.asciidoc tonezones.txt
.PHONY: clean all install devel data config install-programs install-libs
FORCE:

234
README
View File

@ -4,7 +4,7 @@ Asterisk Development Team <asteriskteam@digium.com>
$Revision$, $Date$
DAHDI stands for Digium Asterisk Hardware Device Interface. This
package contains the userspace tools to configure the kernel modules
package contains the user-space tools to configure the kernel modules
included in the package dahdi-linux.
Build Requirements
@ -14,9 +14,10 @@ dahdi-linux before building dahdi-tools.
Build System
~~~~~~~~~~~~
gcc and friends. Generally you will need to install the package gcc.
There may be cases where you will need a specific version of gcc to build
kernel modules.
GCC and friends. Generally you will need to install the package gcc.
Autotools (autoconf, automake and libtool) are needed if you clone from
Git.
Extra Libraries
@ -24,22 +25,25 @@ Extra Libraries
Some libraries are needed for extra utilities that are provided with
DAHDI.
- libusb is needed for building fpga_load, needed for firmware loading of
the Xorcom Astribank.
- libusb is needed for building astribank_hexload, needed for firmware
loading of the Xorcom Astribank.
- libnewt is needed to build the optional but useful utility dahdi_tool.
- libpcap is needed for building dahdi_pcap.
- pppd is needed to build the dahdi pppd plugin.
Installation
~~~~~~~~~~~~
Note: If using `sudo` to build/install, you may need to add /sbin to your PATH.
----------------------------------
# Only if you cloned from git:
autoreconf -i
./configure
# optional step: select custom configuration:
#make menuselect
make
make install
# To install init scripts and config files:
#make config
# To install some extra configuration files:
#make install-config
----------------------------------
@ -51,22 +55,18 @@ There are some make targets that are provided to build or install just
parts of DAHDI:
. Build targets:
- make: Build DAHDI userspace programs. partial
targets of it:
* make 'utilname': builds 'utilname' alone (e.g: `make dahdi_diag`)
* make utils: Build libtonezone.
* make libs: Build libtonezone.
- make: Build DAHDI user-space programs and libraries.
- make docs: Generate some extra documentation files.
. Install targets:
- make install: Installs user space tools into /usr/sbin/ (TODO - list
partial targets)
- make config: should be run once to configure
- make install: Install everything
- make install-config: install configuration files
Installation to a Subtree
^^^^^^^^^^^^^^^^^^^^^^^^^
The following may be useful when testing the package or when preparing a
package for a binary distribution (such as an rpm package) installing
onto a subtree rather than on th real system.
onto a subtree rather than on the real system.
make install DESTDIR=targetdir
@ -75,9 +75,9 @@ This can be useful for any partial install target from the list above.
Options For ./configure
^^^^^^^^^^^^^^^^^^^^^^^
The configure script various several tests and based on them generates
some files ( build_tools/menuselect-deps and makeopts). You can pass it
--with options and variable settings, for instance:
The configure script executes various tests and the build will depend on
their result. You can pass it --with options and variable settings, for
instance:
./configure --without-ncurses CC="gcc-4.10"
@ -89,7 +89,7 @@ run, use:
To re-run ./configure with the same parameters it was run with last
time, use:
./ocnfig.status --recheck
./config.status --recheck
Configuration
@ -106,7 +106,9 @@ channels, and send it to the kernel.
A sample annotated system.conf is included in this directory and
installed by default. Edit it to suit your configuration. Alternatively
use the script dahdi_genconf to generate one that should work with your
system.
system. Note that while dahdi_genconf will generate a working configuration,
it will not automatically detect hardware echo cancellation modules. These
will have to be enabled manually in system.conf.
/etc/dahdi/init.conf
~~~~~~~~~~~~~~~~~~~~
@ -114,29 +116,62 @@ The configuration file of the dahdi init.d script is
/etc/dahdi/init.conf . That file is used to override defaults that are
set at the beginning of the init.d script.
/etc/dahdi/assigned-spans.conf
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Assigns span number and initial channel number for spans in each device.
Just like system.conf it may be generated with dahdi_genconf:
dahdi_span_assignments auto
dahdi_genconf
It may also be edited manually to allow reserving span and channel
numbers for specific devices.
/etc/dahdi/span-types.conf
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Theoretically, this file is similar to assigned-spans.conf. It allows
setting the type (E1/T1) of a "PRI" span. This cannot be configured
anywhere else: it needs to be done before the span is assigned as it
changes the number of channels the span has.
In practice most systems don't mix E1 and T1 and thus this file will
typically have at most a single wild-card line setting all cards to be
either E1 or T1.
Reference Configuration
~~~~~~~~~~~~~~~~~~~~~~~
Sample system.conf
~~~~~~~~~~~~~~~~~~
^^^^^^^^^^^^^^^^^^
include::system.conf.asciidoc[]
Sample init.conf
~~~~~~~~~~~~~~~~
^^^^^^^^^^^^^^^^
include::init.conf.asciidoc[]
Sample genconf_parameters
~~~~~~~~~~~~~~~~~~~~~~~~~
^^^^^^^^^^^^^^^^^^^^^^^^^
FIXME: still not properly formatted.
include::genconf_parameters.asciidoc[]
Sample assigned-spans.conf
^^^^^^^^^^^^^^^^^^^^^^^^^^
include::assigned-spans.conf.asciidoc[]
Sample span-types.conf
^^^^^^^^^^^^^^^^^^^^^^
include::span-types.conf.asciidoc[]
Tonezones
~~~~~~~~~
The file zonedata.c contains the information about the tone zones used
in libtonezone (and hence also in ztcfg). Here is a list of those zones:
in libtonezone (and hence also in dahdi_cfg). Here is a list of those zones:
include::tonezones.txt[]
@ -144,14 +179,14 @@ include::tonezones.txt[]
DAHDI PERL modules
~~~~~~~~~~~~~~~~~~
The directory xpp has, in addition to helper utilities for the
Xorcom Astribank, a collection of perl modules to provide information
related to DAHDI. The perl modules themselves are under xpp/perl_modules/ .
Xorcom Astribank, a collection of PERL modules to provide information
related to DAHDI. The PERL modules themselves are under xpp/perl_modules/ .
In xpp/ there are several utilities that use those modules:
- xpp-specific: dahdi_registration, xpp_sync, xpp_blink .
- General: lsdahdi, dahdi_genconf, dahdi_hardware, dahdi_drivers
The DAHDI perl modules will currently only be automatically installed if you
happen to install the xpp directory. Those utilities require the perl modules
The DAHDI PERL modules will currently only be automatically installed if you
happen to install the xpp directory. Those utilities require the PERL modules
to be installed, however they will also look for them in the directory
perl_modules, and thus can be run directly from the DAHDI source tree. For
example:
@ -165,7 +200,7 @@ instance:
perldoc ./xpp/lsdahdi
Some of them are specific for the Xorcom Astribank and described in its
docuemntation. the others are:
documentation. the others are:
lsdahdi::
A somewhat glorified `cat /proc/dahdi/*`.
@ -174,9 +209,9 @@ dahdi_genconf::
/etc/dahdi/genconf_parameters (replaces genzaptelconf as well).
dahdi_drivers::
A two-liner script (not installed by default) that simply returns the
modules that should be modprobed on this system.
modules that should be modprobe-d on this system.
dahdi_hardware::
Uses the information from sysfs and its own knowledge to show
Uses the information from SysFS and its own knowledge to show
what PCI/USB DAHDI hardware is connected and if it is currently used
by a driver. Shows also some more information for Astribanks from
/proc/xpp .
@ -184,8 +219,8 @@ dahdi_hardware::
PPP Support
~~~~~~~~~~~
DAHDI digital cards can provide data channels through ppp as
point-to-point connections. This requires a plugin to the ppp daemon
DAHDI digital cards can provide data channels through PPP as
point-to-point connections. This requires a plug-in to the PPP daemon
that is included in the ppp/ subdirectory. To install it:
1. Make sure you have the PPP source / headers installed. On Debian:
@ -202,6 +237,131 @@ that is included in the ppp/ subdirectory. To install it:
CONFIG_HDLC .
Initialization
--------------
This section documents the start up sequence of the DAHDI modules.
There are generally two options: explicit (using an init script) and
implicit (run from UDEV hook scripts).
Explicit
~~~~~~~~
The dahdi init scripts does the following tasks:
* Loading the module dahdi and any other module listed in
/etc/dahdi/modules.
* For xpp (Astribanks) - some specific initializations. See
README.Astribank.
* Runs link:doc/dahdi_cfg.8.html[dahdi_cfg] after all modules were
loaded.
* A number of other tools may need to be run:
** link:doc/fxotune.8.html[fxotune]
** dahdihpec_enable
Only at this point Asterisk (or any other user of DAHDI) can be run.
Implicit
~~~~~~~~
(Also known as "hot-plug" or "pinned-spans". This requires:
* dahdi >= 2.8.0
* Setting the module parameter auto_assign_spans of dahdi to 0
* (Recommended) Asterisk >= 12 - which supports "dahdi create channels".
When a device driver of a DAHDI device finishes initialization, it
creates a dahdi_device kernel object. A dahdi_device represents a single
DAHDI device (such as a PCI card) and may have several spans. If the
value of auto_assign_spans is 1 when dahdi_device is created, spans are
assigned automatically - each new span gets the first available span
number and range of channels. However if it is set to 0, spans will not
get assigned, and user space programs need to assign them. The
low-level interface for doing so is explained in the section "Span
Assignment" in the README of DAHDI-Linux.
New Devices
^^^^^^^^^^^
When a kernel object is created or destroyed, the kernel sends an event
to user space. Those events are normally handled by udevd. Configurations
for udevd ("udev rules") may be placed in /etc/udev/rules.d or
/lib/udev/rules.d. This package installs rules that instruct udevd to
run the script `/usr/share/dahdi/dahdi_handle_device` on each new
device, which runs all the scripts in `/usr/share/dahdi/handle_device.d`.
Those scripts will:
* If `/etc/dahdi/span-types.conf` exists, apply it to the device. It is
used for E1/T1/J1 settings. See
<<_sample_span_types_conf,sample span-types.conf>>.
* If `/etc/dahdi/assigned-spans.conf` exists, assign the span according
to it (if it is not specified there: don't assign it).
used for E1/T1/J1 settings. See
<<_sample_assigned_spans_conf,sample assigned-spans.conf>>.
* But if that file does not exist, assign the span to the first
available place.
This script mainly uses the commands
link:doc/dahdi_span_types.8.html[dahdi_span_types] and
link:doc/dahdi_span_assignments.8.html[dahdi_span_assignments].
DAHDI devices are listed under `/sys/bus/dahdi_devices/devices`.
If you want to disable running this script, add the following line to
`/etc/dahdi/init.conf`:
.............................
DAHDI_UDEV_DISABLE_DEVICES=yes
.............................
New Spans
^^^^^^^^^
Once a span is assigned, a kernel object will appear for it. It will be
listed under its device. As a new kernel object was created, an event is
sent to udev.
The standard DAHDI udev rules instruct udevd to run the script
`/usr/share/dahdi/dahdi_span_config` which runs all the scripts in
`/usr/share/dahdi/span_config.d`. Those script configures the new
span:
* If system.conf does not exist, generates a temporary configuration
for the span using link:doc/dahdi_genconf.8.html[dahdi_genconf
system].
* Runs link:doc/dahdi_cfg.8.html[dahdi_cfg] on the new span (using `-S`
and -C`).
* Runs `asterisk -rx 'dahdi create channels'` to add the new channels
and spans to Asterisk (if they were configured in advance).
If you want to disable running this script, add the following line to
`/etc/dahdi/init.conf`:
.............................
DAHDI_UDEV_DISABLE_SPANS=yes
.............................
New Channels
^^^^^^^^^^^^
DAHDI channels have their own representation in the kernel. The standard
udev rules that dahdi-tools includes for them, however, don't run a
script for each device. Each DAHDI channel creates a block device file
at /dev/dahdi/chan/'span'/'rel-chan', where 'span' and 'rel-chan' are
each three-digit numbers (e.g: 035). 'span' is the span number and
'rel-chan' is the channel number relative to the span.
The udev rules generate the following extra symlinks under /dev/dahdi:
* /dev/dahdi/'num' - the channel number. As it was originally (but
continues beyond 250).
* /dev/dahdi/devices/'hardware_id'/'rel-span'/'rel-chan' - if the DAHDI
device has a hardware ID field, provide listing of the device's span
and channels.
* /dev/dahdi/devices/@'hardware_id'/'rel-span'/'rel-chan' - likewise for
the connector field. It has a "@" prefix.
include::UPGRADE.txt[]

View File

@ -62,10 +62,9 @@ Any or all of these modules can be loaded at the same time, and the echo
canceler to be used on the system's channels can be configured using
the dahdi_cfg tool from the dahdi-tools package.
IMPORTANT: It is *mandatory* to configure an echo canceler for the
system's channels using dahdi_cfg unless the interface cards in use
have echo canceler modules available and enabled. There is *no*
default software echo canceler with DAHDI. See
IMPORTANT: It is *mandatory* to configure an echo canceler for the system's
channels using dahdi_cfg. There is *no* default echo canceler with DAHDI, not
even hardware echo cancellation modules. See
<<_echo_cancellers,section on echo cancellers>> in sample system.conf.

View File

@ -0,0 +1,57 @@
#
# /etc/dahdi/assigned-spans.conf:
#
# This file assigns span and channel numbers to dahdi devices
#
# Built as a table keyed by <id>:
# <id> <spanspec>....
#
# Where:
# * The <id> field may be either:
# hardware_id
# @location
# devpath (in sysfs)
# * Shell-style globbing is allowed for the <id> field
# * There may one or more of <spanspec>
# * Each <spanspec> is composed as:
# <local_spanno>:<assigned_spanno>:<base_channo>
#
# Examples:
# Astribank with two spans:
# FXS * 8 channels + 4 digital inputs 2 digital outputs
# FXO * 8 channels
#usb:QA-1 1:1:1
#usb:QA-1 2:2:15
# Same Astribank in one-liner
#usb:QA-1 1:1:1 2:2:15
# Astribank with 4*PRI spans and 3*FXS*8 spans
# Note that channels are NOT globally contigous
# each span get its own 50 numbers. Also, skip
# Channel number 250...
#usb:INT03165 1:1:1 # E1
#usb:INT03165 2:2:51 # E1
#usb:INT03165 3:3:151 # E1
#usb:INT03165 4:4:201 # E1
#usb:INT03165 5:5:301 # FXS * 8 channels
#usb:INT03165 6:6:351 # FXS * 8 channels
#usb:INT03165 7:7:401 # FXS * 8 channels
# Alternatively -- all in one-line
#usb:INT03165 1:1:1 2:2:51 3:3:151 4:4:201 5:5:301 6:6:351 7:7:401
# Astribank with 4*BRI without hardware_id :-(
# We use the location on the bus (ie: where it is physically
# located). Note the '@' prefix that indicate the location key.
#@usb-0000:00:1d.7-3 1:1:50
#@usb-0000:00:1d.7-3 2:2:100
#@usb-0000:00:1d.7-3 3:3:150
#@usb-0000:00:1d.7-3 4:4:200
# Same configuration with globbing:
#/sys/*/usb1/1-6/* 1:1:50
#/sys/*/usb1/1-6/* 2:2:100
#/sys/*/usb1/1-6/* 3:3:150
#/sys/*/usb1/1-6/* 4:4:200

View File

@ -1,102 +0,0 @@
/* autoconfig.h.in. Generated from configure.ac by autoheader. */
/* Define if your system has the DAHDI headers. */
#undef HAVE_DAHDI
/* Define DAHDI headers version */
#undef HAVE_DAHDI_VERSION
/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the <linux/soundcard.h> header file. */
#undef HAVE_LINUX_SOUNDCARD_H
/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H
/* Define this to indicate the ${NEWT_DESCRIP} library */
#undef HAVE_NEWT
/* Define to indicate the ${NEWT_DESCRIP} library version */
#undef HAVE_NEWT_VERSION
/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the <sys/soundcard.h> header file. */
#undef HAVE_SYS_SOUNDCARD_H
/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define this to indicate the ${USB_DESCRIP} library */
#undef HAVE_USB
/* Define to indicate the ${USB_DESCRIP} library version */
#undef HAVE_USB_VERSION
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS
/* Enable extensions on AIX 3, Interix. */
#ifndef _ALL_SOURCE
# undef _ALL_SOURCE
#endif
/* Enable GNU extensions on systems that have them. */
#ifndef _GNU_SOURCE
# undef _GNU_SOURCE
#endif
/* Enable threading extensions on Solaris. */
#ifndef _POSIX_PTHREAD_SEMANTICS
# undef _POSIX_PTHREAD_SEMANTICS
#endif
/* Enable extensions on HP NonStop. */
#ifndef _TANDEM_SOURCE
# undef _TANDEM_SOURCE
#endif
/* Enable general extensions on Solaris. */
#ifndef __EXTENSIONS__
# undef __EXTENSIONS__
#endif
/* Define to 1 if on MINIX. */
#undef _MINIX
/* Define to 2 if the system does not provide POSIX.1 features except with
this defined. */
#undef _POSIX_1_SOURCE
/* Define to 1 if you need to in order for `stat' and other things to work. */
#undef _POSIX_SOURCE

View File

@ -4,6 +4,7 @@
blacklist wct4xxp
blacklist wcte12xp
blacklist wcte13xp
blacklist wct1xxp
blacklist wcte11xp
blacklist wctdm24xxp
@ -11,3 +12,12 @@ blacklist wcfxo
blacklist wctdm
blacklist wctc4xxp
blacklist wcb4xxp
blacklist wcaxx
blacklist wcte43x
# Some mISDN drivers may try to attach to cards supported by DAHDI. If you
# have a card which is *not* supported by DAHDI but supported by one of the
# below drivers you should feel free to remove it from the blacklist below.
blacklist hfcmulti
blacklist netjet
blacklist hfcpci

142
build_tools/dahdi_sysfs_copy Executable file
View File

@ -0,0 +1,142 @@
#! /usr/bin/perl
#
# Written by Oron Peled <oron@actcom.co.il>
# Copyright (C) 2012, Xorcom
# This program is free software; you can redistribute and/or
# modify it under the same terms as Perl itself.
#
#dahdi_sysfs_copy: Short perl script to copy dahdi related sysfs trees
# into a designated directory.
#
# $Id: $
#
use strict;
use warnings;
use File::Path qw(mkpath);
use File::Copy;
use Cwd qw(realpath);
my $destdir = shift || die "Usage: $0 <destdir>\n";
my %symlinks;
my %walk_ups;
my %inode_cash;
# Starting points for recursion
my @toplevels = qw(
/sys/bus/dahdi_devices
/sys/bus/astribanks
/sys/class/dahdi
);
# Loop prevention (by inode number lookup)
sub seen {
my $ino = shift || die;
my $path = shift || die;
if(defined $inode_cash{$ino}) {
#print STDERR "DEBUG($ino): $path\n";
return 1;
}
$inode_cash{$ino}++;
return 0;
}
# Walk up a path and copy readable attributes from any
# directory level.
sub walk_up {
my $path = shift || die;
my $curr = $path;
# Walk up
for (my $curr = $path; $curr; $curr =~ s'/?[^/]+$'') {
my ($dev, $ino, $mode, $nlink, $uid, $gid) = lstat($curr);
next if seen($ino, $curr); # Skip visited directories
# Scan directory
opendir(my $d, $curr) || die "Failed opendir($curr): $!\n";
my @entries = readdir $d;
foreach my $entry (@entries) {
next if $entry =~ /^[.][.]?$/;
my $file = "$curr/$entry";
my ($dev, $ino, $mode, $nlink, $uid, $gid) = lstat($file);
# Copy file
if (-f _ && ($mode & 0004)) { # The '-r _' is buggy
copy($file, "$destdir$file") ||
die "Failed to copy '$file': $!\n";
}
}
closedir $d;
}
}
# Handle a given path (directory,symlink,regular-file)
sub handle_path {
my $path = shift || die;
my ($dev, $ino, $mode, $nlink, $uid, $gid) = lstat($path);
# Save attributes before recursion starts
my $isdir = -d _;
my $islink = -l _;
my $isreadable = $mode & 00004; # The '-r _' was buggy
return if seen($ino, $path); # Loop prevention
my $dest = "$destdir/$path";
if ($isdir) {
mkpath("$dest");
scan_directory($path);
} elsif ($islink) {
# We follow links (the seen() protect us from loops)
my $target = readlink($path) ||
die "Failed readlink($path): $!\n";
my $follow = $target;
if ($target !~ m{^/}) { # fix relative symlinks
my $dir = $path;
$dir =~ s,/[^/]*$,,;
$follow = realpath("$dir/$target");
}
# Save symlink details, so we create them after all
# destination tree (subdirectories, files) is ready
die "Duplicate entry '$dest'\n" if exists $symlinks{$dest};
$symlinks{$dest} = "$target";
# Now follow symlink
handle_path($follow);
$walk_ups{$follow}++;
} elsif ($isreadable) {
copy($path, "$dest") ||
die "Failed to copy '$path': $!\n";
}
}
# Scan a given directory (calling handle_path for recursion)
sub scan_directory {
my $dir = shift || die;
my $entry;
opendir(my $d, $dir) || die "Failed opendir($dir): $!\n";
my @dirs = readdir $d;
foreach my $entry (@dirs) {
next if $entry =~ /^[.][.]?$/;
handle_path("$dir/$entry");
}
closedir $d;
}
# Filter out non-existing toplevels
my @scan = grep { lstat($_) } @toplevels;
# Recurse all trees, creating subdirectories and copying files
foreach my $path (@scan) {
handle_path($path);
}
# Now, that all sub-directories were created, we can
# create the wanted symlinks
for my $dest (keys %symlinks) {
my $link = $symlinks{$dest};
die "Missing link for '$dest'\n" unless defined $link;
unlink $dest if -l $dest;
symlink($link,$dest) ||
die "Failed symlink($link,$dest): $!\n";
}
# Walk up directories that were symlink destinations
# and fill their attributes
foreach my $dir (keys %walk_ups) {
walk_up($dir);
}

View File

@ -31,117 +31,46 @@
# # And then later:
# DAHDI_VIRT_TOP="$PWD/my_sys_state" dahdi_genconf
name=dahdi_sys_state_dump
usage() {
echo "$0: dump system data for Dahdi-Perl"
echo "Usage: $0 [<name>]]"
echo ""
echo "<name>: name of directory/tarball to create. Default: $name"
}
output_tar() {
gzip -9 >$name.tar.gz
}
output_cpio() {
gzip -9 >$name.cpio.gz
}
output_dir() {
rm -rf $name
mkdir -p $name
cd $name
#tar xf -
cpio -id
}
mydir=`dirname $0`
dahdi_sysfs_copy="$mydir/dahdi_sysfs_copy"
# Give usage message on expected texts
case $1 in
help | -* ) usage; exit 1;;
esac
if [ "$1" != '' ]; then
name="$1"
if [ "$#" -ne 0 ]; then
echo >&2 "Usage: $0"
exit 1
fi
# funky permissions on procfs. Sadly rm -f does not kill them.
if [ -d "$name" ]; then
chmod -R u+w "$name"
fi
rm -rf "$name"
mkdir -p "$name"
id="sys_dump.`hostname`_`date +%F_%H.%M.%S`"
tarball="$id.tar.gz"
# delete a (potentially empty) list of files
rm_files() {
xargs rm -f rm_files_non_existing_file
}
tmpdir=`mktemp -td 'dahdi_dump.XXXXXX'`
echo -n >&2 "Creating ... "
trap "[ -d '$tmpdir' ] && rm -rf '$tmpdir'" 0 1 2 15
topdir="$tmpdir/$id"
if [ -r /proc/bus/usb/devices ]; then
mkdir -p "$name/proc/bus/usb"
cp -a /proc/bus/usb/devices "$name/proc/bus/usb/"
mkdir -p "$topdir/proc/bus/usb"
cp -a /proc/bus/usb/devices "$topdir/proc/bus/usb/"
fi
if [ -d /proc/dahdi ]; then
mkdir -p "$name/proc/dahdi"
mkdir -p "$topdir/proc/dahdi"
if find /proc/dahdi -type f >/dev/null; then
cp -a /proc/dahdi/* "$name/proc/dahdi/"
cp -a /proc/dahdi/* "$topdir/proc/dahdi/"
fi
fi
if [ -d /proc/xpp ]; then
mkdir -p "$name/proc/xpp"
mkdir -p "$topdir/proc/xpp"
if find /proc/xpp -type f >/dev/null; then
cp -a /proc/xpp/* "$name/proc/xpp/"
find "$name/proc/xpp" -type f -name command | rm_files
cp -a /proc/xpp/* "$topdir/proc/xpp/"
find "$topdir/proc/xpp" -type f -name command -exec rm -f '{}' ';'
fi
fi
# FIXME: the following grab tons of files from sysfs. Any way to do with
# less information?
pci_dev_pat='/sys/devices/pci*'
mkdir -p "$name/sys/devices"
cp -a $pci_dev_pat "$name/sys/devices/" 2>/dev/null
for bus in astribanks xpds pci pci_express usb; do
if [ -d /sys/bus/$bus ]; then
mkdir -p "$name/sys/bus/"
cp -a /sys/bus/$bus "$name/sys/bus/" 2>/dev/null
fi
done
# Remove PCI devices of irelevan classes:
irrelevant_devs() {
grep . "$name"/$pci_dev_pat/0*/class "$name"/$pci_dev_pat/0*/0*/class \
| perl -n -e '# Perl provides commented regexes:
next unless m{/class:( # The following is a list of device classes
# that can be safely removed:
0x060000 | # Host bridge
0x030000 | # VGA compatible controller
0x038000 | # Display controller
0x040300 | # Audio device
0x060401 | # PCI bridge
0x060100 | # ISA bridge
0x01018a | # IDE interface
0x01018f | # IDE interface
0x0c0500 | # SMBus
0x060700 | # CardBus bridge
0x0c0010 | # FireWire (IEEE 1394)
# The following are not to be removed:
#0x0c0300 | # USB Controller (UHCI?)
#0x060400 | # PCI bridge
#0x0c0320 | # USB Controller (EHCI?)
#0x020000 | # Ethernet controller
#0x0c0010 | # Network controller: (Wifi?)
)$}x;
# Leave out just the name of the node:
s{/[^/]*$}{};
print;
print "\n"
'
}
# FIXME: deleting those seems to remove common 'vendor' directories
# and mess things up. Skip it for now.
#rm -rf `irrelevant_devs`
"$dahdi_sysfs_copy" "$topdir"
echo -n >&2 "tarball ... "
( cd "$tmpdir" && tar czf - . ) > "$tarball";
echo >&2 "ready in '$tarball'"

View File

@ -1,7 +0,0 @@
#!/bin/sh
echo "<?xml version=\"1.0\"?>"
echo
echo "<menu name=\"DAHDI Tools Selection\">"
cat dahdi.xml
echo "</menu>"

View File

@ -1,10 +1,10 @@
#!/bin/sh
if [ -f ${1}/.version ]; then
cat ${1}.version
cat ${1}/.version
elif [ -f ${1}/.svnrevision ]; then
echo SVN-`cat ${1}/.svnbranch`-r`cat ${1}/.svnrevision`
elif [ -d .svn ]; then
elif [ -d ${1}/.svn ]; then
PARTS=`LANG=C svn info ${1} | grep URL | awk '{print $2;}' | sed -e s:^.*/svn/${2}/:: | sed -e 's:/: :g'`
BRANCH=0
TEAM=0
@ -53,4 +53,72 @@ elif [ -d .svn ]; then
done
echo SVN-${RESULT##-}-r${REV}
elif [ -d ${1}/.git ]; then
# If the first log commit messages indicates that this is checked into
# subversion, we'll just use the SVN- form of the revision.
MODIFIED=""
SVN_REV=`git log --pretty=full -1 | grep -F "git-svn-id:" | sed -e "s/.*\@\([^\s]*\)\s.*/\1/g"`
if [ -z "$SVN_REV" ]; then
VERSION=`git describe --tags --dirty=M 2> /dev/null | sed -e "s/^v\([0-9]\)/\1/"`
if [ $? -ne 0 ]; then
if [ "`git ls-files -m | wc -l`" != "0" ]; then
MODIFIED="M"
fi
# Some older versions of git do not support all the above
# options.
VERSION=GIT-`git rev-parse --short --verify HEAD`${MODIFIED}
fi
VERSION=${VERSION##*/} # Remove leading slashes: upsteram/2.10.2
VERSION=${VERSION#[1-9]%} # Remove 1% from tag (tag from Debian epoch)
echo ${VERSION}
else
PARTS=`LANG=C git log --pretty=full | grep -F "git-svn-id:" | head -1 | awk '{print $2;}' | sed -e s:^.*/svn/$2/:: | sed -e 's:/: :g' | sed -e 's/@.*$//g'`
BRANCH=0
TEAM=0
if [ "`git ls-files -m | wc -l`" != "0" ]; then
MODIFIED="M"
fi
if [ "${PARTS}" = "trunk" ]; then
echo SVN-'trunk'-r${SVN_REV}${MODIFIED}
exit 0
fi
for PART in $PARTS
do
if [ ${BRANCH} != 0 ]; then
RESULT="${RESULT}-${PART}"
break
fi
if [ ${TEAM} != 0 ]; then
RESULT="${RESULT}-${PART}"
continue
fi
if [ "${PART}" = "branches" ]; then
BRANCH=1
RESULT="branch"
continue
fi
if [ "${PART}" = "tags" ]; then
BRANCH=1
RESULT="tag"
continue
fi
if [ "${PART}" = "team" ]; then
TEAM=1
continue
fi
done
echo SVN-${RESULT##-}-r${SVN_REV}${MODIFIED}
fi
else
# Use the directory information in the absence of any other version
# information
pwd -P
fi

View File

@ -1,10 +0,0 @@
#!/bin/sh
cat << END
/*
* version.c
* Automatically generated
*/
const char dahdi_tools_version[] = "DAHDI Tools Version - ${TOOLSVERSION}";
END

View File

@ -1,2 +0,0 @@
LIBNEWT=@PBX_NEWT@
HDLC=@PBX_HDLC@

1526
config.guess vendored

File diff suppressed because it is too large Load Diff

1658
config.sub vendored

File diff suppressed because it is too large Load Diff

6991
configure vendored

File diff suppressed because it is too large Load Diff

View File

@ -2,29 +2,65 @@
AC_PREREQ(2.59)
m4_define([TOOLSVERSION],
m4_define([short_version],
m4_bpatsubst(m4_esyscmd([build_tools/make_version . dahdi/tools]),
[\([0-9.]*\)\(\w\|\W\)*],
[\1]))
AC_INIT(dahdi, TOOLSVERSION, www.asterisk.org)
AC_INIT([dahdi-tools], short_version, [www.asterisk.org])
# check existence of the package
AC_CONFIG_SRCDIR([dahdi_cfg.c])
AC_CONFIG_AUX_DIR([auxdir])
AC_CONFIG_MACRO_DIR([m4])
AM_INIT_AUTOMAKE([foreign subdir-objects])
build_version=`build_tools/make_version . dahdi/tools`
AC_SUBST([BUILD_VERSION], "$build_version")
# enable nice build output on automake1.11
m4_pattern_allow([AM_DEFAULT_VERBOSITY])
m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])],[AM_DEFAULT_VERBOSITY=1])
AM_CONDITIONAL([SILENT_RULES], [test "$AM_DEFAULT_VERBOSITY" = '0'])
AC_COPYRIGHT("dahdi-tools")
AC_REVISION($Revision$)
ac_default_prefix=/usr
if test ${sysconfdir} = '${prefix}/etc'; then
sysconfdir=/etc
fi
if test ${mandir} = '${prefix}/man'; then
mandir=/usr/share/man
fi
# Preserve old defaults if called without --prefix or --prefix=/usr
# prefix=/usr
# sysconfdir=/etc
if test ${localstatedir} = '${prefix}/var'; then
localstatedir=/var
ac_default_prefix=/usr
if test "$prefix" = 'NONE' -o "$prefix" = '/usr'; then
if test ${sysconfdir} = '${prefix}/etc'; then
sysconfdir=/etc
fi
if test ${mandir} = '${prefix}/man'; then
mandir=/usr/share/man
fi
if test ${localstatedir} = '${prefix}/var'; then
localstatedir=/var
fi
fi
AC_SUBST([dahditoolsdir], ['${datadir}/dahdi'])
AC_SUBST([dahdiincludedir], ['${includedir}/dahdi'])
# Where to install udev rules?
# * Our default is $sysconfdir/udev/rules.d:
# - This preserve legacy location.
# - It doesn't write into modern vendor supplied location (/lib/udev/rules.d)
# - It doesn't break "make distcheck" (where everything should be relative
# to prefix.
# * Packagers are encouraged to use --udevrules=/lib/udev/rules.d
#
m4_define([_UDEV_RULES_DIR_DEFAULT], [${sysconfdir}/udev/rules.d])dnl
AC_ARG_WITH(udevrules,
[AS_HELP_STRING([--with-udevrules=PATH],
[Location of UDEV rules @<:@default=]_UDEV_RULES_DIR_DEFAULT[@:>@])],
[udevrulesdir=$withval],
[udevrulesdir=]'_UDEV_RULES_DIR_DEFAULT'
)
AC_SUBST([udevrulesdir], "$udevrulesdir")
# specify output header file
AC_CONFIG_HEADER(autoconfig.h)
@ -32,15 +68,18 @@ AC_CONFIG_HEADER(autoconfig.h)
# This needs to be before any macros that use the C compiler
AC_GNU_SOURCE
AC_CHECK_HEADERS([sys/soundcard.h linux/soundcard.h])
AC_CHECK_TOOL([LD], [ld])
# Checks for programs.
AC_PROG_CXX
AC_PROG_CC
AC_PROG_CPP
AM_PROG_CC_C_O
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
AC_PROG_AWK
AC_PROG_LIBTOOL
AST_CHECK_GNU_MAKE
test_obj=conftest.o
@ -70,6 +109,35 @@ AC_SUBST(DOWNLOAD)
AC_LANG(C)
AC_PATH_PROG([PERL], [perl])
if test "$PERL" = ''; then
AC_MSG_ERROR(perl is mandatory)
fi
# Where to install perl modules?
# * Packagers are encouraged to use the result of "perl -V:vendorlib"
# * Our default is:
# - The result of "perl -V:sitelib" for our default prefix (/usr)
# - The "$datadir/perl5" directory otherwise (e.g: during "make distcheck")
#
AC_MSG_CHECKING(for perl libdir)
m4_define([_PERL_LIBDIR_DEFAULT], [${datadir}/perl5])dnl
AC_ARG_WITH(perllib,
[AS_HELP_STRING([--with-perllib=PATH],
[Location of perl modules @<:@default=]_PERL_LIBDIR_DEFAULT[, or perl -V:sitelib@:>@])],
[perllibdir=$withval],
[
if test "$prefix" = 'NONE' -o "$prefix" = '/usr'; then
eval `"$PERL" -V:sitelib`
perllibdir="$sitelib"
else
perllibdir='_PERL_LIBDIR_DEFAULT'
fi
]
)
AC_SUBST([perllibdir], "$perllibdir")
AC_MSG_RESULT([$perllibdir])
AM_CONDITIONAL([PERL], [test "$perllibdir" != ''])
AC_ARG_ENABLE(dev-mode,
[ --enable-dev-mode Turn on developer mode],
[case "${enableval}" in
@ -78,6 +146,7 @@ AC_ARG_ENABLE(dev-mode,
*) AC_MSG_ERROR(bad value ${enableval} for --enable-dev-mode) ;;
esac])
AC_SUBST(DAHDI_DEVMODE)
AM_CONDITIONAL([DAHDI_DEVMODE], [test "$DAHDI_DEVMODE" = 'yes'])
AC_MSG_CHECKING(for -Wdeclaration-after-statement support)
if $(${CC} -Wdeclaration-after-statement -S -o /dev/null -xc /dev/null > /dev/null 2>&1); then
@ -89,15 +158,106 @@ else
fi
AC_SUBST(DAHDI_DECLARATION_AFTER_STATEMENT)
# Checks for header files.
AC_CHECK_HEADERS([sys/soundcard.h linux/soundcard.h])
AC_CHECK_HEADERS([arpa/inet.h fcntl.h limits.h netinet/in.h stdint.h stdlib.h string.h sys/ioctl.h sys/param.h sys/socket.h sys/time.h syslog.h unistd.h])
# Checks for typedefs, structures, and compiler characteristics.
AC_C_INLINE
AC_TYPE_SIZE_T
AC_TYPE_SSIZE_T
AC_TYPE_UINT16_T
AC_TYPE_UINT32_T
AC_TYPE_UINT8_T
# Checks for libraries.
AC_CHECK_LIB([m], [cos])
AC_CHECK_LIB([pthread], [pthread_create])
AST_EXT_LIB_SETUP([DAHDI], [DAHDI], [dahdi])
AST_EXT_LIB_SETUP([NEWT], [newt], [newt])
AST_EXT_LIB_SETUP([USB], [usb], [usb])
AST_EXT_LIB_SETUP([PCAP], [pcap], [pcap])
AST_C_DEFINE_CHECK([DAHDI], [DAHDI_CODE], [dahdi/user.h])
DAHDI23_DIR="${DAHDI_DIR}"
AST_C_DEFINE_CHECK([DAHDI23], [DAHDI_CONFIG_NTTE], [dahdi/user.h])
AST_C_DEFINE_CHECK([TRUNKDEV], [DAHDI_TRUNKDEV_CREATE], [dahdi/user.h])
AST_EXT_LIB_CHECK([NEWT], [newt], [newtBell], [newt.h])
AST_EXT_LIB_CHECK([USB], [usb], [usb_init], [usb.h])
AST_EXT_LIB_CHECK([PCAP], [pcap], [pcap_compile], [pcap.h])
saved_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS $DAHDI_INCLUDE"
AC_CHECK_DECL([DAHDI_TXMIRROR], [DAHDI_TXMIRROR=1], [DAHDI_TXMIRROR=0], [#include <dahdi/user.h>])
CPPFLAGS="$saved_CPPFLAGS"
AM_CONDITIONAL([PBX_NEWT], [test "$PBX_NEWT" = "1"])
AM_CONDITIONAL([PBX_PCAP], [test "$PBX_PCAP" = "1" -a "$DAHDI_TXMIRROR" = "1"])
AM_CONDITIONAL([PBX_TRUNKDEV], [test "$PBX_TRUNKDEV" = "1"])
AC_CHECK_FUNCS([semtimedop])
AC_CHECK_FUNCS([alarm bzero gettimeofday memset pow regcomp select socket strcasecmp strchr strdup strerror strrchr strstr strtol strtoul])
AC_FUNC_ERROR_AT_LINE
AC_FUNC_MALLOC
# What the user asked for? libusb/libusbx
AC_ARG_WITH([libusbx],
[AS_HELP_STRING([--without-libusbx], [Disable libusbx @<:@default=check@:>@])],
[],
[with_libusbx=check])
AC_ARG_WITH([libusb],
[AS_HELP_STRING([--without-libusb], [Disable libusb-0.1 @<:@default=check@:>@])],
[],
[with_libusb=check])
# LIBUSBX tests
have_libusbx=
AS_IF([test "$with_libusbx" != "no"],
[PKG_CHECK_MODULES([LIBUSBX], [libusb-1.0],
[AC_CHECK_LIB([usb-1.0], [libusb_error_name],
[
have_libusbx="yes"
AC_DEFINE([HAVE_LIBUSBX], [1], [Define to 1 if you have <libusb.h>.])
AC_SUBST([PBX_USB], [1])
], [
if test "$with_libusbx" != "yes"; then
AC_MSG_NOTICE([Ignoring old libusb-1.0, trying fallback to old libusb])
fi
])
], [:])
], [])
AS_IF([test "$with_libusbx" = "yes" -a "$have_libusbx" = ""],
[AC_MSG_ERROR([No libusbx found (--with-libusbx was given)])])
# LIBUSB tests
have_libusb=
AS_IF([test "$with_libusb" != "no"],
[AS_IF([test "$have_libusbx" != ""],
[
AS_IF([test "$with_libusbx" = "check"], [
AC_MSG_NOTICE([Skipping LIBUSB tests (have good LIBUSBX)])
])
], [
PKG_CHECK_MODULES([LIBUSB], [libusb],
[
have_libusb="yes"
AC_SUBST([PBX_USB], [1])
]
[AC_DEFINE([HAVE_LIBUSB], [1], [Define to 1 if you have <usb.h>.])],
[:]
)
])
], [])
AS_IF([test "$with_libusb" = "yes" -a "$have_libusb" = ""],
[AC_MSG_ERROR([No libusb found (--with-libusb was given)])])
AM_CONDITIONAL([LIBUSBX], [test "$have_libusbx" != ""])
AM_CONDITIONAL([LIBUSB], [test "$have_libusb" != ""])
AM_CONDITIONAL([PBX_USB], [test "$PBX_USB" = "1"])
PBX_HDLC=0
AC_MSG_CHECKING([for GENERIC_HDLC_VERSION version 4 in linux/hdlc.h])
@ -136,6 +296,7 @@ if test "x${PBX_HDLC}" != "x1"; then
fi
AC_SUBST(PBX_HDLC)
AM_CONDITIONAL([PBX_HDLC], [test "$PBX_HDLC" = "1"])
AC_ARG_WITH(selinux,
[AS_HELP_STRING([--with-selinux],
@ -191,6 +352,9 @@ case "$with_ppp" in
;;
esac
AC_SUBST(PPPD_VERSION)
AM_CONDITIONAL([PPPD], [test "$PPPD_VERSION" != ''])
if test "x${PBX_DAHDI}" != "x1"; then
AC_MSG_NOTICE([***])
AC_MSG_NOTICE([*** Building this package requires DAHDI support. *** ])
@ -209,7 +373,27 @@ fi
AC_SUBST(PPPD_VERSION)
AC_CONFIG_FILES([build_tools/menuselect-deps makeopts])
# Taken from octasic-helper
AC_SUBST([USE_OCTASIC], [yes])
AM_CONDITIONAL([USE_OCTASIC], [test "$USE_OCTASIC" = 'yes'])
octasic_dir='$(top_srcdir)/xpp/oct612x'
AC_SUBST([OCTASIC_CFLAGS], ["-I$octasic_dir/include -I$octasic_dir/octdeviceapi -I$octasic_dir/octdeviceapi/oct6100api"])
AC_SUBST([TOOLSVERSION], m4_esyscmd([build_tools/make_version . dahdi/tools]))
AC_CONFIG_FILES([
makeopts
version.c
Makefile
doc/Makefile
hotplug/Makefile
ppp/Makefile
xpp/Makefile
xpp/xtalk/Makefile
xpp/oct612x/Makefile
xpp/perl_modules/Makefile
trunkdev/Makefile
])
AC_OUTPUT
AC_MSG_NOTICE(*** dahdi-tools build successfully configured ***)

33
contrib/jenkins.sh Executable file
View File

@ -0,0 +1,33 @@
#!/bin/sh
# jenkins build helper script for dahdi-tools. This is how we build on jenkins.osmocom.org
if ! [ -x "$(command -v osmo-build-dep.sh)" ]; then
echo "Error: We need to have scripts/osmo-deps.sh from http://git.osmocom.org/osmo-ci/ in PATH !"
exit 2
fi
set -ex
base="$PWD"
deps="$base/deps"
inst="$deps/install"
export deps inst
osmo-clean-workspace.sh
mkdir "$deps" || true
cd "$deps"
if [ -d dahdi-linux ]; then
(cd dahdi-linux && git fetch && git checkout -f -B master origin/master)
else
git clone https://git.osmocom.org/dahdi-linux
fi
cd $base
autoreconf -fi
./configure --with-dahdi="$deps/dahdi-linux"
$MAKE $PARALLEL_MAKE
osmo-clean-workspace.sh

133
dahdi-bash-completion Normal file
View File

@ -0,0 +1,133 @@
# Check for bash
[ -z "$BASH_VERSION" ] && return
__dahdi_span_assignments() {
local cur prev has_cmd i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
has_cmd=0
for (( i=0; i < COMP_CWORD; i++)); do
case "${COMP_WORDS[$i]}" in
add | auto | dumpconfig | list | remove)
has_cmd=1
break
;;
esac
done
case "$prev" in
-k | --key) COMPREPLY=( $(compgen -W 'devpath hwid location' -- $cur) ) ;;
*)
case "$cur" in
-*) COMPREPLY=( ${COMPREPLY[@]} $(compgen -W \
'-h -k -n -v --help --key --dry-run --verbose' -- $cur ) )
;;
*)
if [ "$has_cmd" = 1 ]; then
COMPREPLY=( ${COMPREPLY[@]} $(shopt -s nullglob; \
echo /sys/bus/dahdi_devices/devices/* ) )
else
COMPREPLY=( ${COMPREPLY[@]} $(compgen -W \
'add auto dumpconfig list remove' -- $cur) )
fi
;;
esac
;;
esac
}
complete -F __dahdi_span_assignments dahdi_span_assignments
__dahdi_span_types() {
local cur prev has_cmd i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
has_cmd=0
for (( i=0; i < COMP_CWORD; i++)); do
case "${COMP_WORDS[$i]}" in
dumpconfig | list | set | compare)
has_cmd=1
break
;;
esac
done
case "$prev" in
-k | --key) COMPREPLY=( $(compgen -W 'devpath hwid location' -- $cur) ) ;;
--line-type) COMPREPLY=( $(compgen -W 'E1 J1 T1' -- $cur) ) ;;
*)
case "$cur" in
-*) COMPREPLY=( ${COMPREPLY[@]} $(compgen -W \
'-h -k -n -v --help --key --dry-run --line-type --verbose' -- $cur ) )
;;
*)
if [ "$has_cmd" = 1 ]; then
# FIXME: check if devices are settable?
COMPREPLY=( ${COMPREPLY[@]} $( \
grep -l '[EJT]1' /sys/devices/pci0000:00/0000:00:10.4/usb1/1-1/xbus-00/*/spantype 2>/dev/null | sed -e 's|/spantype||') )
else
COMPREPLY=( ${COMPREPLY[@]} $(compgen -W \
'dumpconfig list set compare' -- $cur) )
fi
;;
esac
;;
esac
}
complete -F __dahdi_span_types dahdi_span_types
__dahdi_genconf() {
local cur
COMPREPLY=()
prev=${COMP_WORDS[COMP_CWORD-1]}
cur=${COMP_WORDS[COMP_CWORD]}
case "$prev" in
--line-type) COMPREPLY=( $(compgen -W 'E1 J1 T1' -- $cur) ) ;;
*)
case "$cur" in
-*) COMPREPLY+=( $(compgen -W '-F -v -V --freepbx --version --verbose --line-type' -- $cur ) ) ;;
*)
COMPREPLY+=( $(compgen -W "$( perl -e 'my $file = "\u$ARGV[0]";
# Complete module name. Translate the case of the
# first letter
my @pats = map {"$_/Dahdi/Config/Gen/$file*.pm"} @INC;
foreach (@pats) {
foreach(glob) {
s|.*/||;
s|.pm$||;
s|^(.)|lc($1)|e;
print "$_ "
}
}')" -- $cur ) )
;;
esac
;;
esac
}
complete -F __dahdi_genconf dahdi_genconf
__dahdi_cfg() {
local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
case "$prev" in
-c) COMPREPLY=( $(compgen -f -- $cur) ) ;;
-S) COMPREPLY=( $(ls -d /sys/bus/dahdi_spans/devices/* 2>/dev/null | sed -e 's/.*-//') ) ;;
# FIXME: A similar completion for -C (<chan1>-<chan2>)
*)
COMPREPLY=( ${COMPREPLY[@]} $(compgen -W \
'-c -C -f -h -s -S -t -v ' -- $cur ) )
;;
esac
}
# Disable until -c works properly
#complete -F __dahdi_cfg dahdi_cfg

View File

@ -16,6 +16,7 @@
# Should-Stop: $network $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: DAHDI kernel modules
# Description: dahdi - load and configure DAHDI modules
### END INIT INFO
@ -143,15 +144,18 @@ hotplug_exit_after_load() {
# Initialize the Xorcom Astribank (xpp/) using perl utiliites:
xpp_startup() {
if [ "$ASTERISK_SUPPORTS_DAHDI_HOTPLUG" = yes ]; then
aas_param='/sys/module/dahdi/parameters/auto_assign_spans'
aas=`cat "$aas_param" 2>/dev/null`
if [ "$aas" = 0 ]; then
echo 1>&2 "Don't wait for Astribanks (use Asterisk hotplug-support)"
return 0
fi
fi
# do nothing if there are no astribank devices:
if ! /usr/share/dahdi/waitfor_xpds; then return 0; fi
hotplug_exit_after_load
# overriding locales for the above two, as perl can be noisy
# when locales are missing.
# No register all the devices if they didn't auto-register:
LC_ALL=C dahdi_registration on
}
@ -226,21 +230,25 @@ load_modules() {
echo ""
}
# Make sure that either dahdi is loaded or modprobe-able
dahdi_modules_loadable() {
modinfo dahdi >/dev/null 2>&1 || lsmod | grep -q -w ^dahdi
}
if [ ! -x "$DAHDI_CFG" ]; then
echo "dahdi_cfg not executable"
exit 0
fi
if [ ! -f /etc/dahdi/system.conf ]; then
echo "/etc/dahdi/system.conf not found. Nothing to do."
exit 0
fi
RETVAL=0
# See how we were called.
case "$1" in
start)
if ! dahdi_modules_loadable; then
echo "No DAHDI modules on the system. Not starting"
exit 0
fi
if hotplug_should_load_modules; then
load_modules
fi
@ -258,10 +266,8 @@ case "$1" in
xpp_startup
if [ ! -e /proc/dahdi/1 ]; then
echo "No hardware timing source found in /proc/dahdi, loading dahdi_dummy"
modprobe dahdi_dummy 2> /dev/null
fi
# Assign all spans that weren't handled via udev + /etc/dahdi/assigned-spans.conf
/usr/share/dahdi/dahdi_auto_assign_compat
if [ $system = debian ]; then
echo -n "Running dahdi_cfg: "
@ -281,8 +287,12 @@ case "$1" in
$FXOTUNE -s || :
fi
# Set the right Astribanks ticker:
LC_ALL=C xpp_sync "$XPP_SYNC"
# Do not try to call xpp_sync if there are no Astribank devices
# installed.
if test -e /sys/bus/astribanks; then
# Set the right Astribanks ticker:
LC_ALL=C xpp_sync "$XPP_SYNC"
fi
hpec_start
;;

18
dahdi.rules Normal file
View File

@ -0,0 +1,18 @@
ACTION!="add", GOTO="dahdi_add_end"
# DAHDI devices with ownership/permissions for running as non-root
SUBSYSTEM=="dahdi", OWNER="asterisk", GROUP="asterisk", MODE="0660"
# Backward compat names: /dev/dahdi/<channo>
SUBSYSTEM=="dahdi_channels", SYMLINK+="dahdi/%m"
# Add persistant names as well
SUBSYSTEM=="dahdi_channels", ATTRS{hardware_id}!="", SYMLINK+="dahdi/devices/%s{hardware_id}/%s{local_spanno}/%n"
SUBSYSTEM=="dahdi_channels", ATTRS{location}!="", SYMLINK+="dahdi/devices/@%s{location}/%s{local_spanno}/%n"
LABEL="dahdi_add_end"
# hotplug scripts
SUBSYSTEM=="dahdi_devices", RUN+="%E{DAHDI_TOOLS_ROOTDIR}/usr/share/dahdi/dahdi_handle_device"
SUBSYSTEM=="dahdi_spans", RUN+="%E{DAHDI_TOOLS_ROOTDIR}/usr/share/dahdi/dahdi_span_config"

View File

@ -29,13 +29,18 @@
#include <stdio.h>
#include <getopt.h>
#include <signal.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <errno.h>
#include <dirent.h>
#include <stdbool.h>
#include <dahdi/user.h>
#include "tonezone.h"
@ -85,6 +90,11 @@ static struct dahdi_lineconfig lc[DAHDI_MAX_SPANS];
static struct dahdi_chanconfig cc[DAHDI_MAX_CHANNELS];
static int only_span = 0;
static int restrict_channels = 0;
static int selected_channels[DAHDI_MAX_CHANNELS];
static int declared_spans[DAHDI_MAX_SPANS];
static struct dahdi_attach_echocan ae[DAHDI_MAX_CHANNELS];
static struct dahdi_dynamic_span zds[NUM_DYNAMIC];
@ -97,7 +107,7 @@ static int fiftysixkhdlc[DAHDI_MAX_CHANNELS];
static int spans=0;
static int fo_real = 1;
static int dry_run = 0;
static int verbose = 0;
@ -130,6 +140,97 @@ static const char *laws[] = {
"A-law"
};
static bool _are_all_spans_assigned(const char *device_path)
{
char attribute[1024];
int res;
FILE *fp;
int span_count;
DIR *dirp;
struct dirent *dirent;
snprintf(attribute, sizeof(attribute) - 1,
"%s/span_count", device_path);
fp = fopen(attribute, "r");
if (NULL == fp) {
fprintf(stderr, "Failed to open '%s'.\n", attribute);
return false;
}
res = fscanf(fp, "%d", &span_count);
fclose(fp);
if (EOF == res) {
fprintf(stderr, "Failed to read '%s'.\n", attribute);
return false;
}
dirp = opendir(device_path);
while (span_count) {
dirent = readdir(dirp);
if (NULL == dirent)
break;
if (!strncmp("span-", dirent->d_name, 5)) {
--span_count;
}
}
closedir(dirp);
return (span_count > 0) ? false : true;
}
/**
* are_all_spans_assigned - Look in sysfs to see if all spans for a device are assigned.
*
* Returns true if there are $span_count child spans of all devices, or false
* otherwise.
*/
static bool are_all_spans_assigned(void)
{
DIR *dirp;
struct dirent *dirent;
bool res = true;
char device_path[1024];
dirp = opendir("/sys/bus/dahdi_devices/devices");
if (!dirp) {
/* If we cannot open dahdi_devices, either dahdi isn't loaded,
* or we're using an older version of DAHDI that doesn't use
* sysfs. */
return true;
}
while (true && res) {
dirent = readdir(dirp);
if (NULL == dirent)
break;
if (!strcmp(dirent->d_name, ".") ||
!strcmp(dirent->d_name, ".."))
continue;
snprintf(device_path, sizeof(device_path)-1,
"/sys/bus/dahdi_devices/devices/%s", dirent->d_name);
res = _are_all_spans_assigned(device_path);
}
closedir(dirp);
errno = 0;
return res;
}
static bool wait_for_all_spans_assigned(unsigned long timeout_sec)
{
bool all_assigned = are_all_spans_assigned();
unsigned int timeout = 10*timeout_sec;
while (!all_assigned && --timeout) {
usleep(100000);
all_assigned = are_all_spans_assigned();
}
return all_assigned;
}
static const char *sigtype_to_str(const int sig)
{
switch (sig) {
@ -176,16 +277,6 @@ static const char *sigtype_to_str(const int sig)
}
}
int ind_ioctl(int channo, int fd, int op, void *data)
{
struct dahdi_indirect_data ind;
ind.chan = channo;
ind.op = op;
ind.data = data;
return ioctl(fd, DAHDI_INDIRECT, &ind);
}
static void clear_fields()
{
@ -238,6 +329,22 @@ static char *trim(char *buf)
return buf;
}
static int skip_channel(int x)
{
if (restrict_channels) {
if (!selected_channels[x])
return 1;
} else {
if (only_span && !declared_spans[only_span]) {
fprintf(stderr,
"Error: analog span %d given to '-S', without '-C' restriction.\n",
only_span);
exit(1);
}
}
return 0;
}
static int parseargs(char *input, char *output[], int maxargs, char sep)
{
char *c;
@ -268,11 +375,10 @@ static int parseargs(char *input, char *output[], int maxargs, char sep)
int dspanconfig(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int chans;
int timing;
argc = res = parseargs(args, realargs, 4, ',');
res = parseargs(args, realargs, 4, ',');
if (res != 4) {
error("Incorrect number of arguments to 'dynamic' (should be <driver>,<address>,<num channels>, <timing>)\n");
return -1;
@ -321,6 +427,7 @@ int spanconfig(char *keyword, char *args)
error("Span number should be a valid span number, not '%s'\n", realargs[0]);
return -1;
}
declared_spans[span] = 1;
res = sscanf(realargs[1], "%d", &timing);
if ((res != 1) || (timing < 0) || (timing > MAX_TIMING)) {
error("Timing should be a number from 0 to %d, not '%s'\n",
@ -626,6 +733,14 @@ static int chanconfig(char *keyword, char *args)
} else {
fprintf(stderr, "Huh? (%s)\n", keyword);
}
if (cc[x].sigtype != DAHDI_SIG_CAS &&
cc[x].sigtype != DAHDI_SIG_DACS &&
cc[x].sigtype != DAHDI_SIG_DACS_RBS) {
if (NULL != idle) {
fprintf(stderr, "WARNING: idlebits are not valid on %s channels.\n", sig[x]);
}
}
}
}
return 0;
@ -670,19 +785,22 @@ static int setfiftysixkhdlc(char *keyword, char *args)
return 0;
}
static void apply_fiftysix(void)
static int apply_fiftysix(void)
{
int x;
int rate;
int chanfd;
for (x = 1; x < DAHDI_MAX_CHANNELS; x++) {
if (skip_channel(x) || !cc[x].sigtype)
continue;
chanfd = open("/dev/dahdi/channel", O_RDWR);
if (chanfd == -1) {
fprintf(stderr,
"Couldn't open /dev/dahdi/channel: %s\n",
strerror(errno));
exit(-1);
return -1;
}
if (ioctl(chanfd, DAHDI_SPECIFY, &x)) {
@ -703,6 +821,7 @@ static void apply_fiftysix(void)
}
close(chanfd);
}
return 0;
}
static int setechocan(char *keyword, char *args)
@ -765,13 +884,12 @@ static int unimplemented(char *keyword, char *args)
int ctcss(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int rxtone;
int rxtag;
int txtone;
int isdcs = 0;
argc = res = parseargs(args, realargs, 3, ',');
res = parseargs(args, realargs, 3, ',');
if (res != 3) {
error("Incorrect number of arguments to 'ctcss' (should be <rxtone>,<rxtag>,<txtone>)\n");
return -1;
@ -818,10 +936,9 @@ int ctcss(char *keyword, char *args)
int dcsrx(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int rxtone;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'dcsrx' (should be <rxtone>)\n");
return -1;
@ -841,11 +958,10 @@ int dcsrx(char *keyword, char *args)
int tx(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int txtone;
int isdcs = 0;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'tx' (should be <txtone>)\n");
return -1;
@ -870,10 +986,9 @@ int tx(char *keyword, char *args)
int debounce_time(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'debouncetime' (should be <value>)\n");
return -1;
@ -893,10 +1008,9 @@ int debounce_time(char *keyword, char *args)
int burst_time(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'bursttime' (should be <value>)\n");
return -1;
@ -916,10 +1030,9 @@ int burst_time(char *keyword, char *args)
int tx_gain(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'txgain' (should be <value>)\n");
return -1;
@ -937,10 +1050,9 @@ int tx_gain(char *keyword, char *args)
int rx_gain(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'rxgain' (should be <value>)\n");
return -1;
@ -958,10 +1070,9 @@ int rx_gain(char *keyword, char *args)
int de_emp(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'de-emp' (should be <value>)\n");
return -1;
@ -981,10 +1092,9 @@ int de_emp(char *keyword, char *args)
int pre_emp(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'pre_emp' (should be <value>)\n");
return -1;
@ -1004,10 +1114,9 @@ int pre_emp(char *keyword, char *args)
int invert_cor(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'invertcor' (should be <value>)\n");
return -1;
@ -1031,10 +1140,9 @@ int invert_cor(char *keyword, char *args)
int ext_tone(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'exttone' (should be <value>)\n");
return -1;
@ -1060,11 +1168,10 @@ int ext_tone(char *keyword, char *args)
int cor_thresh(char *keyword, char *args)
{
static char *realargs[10];
int argc;
int res;
int val;
int x = 0;
argc = res = parseargs(args, realargs, 1, ',');
res = parseargs(args, realargs, 1, ',');
if (res != 1) {
error("Incorrect number of arguments to 'corthresh' (should be <value>)\n");
return -1;
@ -1091,6 +1198,7 @@ static int rad_chanconfig(char *keyword, char *args)
int res = 0;
int x,i,n;
struct dahdi_radio_param p;
int chanfd;
toneindex = 1;
bzero(chans, sizeof(chans));
@ -1099,8 +1207,21 @@ static int rad_chanconfig(char *keyword, char *args)
return -1;
for (x=1;x<DAHDI_MAX_CHANNELS;x++) {
if (chans[x]) {
const char *CHANNEL_FILENAME = "/dev/dahdi/channel";
chanfd = open(CHANNEL_FILENAME, O_RDWR);
if (-1 == chanfd) {
error("Failed to open '%s'.\n", CHANNEL_FILENAME);
exit(-1);
}
res = ioctl(chanfd, DAHDI_SPECIFY, &x);
if (res) {
error("Failed to open channel %d.\n", x);
close(chanfd);
continue;
}
p.radpar = DAHDI_RADPAR_NUMTONES;
if (ind_ioctl(x,fd,DAHDI_RADIO_GETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_GETPARAM,&p) == -1)
n = 0;
else
n = p.data;
@ -1108,7 +1229,7 @@ static int rad_chanconfig(char *keyword, char *args)
if (n)
{
p.radpar = DAHDI_RADPAR_INITTONE;
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1) {
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1) {
error("Cannot init tones for channel %d\n",x);
}
if (!rxtones[0]) for(i = 1; i <= n; i++)
@ -1118,7 +1239,7 @@ static int rad_chanconfig(char *keyword, char *args)
p.radpar = DAHDI_RADPAR_RXTONE;
p.index = i;
p.data = rxtones[i];
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set rxtone on channel %d\n",x);
}
if (rxtags[i])
@ -1126,7 +1247,7 @@ static int rad_chanconfig(char *keyword, char *args)
p.radpar = DAHDI_RADPAR_RXTONECLASS;
p.index = i;
p.data = rxtags[i];
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set rxtag on channel %d\n",x);
}
if (txtones[i])
@ -1134,7 +1255,7 @@ static int rad_chanconfig(char *keyword, char *args)
p.radpar = DAHDI_RADPAR_TXTONE;
p.index = i;
p.data = txtones[i];
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set txtone on channel %d\n",x);
}
} else { /* if we may have DCS receive */
@ -1143,7 +1264,7 @@ static int rad_chanconfig(char *keyword, char *args)
p.radpar = DAHDI_RADPAR_RXTONE;
p.index = 0;
p.data = rxtones[0];
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set DCS rxtone on channel %d\n",x);
}
}
@ -1152,7 +1273,7 @@ static int rad_chanconfig(char *keyword, char *args)
p.radpar = DAHDI_RADPAR_TXTONE;
p.index = 0;
p.data = txtones[0];
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set default txtone on channel %d\n",x);
}
}
@ -1160,41 +1281,43 @@ static int rad_chanconfig(char *keyword, char *args)
{
p.radpar = DAHDI_RADPAR_DEBOUNCETIME;
p.data = debouncetime;
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set debouncetime on channel %d\n",x);
}
if (bursttime)
{
p.radpar = DAHDI_RADPAR_BURSTTIME;
p.data = bursttime;
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set bursttime on channel %d\n",x);
}
p.radpar = DAHDI_RADPAR_DEEMP;
p.data = deemp;
ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p);
ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p);
p.radpar = DAHDI_RADPAR_PREEMP;
p.data = preemp;
ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p);
ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p);
p.radpar = DAHDI_RADPAR_TXGAIN;
p.data = txgain;
ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p);
ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p);
p.radpar = DAHDI_RADPAR_RXGAIN;
p.data = rxgain;
ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p);
ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p);
p.radpar = DAHDI_RADPAR_INVERTCOR;
p.data = invertcor;
ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p);
ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p);
p.radpar = DAHDI_RADPAR_EXTRXTONE;
p.data = exttone;
ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p);
ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p);
if (corthresh)
{
p.radpar = DAHDI_RADPAR_CORTHRESH;
p.data = corthresh - 1;
if (ind_ioctl(x,fd,DAHDI_RADIO_SETPARAM,&p) == -1)
if (ioctl(chanfd,DAHDI_RADIO_SETPARAM,&p) == -1)
error("Cannot set corthresh on channel %d\n",x);
}
close(chanfd);
}
}
clear_fields();
@ -1221,6 +1344,8 @@ static void printconfig(int fd)
"Configuration\n"
"======================\n\n", vi.version, vi.echo_canceller);
for (x = 0; x < spans; x++) {
if (only_span && only_span != lc[x].span)
continue;
printf("SPAN %d: %3s/%4s Build-out: %s\n",
lc[x].span,
(lc[x].lineconfig & DAHDI_CONFIG_D4 ? "D4" :
@ -1238,6 +1363,8 @@ static void printconfig(int fd)
if (verbose > 1) {
printf("\nChannel map:\n\n");
for (x=1;x<DAHDI_MAX_CHANNELS;x++) {
if (skip_channel(x))
continue;
if ((cc[x].sigtype != DAHDI_SIG_SLAVE) && (cc[x].sigtype)) {
configs++;
ps = 0;
@ -1261,6 +1388,8 @@ static void printconfig(int fd)
}
} else {
for (x=1;x<DAHDI_MAX_CHANNELS;x++) {
if (skip_channel(x))
continue;
if (cc[x].sigtype)
configs++;
}
@ -1355,19 +1484,62 @@ static void usage(char *argv0, int exitcode)
" -h -- Generate this help statement\n"
" -s -- Shutdown spans only\n"
" -t -- Test mode only, do not apply\n"
" -C <chan_list> -- Only configure specified channels\n"
" -S <spanno> -- Only configure specified span\n"
" -v -- Verbose (more -v's means more verbose)\n"
,c);
exit(exitcode);
}
static int chan_restrict(char *str)
{
if (apply_channels(selected_channels, str) < 0)
return 0;
restrict_channels = 1;
return 1;
}
static int span_restrict(char *str)
{
long spanno;
char *endptr;
spanno = strtol(str, &endptr, 10);
if (endptr == str) {
fprintf(stderr, "Missing valid span number after '-S'\n");
return 0;
}
if (*endptr != '\0') {
fprintf(stderr, "Extra garbage after span number in '-S'\n");
return 0;
}
only_span = spanno;
return 1;
}
static const char *SEM_NAME = "dahdi_cfg";
static sem_t *lock = SEM_FAILED;
static void signal_handler(int signal)
{
if (SEM_FAILED != lock) {
sem_unlink(SEM_NAME);
}
/* The default handler should have been restored before this handler was
* called, so we can let the "normal" processing finish the cleanup. */
raise(signal);
}
int main(int argc, char *argv[])
{
int c;
char *buf;
char *key, *value;
int x,found;
int exit_code = 0;
struct sigaction act;
while((c = getopt(argc, argv, "fthc:vsd::")) != -1) {
while((c = getopt(argc, argv, "fthc:vsd::C:S:")) != -1) {
switch(c) {
case 'c':
filename=optarg;
@ -1385,11 +1557,19 @@ int main(int argc, char *argv[])
force++;
break;
case 't':
fo_real = 0;
dry_run = 1;
break;
case 's':
stopmode = 1;
break;
case 'C':
if (!chan_restrict(optarg))
usage(argv[0], 1);
break;
case 'S':
if (!span_restrict(optarg))
usage(argv[0], 1);
break;
case 'd':
if (optarg)
debug = atoi(optarg);
@ -1403,12 +1583,28 @@ int main(int argc, char *argv[])
fprintf(stderr, "%s\n", dahdi_tools_version);
}
if (!restrict_channels && only_span) {
error("-S requires -C\n");
goto finish;
}
if (!restrict_channels && !only_span) {
bool all_assigned = wait_for_all_spans_assigned(5);
if (!all_assigned) {
fprintf(stderr,
"Timeout waiting for all spans to be assigned.\n");
}
}
if (fd == -1) fd = open(MASTER_DEVICE, O_RDWR);
if (fd < 0) {
error("Unable to open master device '%s'\n", MASTER_DEVICE);
goto finish;
}
cf = fopen(filename, "r");
if (strcmp(filename, "-") == 0)
cf = fdopen(STDIN_FILENO, "r");
else
cf = fopen(filename, "r");
if (cf) {
while((buf = readline())) {
if (*buf == 10) /* skip new line */
@ -1458,47 +1654,106 @@ finish:
if (verbose) {
printconfig(fd);
}
if (!fo_real)
exit(0);
if (dry_run)
exit(0);
if (debug & DEBUG_APPLY) {
printf("About to open Master device\n");
fflush(stdout);
}
for (x=0;x<numdynamic;x++) {
/* destroy them all */
ioctl(fd, DAHDI_DYNAMIC_DESTROY, &zds[x]);
sigemptyset(&act.sa_mask);
act.sa_handler = signal_handler;
act.sa_flags = SA_RESETHAND;
if (sigaction(SIGTERM, &act, NULL) == -1) {
perror("Failed to install SIGTERM handler.");
exit(1);
}
if (sigaction(SIGINT, &act, NULL) == -1) {
perror("Failed to install SIGINT handler.");
exit(1);
}
lock = sem_open(SEM_NAME, O_CREAT, O_RDWR, 1);
if (SEM_FAILED == lock) {
perror("Unable to create 'dahdi_cfg' mutex");
exit_code = 1;
goto release_sem;
}
if (-1 == sem_wait(lock)) {
perror("Failed to wait for 'dahdi_cfg' mutex");
exit_code = 1;
goto unlink_sem;
}
if (!restrict_channels && !only_span) {
for (x=0;x<numdynamic;x++) {
/* destroy them all */
ioctl(fd, DAHDI_DYNAMIC_DESTROY, &zds[x]);
}
}
if (stopmode) {
for (x=0;x<spans;x++) {
if (only_span && lc[x].span != only_span)
continue;
if (ioctl(fd, DAHDI_SHUTDOWN, &lc[x].span)) {
fprintf(stderr, "DAHDI shutdown failed: %s\n", strerror(errno));
close(fd);
exit(1);
exit_code = 1;
goto release_sem;
}
}
exit(1);
exit_code = 1;
goto release_sem;
}
for (x=0;x<spans;x++) {
if (only_span && lc[x].span != only_span)
continue;
if (ioctl(fd, DAHDI_SPANCONFIG, lc + x)) {
fprintf(stderr, "DAHDI_SPANCONFIG failed on span %d: %s (%d)\n", lc[x].span, strerror(errno), errno);
close(fd);
exit(1);
exit_code = 1;
goto release_sem;
}
}
for (x=0;x<numdynamic;x++) {
if (ioctl(fd, DAHDI_DYNAMIC_CREATE, &zds[x])) {
fprintf(stderr, "DAHDI dynamic span creation failed: %s\n", strerror(errno));
close(fd);
exit(1);
if (!restrict_channels && !only_span) {
sem_post(lock);
for (x=0;x<numdynamic;x++) {
if (ioctl(fd, DAHDI_DYNAMIC_CREATE, &zds[x])) {
fprintf(stderr, "DAHDI dynamic span creation failed: %s\n", strerror(errno));
close(fd);
exit_code = 1;
goto release_sem;
}
wait_for_all_spans_assigned(1);
}
if (-1 == sem_wait(lock)) {
perror("Failed to wait for 'dahdi_cfg' mutex after creating dynamic spans");
exit_code = 1;
goto unlink_sem;
}
}
for (x=1;x<DAHDI_MAX_CHANNELS;x++) {
struct dahdi_params current_state;
int master;
int needupdate = force;
if (skip_channel(x)) {
if (debug & DEBUG_APPLY) {
printf("Skip device %d\n", x);
fflush(stdout);
}
continue;
}
if (debug & DEBUG_APPLY) {
printf("Configuring device %d\n", x);
fflush(stdout);
@ -1609,7 +1864,8 @@ finish:
" to channel 16 of an E1 CAS span\n");
}
close(fd);
exit(1);
exit_code = 1;
goto release_sem;
}
ae[x].chan = x;
@ -1620,7 +1876,8 @@ finish:
if (ioctl(fd, DAHDI_ATTACH_ECHOCAN, &ae[x])) {
fprintf(stderr, "DAHDI_ATTACH_ECHOCAN failed on channel %d: %s (%d)\n", x, strerror(errno), errno);
close(fd);
exit(1);
exit_code = 1;
goto release_sem;
}
}
if (0 == numzones) {
@ -1647,16 +1904,28 @@ finish:
if (ioctl(fd, DAHDI_DEFAULTZONE, &deftonezone)) {
fprintf(stderr, "DAHDI_DEFAULTZONE failed: %s (%d)\n", strerror(errno), errno);
close(fd);
exit(1);
exit_code = 1;
goto release_sem;
}
}
for (x=0;x<spans;x++) {
if (only_span && lc[x].span != only_span)
continue;
if (ioctl(fd, DAHDI_STARTUP, &lc[x].span)) {
fprintf(stderr, "DAHDI startup failed: %s\n", strerror(errno));
close(fd);
exit(1);
exit_code = 1;
goto release_sem;
}
}
apply_fiftysix();
exit(0);
exit_code = apply_fiftysix();
release_sem:
if (SEM_FAILED != lock)
sem_post(lock);
unlink_sem:
if (SEM_FAILED != lock)
sem_unlink(SEM_NAME);
exit(exit_code);
}

View File

@ -53,10 +53,14 @@ void display_help(char *argv0, int exitcode)
fprintf(stderr, " -h, --help display help\n");
fprintf(stderr, " -s, --span <span num> specify the span\n");
fprintf(stderr, " -l, --loopback <localhost|networkline|"\
"networkpayload|off>\n"\
"networkpayload|loopup|"\
"loopdown|off>\n"\
"\t\tlocalhost - loop back towards host\n"\
"\t\tnetworkline - network line loopback\n"\
"\t\tnetworkpayload - network payload loopback\n");
"\t\tnetworkpayload - network payload loopback\n"\
"\t\tloopup - transmit loopup signal\n"\
"\t\tloopdown - transmit loopdown signal\n"\
"\t\toff - end loopback mode\n");
fprintf(stderr, " -i, --insert <fas|multi|crc|cas|prbs|bipolar>"\
"\n\t\tinsert an error of a specific type\n");
fprintf(stderr, " -r, --reset "\
@ -77,7 +81,6 @@ int main(int argc, char *argv[])
int doloopback = 0;
char *larg = NULL;
int sflag = 0;
int span = 1;
int iflag = 0;
char *iarg = NULL;
@ -105,16 +108,15 @@ int main(int argc, char *argv[])
while ((c = getopt_long(argc, argv, "hj:l:p:s:i:g:r",
long_options, &option_index)) != -1) {
switch (c) {
case 'h': /* local host loopback */
case 'h':
display_help(argv[0], 0);
break;
case 'l': /* network line loopback */
case 'l': /* loopback */
larg = optarg;
doloopback = 1;
break;
case 's': /* specify a span */
span = atoi(optarg);
sflag = 1;
break;
case 'i': /* insert an error */
iarg = optarg;
@ -138,17 +140,15 @@ int main(int argc, char *argv[])
if (!(doloopback || iflag || gflag || rflag)) {
s.spanno = span;
res = ioctl(ctl, DAHDI_SPANSTAT, &s);
if (res)
if (res || ((__u32)-1 == s.fecount))
printf("Error counters not supported by the driver"\
" for this span\n");
printf("Span %d:\n", span);
printf(">FEC : %d:\n", s.fecount);
printf(">CEC : %d:\n", s.crc4count);
printf(">CVC : %d:\n", s.cvcount);
printf(">EBC : %d:\n", s.ebitcount);
printf(">BEC : %d:\n", s.becount);
printf(">PRBS: %d:\n", s.prbs);
printf(">GES : %d:\n", s.errsec);
printf(">Framing Errors : %d:\n", s.fecount);
printf(">CRC Errors : %d:\n", s.crc4count);
printf(">Code Violations : %d:\n", s.cvcount);
printf(">E-bit Count : %d:\n", s.ebitcount);
printf(">General Errored Seconds : %d:\n", s.errsec);
return 0;
}
@ -165,6 +165,12 @@ int main(int argc, char *argv[])
} else if (!strcasecmp(larg, "networkpayload")) {
printf("Span %d: network payload loopback ON\n", span);
m.command = DAHDI_MAINT_NETWORKPAYLOADLOOP;
} else if (!strcasecmp(larg, "loopup")) {
printf("Span %d: transmitting loopup signal\n", span);
m.command = DAHDI_MAINT_LOOPUP;
} else if (!strcasecmp(larg, "loopdown")) {
printf("Span %d: transmitting loopdown signal\n", span);
m.command = DAHDI_MAINT_LOOPDOWN;
} else if (!strcasecmp(larg, "off")) {
printf("Span %d: loopback OFF\n", span);
m.command = DAHDI_MAINT_NONE;
@ -173,9 +179,21 @@ int main(int argc, char *argv[])
}
res = ioctl(ctl, DAHDI_MAINT, &m);
if (res)
if (res) {
printf("This type of looping not supported by the"\
" driver for this span\n");
return 1;
}
/* Leave the loopup/loopdown signal on the line for
* five seconds according to AT&T TR 54016
*/
if ((m.command == DAHDI_MAINT_LOOPUP) ||
(m.command == DAHDI_MAINT_LOOPDOWN)) {
sleep(5);
m.command = DAHDI_MAINT_NONE;
ioctl(ctl, DAHDI_MAINT, &m);
}
}
if (iflag) {

View File

@ -427,6 +427,14 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
fprintf(stderr, "Writing pre-echo combined stream to %s\n", optarg);
file_is_wav[MON_PRE_BRX] = filename_is_wav(optarg);
if (file_is_wav[MON_PRE_BRX]) {
wavheader_init(&wavheaders[MON_PRE_BRX], 1);
if (fwrite(&wavheaders[MON_PRE_BRX], 1, sizeof(struct wavheader), ofh[MON_PRE_BRX]) != sizeof(struct wavheader)) {
fprintf(stderr, "Could not write wav header to %s: %s\n", optarg, strerror(errno));
exit(EXIT_FAILURE);
}
}
preecho = 1;
savefile = 1;
break;
@ -763,12 +771,6 @@ int main(int argc, char *argv[])
if (!(file_is_wav[i]))
continue;
rewind(ofh[i]);
if (fread(&wavheaders[i], 1, sizeof(struct wavheader), ofh[i]) != sizeof(struct wavheader)) {
fprintf(stderr, "Failed to read in a full wav header. Expect bad things.\n");
}
wavheaders[i].riff_chunk_size = (bytes_written[i]) + sizeof(struct wavheader) - 8; /* filesize - 8 */
wavheaders[i].data_data_size = bytes_written[i];

346
dahdi_pcap.c Normal file
View File

@ -0,0 +1,346 @@
/*
* Capturing a pcap from the DAHDI interface
*
* Copyright (C) 2011 Torrey Searle
*
* ISDN support added by Horacio Peña
* Command line cleanups by Sverker Abrahamsson
*
* Requirements:
* - pcap development library
* - DAHDI_MIRROR ioctl which isn't enabled by default in dahdi-linux
* To enable this unsupported feature, #define CONFIG_DAHDI_MIRROR
* in dahdi-linux
* - To build this program call the 'make dahdi_pcap' target
*/
/*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2 as published by the
* Free Software Foundation. See the LICENSE file included with
* this program for more details.
*/
#include <stdio.h>
#include <fcntl.h>
#include <dahdi/user.h>
#include <sys/time.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <pcap.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <getopt.h>
#include <linux/if_packet.h>
#define BLOCK_SIZE 512
#define MAX_CHAN 16
//char ETH_P_LAPD[2] = {0x00, 0x30};
struct mtp2_phdr {
u_int8_t sent;
u_int8_t annex_a_used;
u_int16_t link_number;
};
struct lapd_sll_hdr {
u_int16_t sll_pkttype; /* packet type */
u_int16_t sll_hatype;
u_int16_t sll_halen;
u_int8_t sll_addr[8];
u_int8_t sll_protocol[2]; /* protocol, should be ETH_P_LAPD */
};
struct chan_fds {
int rfd;
int tfd;
int chan_id;
int proto;
char tx_buf[BLOCK_SIZE * 4];
int tx_len;
char rx_buf[BLOCK_SIZE * 4];
int rx_len;
};
int make_mirror(long type, int chan)
{
int res = 0;
int fd = 0;
struct dahdi_bufferinfo bi;
fd = open("/dev/dahdi/pseudo", O_RDONLY);
memset(&bi, 0, sizeof(bi));
bi.txbufpolicy = DAHDI_POLICY_IMMEDIATE;
bi.rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
bi.numbufs = 32;
bi.bufsize = BLOCK_SIZE;
ioctl(fd, DAHDI_SET_BUFINFO, &bi);
res = ioctl(fd, type, &chan);
if(res)
{
printf("error setting channel err=%d!\n", res);
return -1;
}
return fd;
}
int log_packet(struct chan_fds * fd, char is_read, int we_are_network, pcap_dumper_t * dump)
{
unsigned char buf[BLOCK_SIZE * 4];
int res = 0;
struct pcap_pkthdr hdr;
struct mtp2_phdr * mtp2 = (struct mtp2_phdr *)buf;
struct lapd_sll_hdr * lapd = (struct lapd_sll_hdr *)buf;
unsigned char *dataptr = buf;
int datasize = sizeof(buf);
if(fd->proto == DLT_LINUX_LAPD)
{
dataptr += sizeof(struct lapd_sll_hdr);
datasize -= sizeof(struct lapd_sll_hdr);
}
else
{
dataptr += sizeof(struct mtp2_phdr);
datasize -= sizeof(struct mtp2_phdr);
}
memset(buf, 0, sizeof(buf));
if(is_read)
{
res = read(fd->rfd, dataptr, datasize);
if(fd->rx_len > 0 && res == fd->rx_len && !memcmp(fd->rx_buf, dataptr, res) )
{
//skipping dup
return 0;
}
memcpy(fd->rx_buf, dataptr, res);
fd->rx_len = res;
}
else
{
res = read(fd->tfd, dataptr, datasize);
if(fd->tx_len > 0 && res == fd->tx_len && !memcmp(fd->tx_buf, dataptr, res) )
{
//skipping dup
return 0;
}
memcpy(fd->tx_buf, dataptr, res);
fd->tx_len = res;
}
gettimeofday(&hdr.ts, NULL);
if(res > 0)
{
if(fd->proto == DLT_LINUX_LAPD)
{
hdr.caplen = res+sizeof(struct lapd_sll_hdr)-2;
hdr.len = res+sizeof(struct lapd_sll_hdr)-2;
lapd->sll_pkttype = htons(is_read ? PACKET_HOST : PACKET_OUTGOING);
lapd->sll_hatype = 0;
lapd->sll_halen = htons(8);
lapd->sll_addr[0] = we_are_network;
lapd->sll_protocol[0] = 0x00;
lapd->sll_protocol[1] = 0x30;
}
else
{
hdr.caplen = res+sizeof(struct mtp2_phdr);
hdr.len = res+sizeof(struct mtp2_phdr);
if(is_read)
{
mtp2->sent = 0;
mtp2->annex_a_used = 0;
}
else
{
mtp2->sent = 1;
mtp2->annex_a_used = 0;
}
mtp2->link_number = htons(fd->chan_id);
}
pcap_dump((u_char*)dump, &hdr, buf);
pcap_dump_flush(dump);
}
return 1;
}
void usage()
{
printf("Usage: dahdi_pcap [OPTIONS]\n");
printf("Capture packets from DAHDI channels to pcap file\n\n");
printf("Options:\n");
printf(" -p, --proto=[mtp2|lapd] The protocol to capture, default mtp2\n");
printf(" -c, --chan=<channels> Comma separated list of channels to capture from, max %d. Mandatory\n", MAX_CHAN);
printf(" -r, --role=[network|user] Is the local side the network or user side in ISDN?\n");
printf(" -f, --file=<filename> The pcap file to capture to. Mandatory\n");
printf(" -h, --help Display this text\n");
}
int main(int argc, char **argv)
{
struct chan_fds chans[MAX_CHAN];
char *filename = NULL;
int num_chans = 0;
int max_fd = 0;
int proto = DLT_MTP2_WITH_PHDR;
int we_are_network = 0;
int i;
int packetcount;
int c;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"proto", required_argument, 0, 'p'},
{"chan", required_argument, 0, 'c'},
{"role", required_argument, 0, 'r'},
{"file", required_argument, 0, 'f'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0}
};
c = getopt_long(argc, argv, "p:c:r:f:?",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'p':
// Protocol
if(strcasecmp("LAPD", optarg)==0)
{
proto = DLT_LINUX_LAPD;
}
else if(argc > 0 && strcasecmp("MTP2", argv[1])==0)
{
proto = DLT_MTP2_WITH_PHDR;
}
break;
case 'c':
// TODO Should it be possible to override protocol per channel?
// Channels, comma separated list
while(optarg != NULL && num_chans < MAX_CHAN)
{
int chan = atoi(strsep(&optarg, ","));
chans[num_chans].tfd = make_mirror(DAHDI_TXMIRROR, chan);
chans[num_chans].rfd = make_mirror(DAHDI_RXMIRROR, chan);
chans[num_chans].chan_id = chan;
chans[num_chans].proto = proto;
if(chans[num_chans].tfd > max_fd)
{
max_fd = chans[num_chans].tfd;
}
if(chans[num_chans].rfd > max_fd)
{
max_fd = chans[num_chans].rfd;
}
num_chans++;
}
max_fd++;
break;
case 'r':
if (!strcasecmp("network", optarg))
we_are_network = 1;
else if (!strcasecmp("user", optarg))
we_are_network = 0;
else {
fprintf(stderr, "Role must be user or network!\n");
exit(1);
}
break;
case 'f':
// File to capture to
filename=optarg;
break;
case 'h':
default:
// Usage
usage();
exit(0);
}
}
if((num_chans == 0) || (filename == NULL)) {
usage();
exit(0);
}
else
{
printf("Capturing protocol %s on channels ", (proto == DLT_MTP2_WITH_PHDR ? "mtp2":"lapd"));
for(i = 0; i < num_chans; i++)
{
printf("%d", chans[i].chan_id);
if(i<num_chans-1)
{
printf(", ");
}
}
printf(" to file %s\n", filename);
}
pcap_t * pcap = pcap_open_dead(chans[0].proto, BLOCK_SIZE*4);
pcap_dumper_t * dump = pcap_dump_open(pcap, filename);
packetcount=0;
while(1)
{
fd_set rd_set;
FD_ZERO(&rd_set);
for(i = 0; i < num_chans; i++)
{
FD_SET(chans[i].tfd, &rd_set);
FD_SET(chans[i].rfd, &rd_set);
}
select(max_fd, &rd_set, NULL, NULL, NULL);
for(i = 0; i < num_chans; i++)
{
if(FD_ISSET(chans[i].rfd, &rd_set))
{
packetcount += log_packet(&chans[i], 1, we_are_network, dump);
}
if(FD_ISSET(chans[i].tfd, &rd_set))
{
packetcount += log_packet(&chans[i], 0, we_are_network, dump);
}
}
printf("Packets captured: %d\r", packetcount);
fflush(stdout);
}
return 0;
}

View File

@ -42,12 +42,35 @@ static inline int is_digital_span(struct dahdi_spaninfo *s)
return (s->linecompat > 0);
}
static int get_basechan(unsigned int spanno)
{
int res;
int basechan;
char filename[256];
FILE *fp;
snprintf(filename, sizeof(filename),
"/sys/bus/dahdi_spans/devices/span-%u/basechan", spanno);
fp = fopen(filename, "r");
if (NULL == fp) {
return -1;
}
res = fscanf(fp, "%d", &basechan);
fclose(fp);
if (EOF == res) {
return -1;
}
return basechan;
}
int main(int argc, char *argv[])
{
int ctl;
int x, y, z;
struct dahdi_params params;
unsigned int basechan = 1;
int direct_basechan;
struct dahdi_spaninfo s;
char buf[100];
char alarms[50];
@ -87,6 +110,14 @@ int main(int argc, char *argv[])
}
}
/* DAHDI-Linux 2.5.x exposes the base channel in sysfs. Let's
* try to look for it there in case there are holes in the span
* numbering. */
direct_basechan = get_basechan(x);
if (-1 != direct_basechan) {
basechan = direct_basechan;
}
alarms[0] = '\0';
if (s.alarms) {
if (s.alarms & DAHDI_ALARM_BLUE)
@ -95,11 +126,13 @@ int main(int argc, char *argv[])
strcat(alarms, "YEL/");
if (s.alarms & DAHDI_ALARM_RED) {
strcat(alarms, "RED/");
/* Extended alarm feature test. Allows compilation with
* versions of dahdi-linux prior to 2.4
*/
#ifdef DAHDI_ALARM_LFA
if (s.alarms & DAHDI_ALARM_LFA)
strcat(alarms, "LFA/");
if (s.alarms & DAHDI_ALARM_LMFA)
strcat(alarms, "LMFA/");
#endif /* ifdef DAHDI_ALARM_LFA */
}
if (s.alarms & DAHDI_ALARM_LOOPBACK)
@ -115,10 +148,35 @@ int main(int argc, char *argv[])
alarms[strlen(alarms)-1]='\0';
}
} else {
if (s.numchans)
strcpy(alarms, "OK");
else
if (s.numchans) {
#ifdef DAHDI_ALARM_LFA
/* If we continuously receive framing errors
* but our span is still in service, and we
* are configured for E1 & crc4. We've lost
* crc4-multiframe alignment
*/
if ((s.linecompat & DAHDI_CONFIG_CRC4) &&
(s.fecount > 0)) {
struct dahdi_spaninfo t;
memset(&t, 0, sizeof(t));
t.spanno = x;
sleep(1);
if (ioctl(ctl, DAHDI_SPANSTAT, &t))
continue;
/* Test fecount at two separate time
* intervals, if they differ, throw LMFA
*/
if ((t.fecount > s.fecount) &&
!t.alarms) {
strcat(alarms, "LMFA/");
}
}
#endif /* ifdef DAHDI_ALARM_LFA */
strcat(alarms, "OK");
} else {
strcpy(alarms, "UNCONFIGURED");
}
}
fprintf(stdout, "[%d]\n", x);
@ -169,7 +227,8 @@ int main(int argc, char *argv[])
if (s.lineconfig & DAHDI_CONFIG_ESF) fprintf(stdout, "ESF");
else if (s.lineconfig & DAHDI_CONFIG_D4) fprintf(stdout, "D4");
else if (s.lineconfig & DAHDI_CONFIG_CCS) fprintf(stdout, "CCS");
else if (s.lineconfig & DAHDI_CONFIG_CRC4) fprintf(stdout, "/CRC4");
else fprintf(stdout, "CAS");
if (s.lineconfig & DAHDI_CONFIG_CRC4) fprintf(stdout, "/CRC4");
fprintf(stdout, "\n");
} else {
/* this is an analog span */

399
dahdi_span_assignments Executable file
View File

@ -0,0 +1,399 @@
#! /bin/sh
#
# /usr/sbin/dahdi_span_assignments:
#
# this script can be used both from udev and
# from the command line to assign/unassign and list
# current span assignments.
#
# It uses a configuration file: $DAHDICONFDIR/assigned-spans.conf
# (default DAHDICONFDIR=/etc/dahdi)
#
# The first argument is an action:
# "auto" - trigger driver auto_assign attribute for given devices
# (no configuration file is used)
# "add" - assign (spans which are not already assigned), according
# to /etc/dahdi/assigned-spans.conf configuration file
# "remove" - unassign spans which are not already unassigned
# "list" - human-readable list of all spans (with/without assignments)
# "dumpconfig" - dump current assignments in a /etc/dahdi/assigned-spans.conf
# compatible format
#
# Without further arguments, it operates on all existing spans
# With one or more sysfs dahdi_devices it is limited to those.
#
# We may use alternative "keys" for device matching:
# * Available keys:
# - "hwid" - Hardware id attribute from sysfs
# - "@location" - Location attribute from sysfs (embeded inside '<>')
# - "/devpath" - The sysfs absolute devpath
#
# * During "dumpconfig", for each device we take the first available key:
# - The preference is: "hwid" or else "@location" or else "/devpath"
# - This can be overriden via the SPAN_ASSIGNMENTS_KEY environment variable
# or the '{-k|--key} key' command line option.
#
# * During "add":
# - Any key match is valid (hwid/location/devpath)
# - Shell globs (wildcards: '*', '?', '[...]') may be optionally used.
#
# Command line options:
# - The '-h|--help' show a usage message.
# - The '-n|--dry-run' affects the "add" and "remove" operations.
# - The '-v|--verbose' currently shows device matches during "add" operation.
# - The '-k <key>|--key <key>' overrides the SPAN_ASSIGNMENTS_KEY environment
# variable.
#
# Examples:
# dahdi_span_assignments list
# dahdi_span_assignments add # all unassigned devices
# dahdi_span_assignments add /sys/bus/dahdi_devices/devices/astribanks:xbus-00
# dahdi_span_assignments remove # all assigned devices
# dahdi_span_assignments -k location dumpconfig
#
devbase='/sys/bus/dahdi_devices/devices'
DAHDICONFDIR="${DAHDICONFDIR:-/etc/dahdi}"
DAHDISASSIGNEDSPANSCONF="${DAHDIASSIGNEDSPANSCONF:-"${DAHDICONFDIR}/assigned-spans.conf"}"
SPAN_ASSIGNMENTS_KEY=${SPAN_ASSIGNMENTS_KEY:-hwid}
dry_run=
verbose=
usage() {
echo >&2 "Usage: $0 [options] action [devpath ...]"
echo >&2 " action:"
echo >&2 " auto - trigger driver auto_assign attribute for given devices"
echo >&2 " add - assign spans, according to /etc/dahdi/assigned-spans.conf"
echo >&2 " remove - unassign spans"
echo >&2 " list - human-readable list of all spans"
echo >&2 " matched - found spans matched in configuration"
echo >&2 " unmatched - found spans not matched in configuration"
echo >&2 " dumpconfig - dump current state as new configuration"
echo >&2 ""
echo >&2 " options:"
echo >&2 " -h|--help - Show this help"
echo >&2 " -n|--dry-run - For 'add/remove' actions"
echo >&2 " -v|--versbose - Show matches during 'add' action"
echo >&2 " -k|--key <k> - Override prefered key during dumpconfig action"
exit 1
}
# Parse command line options
TEMP=`getopt -o hnvk: --long help,dry-run,verbose,key: -n "$0" -- "$@"`
if [ $? != 0 ]; then
echo >&2 "Bad options"
usage
fi
# Note the quotes around `$TEMP': they are essential!
eval set -- "$TEMP"
while true ; do
case "$1" in
-h|--help)
usage
;;
-n|--dry-run)
dry_run='true'
shift
;;
-v|--verbose)
verbose='true'
shift
;;
-k|--key)
SPAN_ASSIGNMENTS_KEY="$2"
shift
shift
;;
--)
shift
break
;;
*)
echo >&2 "Internal error!"
exit 1
;;
esac
done
if [ "$#" -eq 0 ]; then
echo >&2 "Missing action argument"
usage
fi
action="$1"
shift
# Validate SPAN_ASSIGNMENTS_KEY
case "$SPAN_ASSIGNMENTS_KEY" in
hwid|location|devpath)
;;
*)
echo >&2 "Bad SPAN_ASSIGNMENTS_KEY='$SPAN_ASSIGNMENTS_KEY' (should be: hwid|location|devpath)"
usage
;;
esac
if [ ! -d "$devbase" ]; then
echo >&2 "$0: Missing '$devbase' (DAHDI driver unloaded?)"
exit 1
fi
# Use given devices or otherwise, all existing devices
if [ "$#" -gt 0 ]; then
DEVICES="$@"
else
DEVICES=`ls -d $devbase/* 2>/dev/null`
fi
# Beware of special characters in attributes
attr_clean() {
cat "$1" 2>/dev/null | tr -d '\n' | tr '!' '/' | tr -c 'a-zA-Z0-9/:.-' '_'
}
show_devices() {
for device in $DEVICES
do
devpath=`cd "$device" && pwd -P`
location='@'`attr_clean "$device/location"`
hardware_id=`attr_clean "$device/hardware_id"`
for local_spanno in `cut -d: -f1 "$device/spantype"`
do
span=`grep 2>/dev/null -Hw "$local_spanno" "$device/span-"*"/local_spanno" | \
sed -e 's,/local_spanno:.*,,' -e 's,.*/,,'`
if [ "$span" != '' ]; then
spanno=`echo $span | sed 's/^.*-//'`
name=`cat 2>/dev/null "$device/$span/name"`
basechan=`cat 2>/dev/null "$device/$span/basechan"`
else
spanno='-'
basechan='-'
fi
printf "%-8s %-14s %s %s\n" "$local_spanno:$spanno:$basechan" "[$hardware_id]" "$location" "$devpath"
done | sort -n
done
}
dump_config() {
echo '#'
echo "# Autogenerated by $0 on `date`"
echo "# Map devices + local spans to span + base channel number"
echo ''
for device in $DEVICES
do
devpath=`cd "$device" && pwd -P`
location=`attr_clean "$device/location"`
hardware_id=`attr_clean "$device/hardware_id"`
if [ "$SPAN_ASSIGNMENTS_KEY" = 'hwid' -a "$hardware_id" != '' ]; then
id="$hardware_id"
elif [ "$SPAN_ASSIGNMENTS_KEY" = 'location' -a "$location" != '' ]; then
id="@$location"
else
id="$devpath"
fi
echo "# Device: [$hardware_id] @$location $devpath"
for local_spanno in `cut -d: -f1 "$device/spantype"`
do
span=`grep 2>/dev/null -Hw "$local_spanno" "$device/span-"*"/local_spanno" | \
sed -e 's,/local_spanno:.*,,' -e 's,.*/,,'`
if [ "$span" != '' ]; then
spanno=`echo $span | sed 's/^.*-//'`
name=`cat 2>/dev/null "$device/$span/name"`
basechan=`cat 2>/dev/null "$device/$span/basechan"`
printf "%-30s %s\n" "$id" "$local_spanno:$spanno:$basechan"
else
echo "# Skipped unassigned local span $local_spanno"
fi
done | sort
echo ''
done
}
unassign_all_spans() {
for device in $DEVICES
do
find "$device" -follow -maxdepth 1 -name 'span-*' -type d | \
sort | while read spandir; do
local_spanno=`cat "$spandir/local_spanno"`
if [ "$dry_run" = true ]; then
echo >&2 "(dry-run) unassign $device $local_spanno"
continue
fi
echo >&2 "unassign $device $local_spanno"
if ! echo "$local_spanno" > "$device/unassign_span"; then
echo >&2 "$0: failed unassigning '$local_spanno' in '$device'"
fi
done
done
}
# Allow comments and empty lines in config file
filter_conf() {
sed -e 's/#.*//' -e '/^[ \t]*$/d' "$DAHDISASSIGNEDSPANSCONF"
}
assign_device_spans() {
device="$1"
for s in $spanspecs
do
local_spanno=`echo "$s" | cut -d: -f1`
spanno=`echo "$s" | cut -d: -f2`
span="$device/span-$spanno"
if [ "$dry_run" = true ]; then
echo "(dry-run) assign $device: $s"
continue
fi
if [ -d "$span" ]; then
span_local_spanno=`cat "$span/local_spanno"`
if [ "$span_local_spanno" != "$local_spanno" ]; then
echo >&2 "WARNING: $span_local_spanno != $local_spanno"
fi
echo >&2 "$device [$local_spanno] already assigned to span $spanno. Skipping..."
continue
fi
echo >&2 "assign $device: $s"
if ! echo "$s" > "$device/assign_span"; then
echo >&2 "$0: failed assigning '$s' to '$device'"
fi
done
}
match_device() {
device="$1"
devpath=`cd "$device" && pwd -P`
location='@'`attr_clean "$device/location"`
hardware_id=`attr_clean "$device/hardware_id"`
filter_conf | while read id spanspecs
do
# We use case to enable shell-style globbing in configuration
case "$hardware_id" in
$id)
[ "$verbose" = true ] && echo >&2 "match by hwid ($id ~ $hardware_id): $spanspecs"
assign_device_spans "$device"
;;
esac
# We use case to enable shell-style globbing in configuration
case "$location" in
$id)
[ "$verbose" = true ] && echo >&2 "match by location ($id ~ $location): $spanspecs"
assign_device_spans "$device"
;;
esac
# We use case to enable shell-style globbing in configuration
case "$devpath" in
$id)
[ "$verbose" = true ] && echo >&2 "match by devpath ($id ~ $devpath): $spanspecs"
assign_device_spans "$device"
;;
esac
done
}
assign_devices() {
if [ ! -f "$DAHDISASSIGNEDSPANSCONF" ]; then
echo >&2 "$0: Missing '$DAHDISASSIGNEDSPANSCONF'"
exit 1
fi
echo >&2 "using '$DAHDISASSIGNEDSPANSCONF'"
for device in $DEVICES
do
match_device "$device"
done
}
auto_assign_devices() {
for device in $DEVICES
do
echo >&2 "auto-assign $device"
if [ "$dry_run" != true ]; then
echo 1 > "$device/auto_assign"
fi
done
}
dev_match_conf() {
local devpath="$1"
local location="$2"
local hardware_id="$3"
local local_spanno="$4"
filter_conf | while read id spanspecs
do
spanno=`echo "$spanspecs" | cut -d: -f1`
match_dev=no
# We use case to enable shell-style globbing in configuration
case "$hardware_id" in
$id)
match_dev=yes
;;
esac
# We use case to enable shell-style globbing in configuration
case "$location" in
$id)
match_dev=yes
;;
esac
# We use case to enable shell-style globbing in configuration
case "$devpath" in
$id)
match_dev=yes
;;
esac
if [ "$match_dev" = 'yes' -a "$local_spanno" = "$spanno" ]; then
#printf "%-8s (%s) %-14s %s %s\n" "$local_spanno" "$spanno" "[$hardware_id]" "$location" "$devpath"
echo "[$hardware_id]:$local_spanno"
fi
done
}
list_devices() {
wanted="$1"
if [ ! -f "$DAHDISASSIGNEDSPANSCONF" ]; then
echo >&2 "$0: Missing '$DAHDISASSIGNEDSPANSCONF'"
exit 1
fi
echo >&2 "using '$DAHDISASSIGNEDSPANSCONF'"
for device in $DEVICES
do
devpath=`cd "$device" && pwd -P`
location='@'`attr_clean "$device/location"`
hardware_id=`attr_clean "$device/hardware_id"`
for local_spanno in `cut -d: -f1 "$device/spantype"`
do
found=`dev_match_conf "$devpath" "$location" "$hardware_id" "$local_spanno"`
if [ "$wanted" = "unmatched" ]; then
[ -z "$found" ] && echo "[$hardware_id]:$local_spanno"
else
[ -z "$found" ] || echo "[$hardware_id]:$local_spanno"
fi
done
done
}
case "$action" in
auto)
auto_assign_devices
;;
add)
assign_devices
;;
remove)
unassign_all_spans
;;
list)
show_devices
;;
dumpconfig)
dump_config
;;
matched)
list_devices "matched"
;;
unmatched)
list_devices "unmatched"
;;
*)
echo >&2 "Bad action='$action'"
usage
;;
esac

397
dahdi_span_types Executable file
View File

@ -0,0 +1,397 @@
#! /bin/sh
#
# /usr/sbin/dahdi_span_types
#
# This script can be used both from udev and
# from the command line to manage PRI spans
# type (E1/T1/J1).
#
# Span types can be set only *BEFORE* span are assigned.
#
# It uses a configuration file: $DAHDICONFDIR/span-types.conf
# (default DAHDICONFDIR=/etc/dahdi)
# (the format is documented inside that file)
#
# The first argument is an action:
# "set" - actually write the setting to the driver
# "list" - human-readable list of E1/T1/J1 types
# "dumpconfig" - dump current assignments in a /etc/dahdi/span-types.conf
# compatible format
#
# Without further arguments, it operates on all existing spans
# With one or more sysfs dahdi_devices it is limited to those.
#
# We may use alternative "keys" for device matching:
# * Available keys:
# - "hwid" - Hardware id attribute from sysfs
# - "@location" - Location attribute from sysfs (embeded inside '<>')
# - "/devpath" - The sysfs absolute devpath
#
# * Wildcard are allowed in the configuration file:
# - In the device specifiers (keys)
# - In the span numbers
# - Example for "match-all": * *:T1
#
# * During "set":
# - If there are multiple matches, for a span, all are applied
# - They are always applied in their order in the configuration file
# - This means the last match wins
# - Example:
# * *:T1 # All span on all devices are T1
# usb:X1234567 [34]:E1 # Except spans 3,4 on specific device
#
# * During "dumpconfig", for each device we take the first available key:
# - The preference is: "hwid" or else "@location" or else "/devpath"
# - This can be overriden via the SPAN_ASSIGNMENTS_KEY environment variable
# or the '{-k|--key} key' command line option.
#
# Command line options:
# - The '-h|--help' show a usage message.
# - The '-v|--verbose' show debugging messages (on stderr)
# - The '-n|--dry-run' During "set", only show what would be done
# - The '-k <key>|--key <key>' overrides the SPAN_ASSIGNMENTS_KEY environment
# variable.
#
# Examples:
# dahdi_span_types list
# dahdi_span_types set # all devices
# dahdi_span_types set /sys/bus/dahdi_devices/devices/astribanks:xbus-00
# dahdi_span_types -k location dumpconfig
#
devbase='/sys/bus/dahdi_devices/devices'
DAHDICONFDIR="${DAHDICONFDIR:-/etc/dahdi}"
DAHDISPANTYPESCONF="${DAHDISPANTYPESCONF:-"${DAHDICONFDIR}/span-types.conf"}"
SPAN_ASSIGNMENTS_KEY=${SPAN_ASSIGNMENTS_KEY:-hwid}
usage() {
echo >&2 "Usage: $0 [options] action [devpath ...]"
echo >&2 " action:"
echo >&2 " set - set spans to E1/T1 according to /etc/dahdi/span-types.conf"
echo >&2 " compare - show config values that differ from system"
echo >&2 " list - human-readable list of all spans"
echo >&2 " dumpconfig - dump current state in /etc/dahdi/span-types.conf format"
echo >&2 ""
echo >&2 " options:"
echo >&2 " -h|--help - Show this help"
echo >&2 " -v|--verbose' - Show debugging messages (on stderr)"
echo >&2 " -n|--dry-run' - During 'set', only show what would be done"
echo >&2 " -k|--key <k> - Override prefered key during dumpconfig action"
echo >&2 " --line-mode <m> - Set default line mode to <m> (E1/T1/J1)"
exit 1
}
# Parse command line options
TEMP=`getopt -o hnvk: --long help,dry-run,verbose,key:,line-mode: -n "$0" -- "$@"`
if [ $? != 0 ]; then
echo >&2 "Bad options"
usage
fi
compare=false
# Note the quotes around `$TEMP': they are essential!
eval set -- "$TEMP"
while true ; do
case "$1" in
-h|--help)
usage
;;
-n|--dry-run)
shift
dry_run=true
;;
-v|--verbose)
shift
verbose=true
;;
-k|--key)
SPAN_ASSIGNMENTS_KEY="$2"
shift
shift
;;
--line-mode)
DEFAULT_LINE_MODE="$2"
shift
shift
;;
--)
shift
break
;;
*)
echo "Internal error!"
exit 1
;;
esac
done
if [ "$#" -eq 0 ]; then
echo >&2 "Missing action argument"
usage
fi
action="$1"
shift
# Validate SPAN_ASSIGNMENTS_KEY
case "$SPAN_ASSIGNMENTS_KEY" in
hwid|location|devpath)
;;
*)
echo >&2 "Bad --key='$SPAN_ASSIGNMENTS_KEY' (should be: hwid|location|devpath)"
usage
;;
esac
# Validate DEFAULT_LINE_MODE
case "$DEFAULT_LINE_MODE" in
E1|T1|J1|'')
;;
*)
echo >&2 "Bad --line-mode='$DEFAULT_LINE_MODE' (should be: E1|T1|J1)"
usage
;;
esac
if [ ! -d "$devbase" ]; then
echo >&2 "$0: Missing '$devbase' (DAHDI driver unloaded?)"
exit 1
fi
# Use given devices or otherwise, all existing devices
if [ "$#" -gt 0 ]; then
DEVICES="$@"
else
DEVICES=`ls -d $devbase/* 2>/dev/null`
fi
# Beware of special characters in attributes
attr_clean() {
cat "$1" 2>/dev/null | tr -d '\n' | tr '!' '/' | tr -c 'a-zA-Z0-9/:.-' '_'
}
show_spantypes() {
echo "# PRI span types (E1/T1/J1)"
for device in $DEVICES
do
devpath=`cd "$device" && pwd -P`
location='@'`attr_clean "$device/location"`
hardware_id=`attr_clean "$device/hardware_id"`
cat "$device/spantype" | while read st; do
case "$st" in
*:[ETJ]1)
printf "%-10s %-20s %-30s %s\n" \
"$st" "[$hardware_id]" "$location" \
"$devpath"
;;
esac
done
done
}
list_pri_spantypes() {
find $DEVICES -follow -maxdepth 1 -name spantype | \
xargs cat | \
sed -n '/:[ETJ]1$/s/^.*://p' | \
sort -u | \
tr '\n' ' ' | \
sed -e 's/^ *//' -e 's/ *$//'
}
dump_config() {
pri_spantypes=`list_pri_spantypes`
num_spantypes=`echo "$pri_spantypes" | wc -w`
gen_default=''
echo '#'
echo "# Autogenerated by $0 on `date`"
echo "# Map PRI DAHDI devices to span types for E1/T1/J1"
echo "#"
echo "# Summary:"
if [ "$DEFAULT_LINE_MODE" != '' ]; then
gen_default="$DEFAULT_LINE_MODE"
echo "# * Generating wildcard match of $gen_default."
echo "# - Was run with '--line-mode=$DEFAULT_LINE_MODE'"
elif [ "$num_spantypes" -eq 1 ]; then
gen_default="$pri_spantypes"
echo "# * Generating wildcard match of $gen_default."
echo "# - Spans were $pri_spantypes"
else
echo "# * Not generating wildcard match."
echo "# - Was run without '--line-mode' option and span were of mixed types [$pri_spantypes]"
fi
echo "#"
if [ "$num_spantypes" -eq 1 ]; then
echo "# * Generating a list of commented out configurations for spans."
echo "# - Spans were $pri_spantypes"
echo "# - Uncomment for specific overrides"
else
echo "# * Generating a list of specific span configurations."
echo "# - Spans were of mixed types: $pri_spantypes"
fi
echo "#"
echo ''
fmt="%-65s %s"
printf "$fmt\n" '# @location/hardware_id' 'span_type'
if [ "$gen_default" != '' ]; then
printf "$fmt\t\t# Wildcard line-mode" "*" "*:$gen_default"
echo ""
fi
echo ""
for device in $DEVICES
do
devpath=`cd "$device" && pwd -P`
location=`attr_clean "$device/location"`
hardware_id=`attr_clean "$device/hardware_id"`
if [ "$SPAN_ASSIGNMENTS_KEY" = 'hwid' -a "$hardware_id" != '' ]; then
id="$hardware_id"
elif [ "$SPAN_ASSIGNMENTS_KEY" = 'location' -a "$location" != '' ]; then
id="@$location"
else
id="$devpath"
fi
echo "# Device: [$hardware_id] @$location $devpath"
cat "$device/spantype" | while read st; do
case "$st" in
*:[ETJ]1)
if [ "$num_spantypes" -eq 1 ]; then
printf "#$fmt\n" "$id" "$st"
else
printf "$fmt\n" "$id" "$st"
fi
;;
*)
#echo "# Skipped local span `echo $st | sed 's/:/ -- /'`"
;;
esac
done | sort -n
echo ''
done
}
# Allow comments and empty lines in config file
filter_conf() {
sed -e 's/#.*//' -e '/^[ \t]*$/d' "$DAHDISPANTYPESCONF"
}
handle_span() {
device="$1"
spantype="$2"
attr_file="$device/spantype"
devpath=`cd "$device" && pwd -P`
devname=`echo "$device" | sed "s,$devbase/,,"`
location='@'`attr_clean "$device/location"`
hardware_id=`attr_clean "$device/hardware_id"`
spanno=`echo "$spantype" | cut -d: -f1`
#echo >&2 "DEBUG: $device $spanno ($spantype)"
filter_conf | while read id span_spec; do
sn=`echo "$span_spec" | cut -d: -f1`
val=`echo "$span_spec" | cut -d: -f2`
case "$spanno" in
$sn)
;;
*)
#echo >&2 "no-match($device $spanno): $sn"
continue
;;
esac
found=no
# GLOBBING
case "$location" in
$id)
#echo >&2 "match($id): $span_spec"
found=yes
;;
esac
case "$hardware_id" in
$id)
#echo >&2 "match([$id]): $span_spec"
found=yes
;;
esac
case "$devpath" in
$id)
#echo >&2 "match([$id]): $span_spec"
found=yes
;;
esac
if [ "$found" = 'yes' ]; then
if [ "$dry_run" = 'true' -o "$verbose" = 'true' ]; then
echo >&2 "Set $devname span $spanno = $val"
fi
if [ "$dry_run" != 'true' ]; then
if [ "$compare" = 'true' ]; then
config="$spanno:$val"
system=`grep "$spanno:" "$attr_file"`
if [ "$config" != "$system" ]; then
active_val=`echo $system | cut -d: -f2`
echo "$devname $spanno $val $active_val" >>"$compare_results_file"
fi
else
echo "$spanno:$val" > "$attr_file"
fi
fi
fi
done
}
set_all_devices() {
span_differs='false'
SPANS_DIFFER='false'
if [ ! -f "$DAHDISPANTYPESCONF" ]; then
echo >&2 "$0: Missing configuration '$DAHDISPANTYPESCONF'"
exit 1
fi
for device in $DEVICES
do
devname=`echo "$device" | sed "s,$devbase/,,"`
cat "$device/spantype" | while read spantype; do
case "$spantype" in
*:[ETJ]1)
handle_span "$device" "$spantype"
;;
*)
if [ "$dry_run" = 'true' -o "$verbose" = 'true' ]; then
echo >&2 "Skipping non-E1/T1/J1 span ($devname -- $spantype)"
fi
;;
esac
done
done
if [ "$compare" = 'true' ]; then
if [ -s "$compare_results_file" ]; then
echo "# Device Unit Config Active"
cat "$compare_results_file"
rm -f "$compare_results_file"
exit 5
fi
rm -f "$compare_results_file"
exit 0
fi
}
case "$action" in
list)
show_spantypes
;;
dumpconfig)
dump_config
;;
set)
set_all_devices
;;
compare)
compare=true
compare_results_file=`mktemp`
set_all_devices
;;
*)
usage
;;
esac

View File

@ -40,17 +40,32 @@
#define SIZE 8000
static int verbose;
static int pass = 0;
static float best = 0.0;
static float worst = 100.0;
static double total = 0.0;
static double delay_total = 0.0;
static double total_time = 0.0;
static double total_count = 0.0;
static inline float _fmin(float a, float b)
{
return (a < b) ? a : b;
}
static double calculate_accuracy(double count, double ms)
{
return ((count - _fmin(count, fabs(count - ms))) / count) * 100.0;
}
void hup_handler(int sig)
{
double accuracy = calculate_accuracy(total_count, total_time);
printf("\n--- Results after %d passes ---\n", pass);
printf("Best: %.3f -- Worst: %.3f -- Average: %f, Difference: %f\n",
best, worst, pass ? total/pass : 100.00, pass ? delay_total/pass : 100);
printf("Best: %.3f%% -- Worst: %.3f%% -- Average: %f%%\n",
best, worst, pass ? total/pass : 100.00);
printf("Cumulative Accuracy (not per pass): %0.3f\n",
pass ? accuracy : 0.0);
exit(0);
}
@ -79,9 +94,7 @@ int main(int argc, char *argv[])
int count = 0;
int seconds = 0;
int curarg = 1;
int verbose = 0;
char buf[8192];
float score;
float ms;
struct timeval start, now;
fd = open("/dev/dahdi/pseudo", O_RDWR);
@ -140,23 +153,23 @@ int main(int argc, char *argv[])
ms += (now.tv_sec - start.tv_sec) * 8000;
ms += (now.tv_usec - start.tv_usec) / 125.0;
if (count >= SIZE) {
double percent = 100.0 * (count - ms) / count;
const double percent = calculate_accuracy(count, ms);
if (verbose) {
printf("\n%d samples in %0.3f system clock sample intervals (%.3f%%)",
count, ms, 100 - percent);
count, ms, percent);
} else if (pass > 0 && (pass % 8) == 0) {
printf("\n");
}
score = 100.0 - fabs(percent);
if (score > best)
best = score;
if (score < worst)
worst = score;
if (percent > best)
best = percent;
if (percent < worst)
worst = percent;
if (!verbose)
printf("%.3f%% ", score);
total += score;
delay_total += 100 - percent;
printf("%.3f%% ", percent);
total += percent;
fflush(stdout);
total_count += count;
total_time += ms;
count = 0;
pass++;
}

73
dahdi_waitfor_span_assignments Executable file
View File

@ -0,0 +1,73 @@
#! /bin/sh
usage() {
echo >&2 "Usage: $0 {assigned|unassigned}"
echo >&2 "# wait until all spans known are assigned/unassigned"
exit 1
}
TIMEOUT=5 # How much time to wait for spans
if [ "$#" -lt 1 ]; then
usage
fi
wanted_event="$1"
shift
case "$wanted_event" in
assigned)
;;
unassigned)
;;
*)
usage
;;
esac
devbase='/sys/bus/dahdi_devices/devices'
spans_of() {
dev="$1"
wc -l < "$dev/spantype"
}
assigned_spans_of() {
dev="$1"
ls -d "$dev/span-"* 2>/dev/null | wc -l
}
waitfor_span_assignments() {
wanted_state="$1"
device_list=`ls -d "$devbase/"* 2> /dev/null`
finished=''
count="$TIMEOUT"
echo -n "Waiting for spans to become $wanted_state: "
while [ "$count" -gt 0 ]; do
finished='yes'
for dev in $device_list
do
spans=`spans_of "$dev"`
assigned_spans=`assigned_spans_of "$dev"`
if [ "$wanted_state" = 'assigned' -a "$assigned_spans" -ne "$spans" ]; then
finished='no'
elif [ "$wanted_state" = 'unassigned' -a "$assigned_spans" -ne 0 ]; then
finished='no'
fi
done
if [ "$finished" = 'yes' ]; then
break
else
sleep 1
echo -n "."
fi
count=`expr "$count" - 1`
done
if [ "$finished" = 'yes' ]; then
echo "done"
else
echo "timeout"
fi
}
waitfor_span_assignments "$wanted_event"

19
doc/Makefile.am Normal file
View File

@ -0,0 +1,19 @@
man_MANS = \
dahdi_cfg.8 \
dahdi_maint.8 \
dahdi_monitor.8 \
dahdi_scan.8 \
dahdi_span_assignments.8 \
dahdi_span_types.8 \
dahdi_test.8 \
dahdi_tool.8 \
dahdi_waitfor_span_assignments.8 \
fxotune.8
noinst_MANS = \
dahdi_diag.8 \
fxstest.8 \
patgen.8 \
pattest.8
EXTRA_DIST = $(man_MANS) $(noinst_MANS)

View File

@ -4,7 +4,7 @@
dahdi_cfg \- configures DAHDI kernel modules from /etc/dahdi/system.conf
.SH SYNOPSIS
.B dahdi_cfg [\-c \fICFG_FILE\fB] [\-s] [\-f] [\-t] [\-v [\-v ... ] ]
.B dahdi_cfg [\-c \fICFG_FILE\fB] [\-S\fINUM\fB [\-S\fICHANS\fB]] [\-s] [\-f] [\-t] [\-v [\-v ... ] ]
.B dahdi_cfg \-h
@ -24,6 +24,14 @@ the DAHDI init script.
.RS
Use an alternative configuration file instead of
.I /etc/dahdi/system.conf
If \fICFG_FILE\fR is '\fB\-\fR', it is read from stdin.
.RE
.B \-C \fICHANNELS
.RS
Only apply changes to channels in the specified range. Only
applicable when \-S is in use.
.RE
.B \-s
@ -31,6 +39,12 @@ Use an alternative configuration file instead of
Only shutdown spans.
.RE
.B \-S \fISPAN
.RS
Only apply changes to span no. \fISPAN\fR. You also need to specify the
range of channels in the span explicitly with \-C.
.RE
.B \-f
.RS
Always configure every channel, even if it appears not to have changed.

62
doc/dahdi_maint.8 Normal file
View File

@ -0,0 +1,62 @@
.TH "DAHDI_MAINT" "8" "9 Sep 2011" "" ""
.SH NAME
dahdi_maint \- Sets Dahdi spans into maintenance mode, e.g.: loopback
.SH SYNOPSIS
.B dahdi_maint \-s \fInum\fB [options]
.B dahdi_maint <\-h|\-\-help>
.SH DESCRIPTION
dahdi_maint uses the DAHDI_MAINT interface to set a Dahdi span (port
of a Dahdi adapter card) into loopback mode or similar maintenance mode.
.SH OPTIONS
.B \-s \-\-span \fInum\fR
.RS
The span number. Required.
.RE
.B \-l \-\-loopback <localhost|networkline|networkpayload|loopup|loopdown|off>
.RS
Loopback type. One of:
.IP localhost 4
loop back towards host
.IP networkline 4
network line loopback
.IP networkpayload 4
network payload loopback
.IP loopup 4
transmit loopup signal
.IP loopdown 4
transmit loopdown signal
.IP off 4
end loopback mode
.RE
.B \-i \-\-insert <fas|multi|crc|cas|prbs|bipolar>
.RS
Insert an error of a specific type
.RE
.SH EXAMPLES
Enable network line loopback on span 1:
dahdi_maint \-s 1 \-\-loopback networkline
Disable network line loopback on span 1:
dahdi_maint \-s 1 \-\-loopback off
.SH SEE ALSO
.PP
dahdi_tool(8), dahdi_cfg(8), asterisk(8).
.SH AUTHOR
.PP
This manual page was written by Tzafrir Cohen <tzafrir.cohen@xorcom.com>.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU General Public License, Version 2 any later
version published by the Free Software Foundation.

View File

@ -1,37 +1,139 @@
.TH "DAHDI_MONITOR" "8" "16 June 2008" "" ""
.TH "DAHDI_MONITOR" "8" "9 Sep 2011" "" ""
.SH NAME
dahdi_monitor \- checks the rx/tx levels of DAHDI channels
dahdi_monitor \- checks the Rx/Tx levels of a DAHDI channels
.SH SYNOPSIS
.B dahdi_monitor \fIchannel number\fB [\-v] [\-f \fIFILE\fB]
.B dahdi_monitor \fInum\fB [\-v[v]]
.B dahdi_monitor \fInum\fB [\-o] [<\-f|\-F> \fIFILE\fB]
.B dahdi_monitor \fInum\fB [[<\-r|\-R> \fIFILE\fB]] [[<\-t|\-T> \fIFILE\fB]]
.SH DESCRIPTION
dahdi_monitor monitors a DAHDI channel. It gives you a visual
representation of the sound strengths and makes it easy to see if
the received or transmitted signals are too high or out of
balance
dahdi_monitor monitors a Dahdi channel. It can record the output to a
file, play it to the speaker, or visualize the audio levels on the
terminal.
Recorded audio files are by default raw signed linear PCM. If the file
name ends with ".wav", the recorded file will be a WAV file.
The visual display shows the current audio level at both the Rx
(audio Received by Asterisk) and
Tx (audio Transmitted by Asterisk)
To exit the program, press Ctrl-C.
.SH OPTIONS
The first (mandatory) parameter is the number of the channel
to monitor.
.B \-m
.RS
Multiple channels. Don't multiplex both Rx and Tx in a single channel.
Normally there's a different option that you need that implies it.
.RE
.B \-o
.RS
Plays the output to OSS (/dev/dsp). Requires \-m not to be used.
.RE
.B \-v
.RS
Display visual audio levels.
Display Visual audio levels. With two v-s, Verbose mode is enabled, that
shows the actual levels as numbers. Note that this requires a terminal
wider than 80 columns to be properly displayed.
Implies \-m.
.RE
.B \-f \fIFILE
.RS
Write output to FILE
Record the content of the channel (Tx + Rx) to a file.
.RE
Some extra, yet undocumented, options.
.B \-F \fIFILE
.RS
Record the content of the channel (Tx + Rx) before the echo canceler
to a file.
.RE
.B \-r \fIFILE
.RS
Record the content of the Rx channel to a file.
Implies \-m.
.RE
.B \-R \fIFILE
.RS
Record the content of the R channel before the echo canceler to a file.
Implies \-m.
.RE
.B \-s \fIFILE
.RS
Record the content of the Tx and Rx of the channel to a file.
.RE
.B \-S \fIFILE
.RS
Records a stereo of both Tx and Rx of the channel before the echo
canceler to a file.
.RE
.B \-t \fIFILE
.RS
Record the content of the Tx channel to a file.
Implies \-m.
.RE
.B \-T \fIFILE
.RS
Record the content of the Tx channel before the echo canceler to a file.
Implies \-m.
.RE
.SH EXAMPLES
Visualize audio levels on DAHDI channel 2:
dahdi_monitor 2 \-v
Record channel 3 to a file:
dahdi_monitor 3 \-f output.raw
This will create a raw PCM file (signed-linear, 8kHz, mono, 16 bits per
sample). Both the Tx and Rx will be multiplexed in a single channel.
It can be converted to a WAV file using e.g.:
sox \-s \-c1 \-2 \-r8000 output.raw output.wav
Record Tx and Rx of channel 5 to separate files. This time directly to
WAV files:
dahdi_monitor 5 \-r output_rx.wav \-t output_tx.wav
Record channel 8 to a stereo file (Tx and Rx on its two channels):
dahdi_monitor 8 \-s output.raw
Converting it to a WAV file:
sox \-s \-c2 \-2 \-r8000 output.raw output.wav
.SH SEE ALSO
.PP
dahdi_tool(8), dahdi_cfg(8), asterisk(8).
dahdi_tool(8), dahdi_cfg(8).
.SH AUTHOR
.PP

View File

@ -0,0 +1,251 @@
.TH "DAHDI_SPAN_ASSIGNMENTS" "8" "23 Jan 2014" "" ""
.SH NAME
dahdi_span_assignments \- handle DAHDI spans assignments
.SH SYNOPSIS
.B dahdi_span_assignments [\-v|\-\-verbose] [\-n|\-\-dry\-run] <add|remove|auto> \fB[\fIdevpath\fB...]
.B dahdi_span_assignments [\-v|\-\-verbose] list \fB[\fIdevpath\fB...]
.B dahdi_span_assignments [\-v|\-\-verbose] [\-k|\-\-key \fIkey\fB] dumpconfig
.B dahdi_span_assignments \-h|\-\-help
.SH DESCRIPTION
Channels in DAHDI devices (such as DAHDI PCI cards) are groups to logical
units called "spans" (for example: a port in a digital card is a span).
When the kernel module parameter \fBdahdi.auto_assign_span\fR is unset,
DAHDI devices that register with DAHDI don't cause their spans to be
automatically assigned.
This allows user-space to order DAHDI to assign them to specific span
and channel numbers. That way, specific spans on specific DAHDI devices
may be assigned with specific span and channel numbers \fBregardless\fR
of the registration order of the hardware (or if all hardware is present
at all).
.B dahdi_span_assignments
is used to assign those spans or to help creating the configuration
file used in their assignment:
.B /etc/dahdi/assigned\-spans.conf .
.SH SUB-COMMANDS
There are several sub-commands.
All sub-commands take an optional list of paths to SysFS nodes of
devices. If given, the command will only operate on those DAHDI
devices. The default is to operate on all devices (which would normally
be the sane case when running from the command-line).
.B add \fB[\fIdevpath \fB...]
.RS
Applies to all devices or to those listed on the command line.
Parameters are paths (in SysFS) to DAHDI devices with unassigned
spans.
The command will assign spans with DAHDI according to
configuration in \fBassigned\-spans.conf\fR.
If no line matches the span, or if the assignment for it fails (it is
not available) it will remain unassigned.
If any of the span settings fails (the span number or range of channels
is already in use), the program will print a message, but continue
applying the others. In such a case you should fix assigned\-spans.conf
and re-run \fBadd\fR (or run \fBauto\fR to give those channels the
first available range and regenerate the file with 'dahdi_genconf
assignedspans').
.RE
.B remove \fB[\fIdevpath \fB...]
.RS
Applies to all devices or to those listed on the command line.
Parameters are paths (in SysFS) to DAHDI devices with assigned
spans.
The command will un-assign them.
.RE
.B auto \fB[\fIdevpath \fB...]
.RS
Applies to all devices or to those listed on the command line.
Parameters are paths (in SysFS) to DAHDI devices with unassigned
spans.
Each span is assigned to first available span number and channel
numbers, as if \fBdahdi.auto_assign_span\fR was set. The configuration
file doesn't affect these assignments.
.RE
.B list
.RS
List all spans in the system.
.RE
.B dumpconfig
.RS
List all assigned spans in the system in a format fit to be used in
\fBassigned\-spans.conf\fR. Use this to generate a configuration file after
you have (automatically or manually) assigned all existing spans.
.B dahdi_genconf assignedspans
uses this command internally.
.RE
.SH OPTIONS
.B \-v \-\-verbose
.RS
Verbose output.
.RE
.B \-n \-\-dry\-run
.RS
Don't assign / un-assign spans. Only print commands used to do so.
.RE
.B \-k \fIkey
.RS
For \fBdumpconfig\fR \- The key by which to identify the hardware in the
generated configuration. Legal values:
.B hwid
.RS
Hardware identifier (e.g.: software-readable serial number). This is the
default. If the device has no hwid, devpath is used.
.RE
.B location
.RS
The location field (file) in the SysFS device node (directory) for the
DAHDI device. If not available (typically: DAHDI version <= 2.7.x),
devpath is used.
.RE
.B devpath
.RS
Path in SysFS to the device node.
.RE
.RE
.SH CONFIGURATION
.B /etc/dahdi/assigned\-spans.conf
is a file with lines specifying assignment of spans.
Empty lines or lines beginning with '#' are ignored.
Each line is in the format of:
.I ID spanspec ...
The \fIID\fR field specifies the DAHDI device and the \fIspanspecs\fR
define how to assign its spans. A line may have multiple
\fIspanspecs\fR in a single line (though dumpconfig generates a
configuration with one per line).
.SS Span Identifier
A DAHDI device may be specified either by a hardware identifier (a
software readable serial number or whatever) or the location in which
it is installed on the system. The former makes it simpler to change
connector / slot whereas the latter makes it simpler to replace a unit.
The value in this field is matched (when the commands \fBadd\fR and
\fBremove\fR) are used) to the following values:
\fIhwid\fR
\fB@\fIlocation\fR
\fIdevpath\fR
See above for their descriptions. The value may include shell wildcards:
*, ? and [], which are used in the match. The values to be matched are
first cleaned up: '!' is replaced with '/' and any character beyond
"a\-zA\-Z0\-9/:.\-" is removed.
.SS Span Specification
Each line should have one or more span specifications: this is the value
used to assign a span with DAHDI in the SysFS interface. A
specification has three colon-separated numbers:
.I rel_span_no:span_no:first_chan
for instance, the following are four span specifications for a quad-E1
device: 1:6:53 2:7:84 3:8:115 4:9:146 occupying spans 6-9 and channels
53-176.
.B rel_span_no
.RS
The relative number of the span in the device. E.g.: port number.
.RE
.B span_no
.RS
The desired DAHDI span number. Must be available.
.RE
.B first_chan
.RS
The desired DAHDI channel number for the first DAHDI channel in the span.
All channels of the span will be assigned following it and hence that
space must be available.
.RE
.SH ENVIRONMENT
.B DAHDICONFDIR
.RS
The directory in which assigned\-spans.conf resides. /etc/dahdi if not
overridden from the environment.
.RE
.B DAHDISASSIGNEDSPANSCONF
.RS
The path to assigned-spans.conf resides. /etc/dahdi/assigned\-spans.conf if
not overridden from the environment.
.RE
.B SPAN_ASSIGNMENTS_KEY
.RS
The default value for \-k . Defaults to "hwid" if not overridden from the
environment.
.RE
.SH FILES
.B /etc/dahdi/assigned\-spans.conf
.RS
The default location for the configuration file.
.RE
.B /sys/bus/dahdi_devices/devices/\fIdevice\fR
.RS
SysFS node for the device. In this directory reside the following
files, among others:
.B location
.RS
The value of the device's location field.
.RE
.B assign_span, unassign_span, auto_assign
.RS
Write only files for the operations. Used by \fBadd\fR, \fBremove\fR and
\fBauto\fR, respectively.
.RE
.RE
.SH SEE ALSO
dahdi_span_types(8), dahdi_genconf(8), dahdi_cfg(8)
.SH AUTHOR
dahdi_span_assignments was written by Oron Peled. This manual page was
written by Tzafrir Cohen. Permission is granted to copy, distribute
and/or modify this document under the terms of the GNU General Public
License, Version 2 any later version published by the Free Software
Foundation.

207
doc/dahdi_span_types.8 Normal file
View File

@ -0,0 +1,207 @@
.TH "DAHDI_SPAN_TYPES" "8" "23 Jan 2014" "" ""
.SH NAME
dahdi_span_types \- set line modes of DAHDI spans before assignment
.SH SYNOPSIS
.B dahdi_span_types [\fIoptions\fB] <list|dumpconfig|compare|set> \fB[\fIdevpath \fB...]
.SH DESCRIPTION
The span type (the line mode: E1/T1/J1) must be set to a span before
DAHDI assigns it a span number, as E1 spans use more channels.
\fBdahdi_span_types\fR applies the span type configuration to an
un-assigned span.
Using it only makes sense when the kernel module parameter
\fBdahdi.auto_assign_span\fR is unset, otherwise DAHDI automatically
assign span numbers during device registration.
.B dahdi_span_types
takes a command and an optional list of devices. If no device is given,
the command is applied to all devices.
The device is marked as a path in the SysFS tree.
.SH OPTIONS
.B \-h|\-\-help
.RS
Output usage message and exit
.RE
.B \-n|\-\-dry\-run
.RS
During \fB"set"\fR operation, only show what would be done, without actually
changing anything.
.RE
.B \-v|\-\-verbose
.RS
During \fB"set"\fR operation, show the actions that are being performed.
.RE
.BI \-\-line\-mode= <E1|T1|J1>
.RS
During \fB"dumpconfig"\fR operation, force special generation mode:
.IP \(bu 3
First, generates a "wildcard" entry with the fiven \fBline\-mode\fR.
.IP \(bu 3
Comment out all span entries. Each of them may be manually un-commented
to override the "wildcard".
.RE
.SH SUB-COMMANDS
.B set
.RS
Reads settings from \fBspan\-types.conf\fR and applies them to the
device(s) specified in the command line (or all devices, if none
specified).
.RE
.B compare
.RS
Compare the settings on the system to those in the configuration file.
For each line that applies to a device on the system, print it if the
value to be set and the active value on the system differ.
The exit status is 0 if there is no difference and non-zero if a
difference was detected.
.RE
.B list
.RS
List line modes for all spans in the system which may be set with
dahdi_span_types (E1/T1/J1 spans).
.RE
.B dumpconfig
.RS
List types for the spans in a format fit to be used in
\fBspan\-types.conf\fR. Use this to generate a configuration file after
you have (perhaps manually) set all existing spans.
.B dahdi_genconf spantypes
uses this command internally.
.RE
.SH CONFIGURATION
.SS General structure
.B span\-types.conf
is a file with lines specifying line modes of spans.
Empty lines or lines beginning with '#' are ignored.
Each line is in the format of:
.I ID spanspec ...
The \fIID\fR field specifies the DAHDI device and the \fIspanspecs\fR
define the line modes of its spans. A line may have multiple
\fIspanspecs\fR in a single line (though dumpconfig generates a
configuration with one per line).
.SS Span Identifier
A DAHDI device may be specified either by a hardware identifier (a
software readable serial number or whatever) or the location in which
it is installed on the system. The former makes it simpler to change
connector / slot whereas the latter makes it simpler to replace a unit.
The value in this field is matched (when the command \fBset\fR is
used) to the following values:
\fIhwid\fR
\fB@\fIlocation\fR
\fIdevpath\fR
See above for their descriptions. The value may include shell wildcards:
*, ? and [], which are used in the match. The values to be matched are
first cleaned up: '!' is replaced with '/' and any character not in
"a\-zA\-Z0\-9/:.\-" is replaced by "_".
Note that while span\-types.conf allows an arbitrarily-complex
combination of E1, J1 and T1 ports, it would normally have just a single
wildcard line setting the line mode (the first line in the example below).
.SS Span Specification
Each line should have one or more span specifications: this is the value
used to set span type with DAHDI in the SysFS interface. A
specification has two colon-separated fields:
.I rel_span_no:span_type
for instance, the following are four span specifications specify ports 1
and 2 as E1 and ports 3 and 4 as T1: [12]:E1 [34]:T1 .
.B rel_span_no
.RS
The relative number of the span in the device. E.g.: port number.
This field may contain shell wildcards (*, ? and [])
.RE
.B span_type
.RS
E1/T1/J1
.RE
.SS Multiple matches
During \fBset\fR operation, the \fBdahdi_span_types\fR applies all
matching settings to a span. This is done in the order of lines in the
configuration files.
Thus, if there are multiple matches to a span -- the last match
will \fIwin\fR (all will be applied to the kernel in order. The last
one in the file will be applied last).
Example:
.EX
* *:T1 # All spans on all devices will be T1
usb:X1234567 [34]:E1 # Except spans 3,4 on the device which will be E1
.EE
.SH ENVIRONMENT
.B DAHDICONFDIR
.RS
The directory in which span\-types.conf resides. /etc/dahdi if not
overridden from the environment.
.RE
.B DAHDISPANTYPESCONF
.RS
The path to span\-types.conf resides. /etc/dahdi/span\-types.conf if
not overridden from the environment.
.RE
.SH FILES
.B /etc/dahdi/span\-types.conf
.RS
The default location for the configuration file.
.RE
.B /sys/bus/dahdi_devices/devices/\fIdevice\fR
.RS
SysFS node for the device. In this directory reside the following
files, among others:
.B spantype
.RS
read/write file. Reading from it returns current configuration for spans
of the device. Span-specifications can be written to it to change line
modes (but only for a span that is not assigned yet).
.RE
.SH SEE ALSO
dahdi_span_assignments(8), dahdi_genconf(8), dahdi_cfg(8)
.SH AUTHOR
dahdi_span_types was written by Oron Peled. This manual page was
written by Tzafrir Cohen. Permission is granted to copy, distribute
and/or modify this document under the terms of the GNU General Public
License, Version 2 any later version published by the Free Software
Foundation.

View File

@ -7,7 +7,7 @@ dahdi_tool \- Shows status of DAHDI interfaces
.B dahdi_tool
.SH DESCRIPTION
dahdi_tool shows the current status the DAHDI inteface cards plugged
dahdi_tool shows the current status the DAHDI interface cards plugged
to the computer.
It displays values like Current Alarms, SyncSource, Tx/Rx

View File

@ -0,0 +1,49 @@
.TH "DAHDI_WAITFOR_SPAN_ASSIGNMENTS" "8" "22 Jan 2014" "" ""
.SH NAME
dahdi_waitfor_span_assignments \- wait for DAHDI spans to get (un)assigned
.SH SYNOPSIS
.B dahdi_span_assignments assigned
.B dahdi_span_assignments unassigned
.SH DESCRIPTION
DAHDI spans get assigned / unassigned asynchronously.
.B dahdi_span_assignments
is a helper script that allows running commands after all the spans have
been assigned or unassigned.
It takes a single command: \fBassigned\fR or \fBunassigned\fR and waits
(up until a timeout of 5 seconds) for all the DAHDI spans in the system
to do so.
Note that if the system has a span that will not get assigned
automatically (e.g.: it's not in assigned\-spans.conf), this program
does not know and will wait until a timeout.
.SH EXAMPLES
modprobe wctdm24xxp
dahdi_waitfor_span_assignments assigned
do_something
dahdi_span_assignments add
dahdi_waitfor_span_assignments assigned
do_something_else
dahdi_span_assignments remove
dahdi_span_assignments unassigned
do_something_completely_different
.SH SEE ALSO
dahdi_span_assignments(8)
.SH AUTHOR
dahdi_waitfor_span_assignments was written by Oron Peled. This manual
page was written by Tzafrir Cohen. Permission is granted to copy,
distribute and/or modify this document under the terms of the GNU
General Public License, Version 2 any later version published by the
Free Software Foundation.

View File

@ -11,6 +11,7 @@ fxotune \- automatically tune DAHDI FXO channels
\- dump mode
.B fxotune \-s
.I [ options ]
\- Startup mode
.SH
.SH DESCRIPTION
@ -32,7 +33,7 @@ is generated in the current directory.
fxotune just reads the settings from fxotune.conf into the FXO modules.
You are advised to run fxotune on all FXO ports you have that support
it and that are connected. Note that the tunning is affected by e.g.
it and that are connected. Note that the tuning is affected by e.g.
the physical parameters of the connection, and thus if it has been
radically changed, you may need to re-run fxotune.
@ -43,7 +44,7 @@ cards and clones) do not have the hardware to support such tuning.
The tuning process needs a clear line to do the tuning. In order to do
that, it runs in cycles of the following: sets the line off-hook, dials
a dial string (which should set the PSTN provider waiting for the next
digit), and then starts tuning. It has a limited ammount of time for
digit), and then starts tuning. It has a limited amount of time for
tuning before the PSTN gives up and gives a busy tone. So after a while
it hangs up and starts a new cycle.
@ -179,7 +180,7 @@ so if you stop it half-way, you may get a half-configured system. If you
have already tuned your FXO channels and wish to test-run fxotune again,
you are advised to backup /etc/fxotune.conf .
The default for \-m is 18 seconds. This asusmes that you get a clear line
The default for \-m is 18 seconds. This assumes that you get a clear line
for at least 18 seconds. It is advised that you test that timeout earlier
by connecting a phone to the FXO line, dialing 4 (or whatever dial string
you put with \-n) and see how much time of silence you have.

View File

@ -47,7 +47,6 @@ static float sintable[SINE_SAMPLES];
static const float amplitude = 16384.0;
static char *dahdipath = "/dev/dahdi";
static char *configfile = "/etc/fxotune.conf";
static int audio_dump_fd = -1;
@ -913,6 +912,66 @@ retry:
return 0;
}
static int channel_is_fxo(int channo)
{
int res = 0;
int fd;
const char *CTL_DEV = "/dev/dahdi/ctl";
struct dahdi_params params;
fd = open(CTL_DEV, O_RDWR, 0600);
if (-1 == fd) {
fprintf(stderr, "Failed to open %s: %s\n",
CTL_DEV, strerror(errno));
return -1;
}
params.channo = channo;
if (ioctl(fd, DAHDI_GET_PARAMS, &params)) {
fprintf(stderr,
"%d is not a valid channel number.\n", channo);
res = -1;
} else if (0 == (__DAHDI_SIG_FXS & params.sigcap)) {
fprintf(stderr,
"Channel %d is not an FXO port.\n", channo);
res = -1;
} else if (0 == params.sigtype) {
fprintf(stderr,
"Cannot run on unconfigured channel %d. Please run dahdi_cfg to configure channels before running fxotune.\n",
channo);
res = -1;
}
close(fd);
return res;
}
static int channel_open(int channo)
{
int fd;
const char *DEVICE = "/dev/dahdi/channel";
if (channo > 0) {
if (channel_is_fxo(channo))
return -1;
fd = open(DEVICE, O_RDWR, 0600);
if (fd < 0) {
perror(DEVICE);
return -1;
}
if (ioctl(fd, DAHDI_SPECIFY, &channo) < 0) {
perror("DADHI_SPECIFY ioctl failed");
close(fd);
fd = -1;
}
} else {
fprintf(stderr,
"Specified channel is not a valid channel number");
fd = -1;
}
return fd;
}
/**
* Reads echo register settings from the configuration file and pushes them into
* the appropriate devices
@ -921,7 +980,7 @@ retry:
*
* @return 0 if successful, !0 otherwise
*/
static int do_set(char *configfilename)
static int do_set(char *configfilename, int dev_range, int startdev, int stopdev)
{
FILE *fp = NULL;
int res = 0;
@ -948,6 +1007,8 @@ static int do_set(char *configfilename)
if (res == EOF) {
break;
}
if (dev_range && (mydahdi < startdev || mydahdi > stopdev))
continue;
/* Check to be sure conversion is done correctly */
if (OUT_OF_BOUNDS(myacim) || OUT_OF_BOUNDS(mycoef1)||
@ -969,11 +1030,10 @@ static int do_set(char *configfilename)
mycoefs.coef7 = mycoef7;
mycoefs.coef8 = mycoef8;
snprintf(completedahdipath, sizeof(completedahdipath), "%s/%d", dahdipath, mydahdi);
fd = open(completedahdipath, O_RDWR);
if (debug >= 2)
printf("fxotune: set channel %d\n", mydahdi);
fd = channel_open(mydahdi);
if (fd < 0) {
fprintf(stdout, "open error on %s: %s\n", completedahdipath, strerror(errno));
return -1;
}
@ -1014,11 +1074,8 @@ static int do_dump(int startdev, char* dialstr, int delayuntilsilence, int silen
char dahdidev[80] = "";
int dahdimodule = startdev;
snprintf(dahdidev, sizeof(dahdidev), "%s/%d", dahdipath, dahdimodule);
fd = open(dahdidev, O_RDWR);
fd = channel_open(dahdimodule);
if (fd < 0) {
fprintf(stdout, "%s absent: %s\n", dahdidev, strerror(errno));
return -1;
}
@ -1060,7 +1117,6 @@ static int do_calibrate(int startdev, int enddev, int calibtype, char* configfil
int res = 0;
int configfd, fd;
int devno = 0;
char dahdidev[80] = "";
struct wctdm_echo_coefs coefs;
configfd = open(configfile, O_CREAT|O_TRUNC|O_WRONLY, 0666);
@ -1071,15 +1127,12 @@ static int do_calibrate(int startdev, int enddev, int calibtype, char* configfil
}
for (devno = startdev; devno <= enddev; devno++) {
snprintf(dahdidev, sizeof(dahdidev), "%s/%d", dahdipath, devno);
fd = open(dahdidev, O_RDWR);
fd = channel_open(devno);
if (fd < 0) {
fprintf(stdout, "%s absent: %s\n", dahdidev, strerror(errno));
continue;
}
fprintf(stdout, "Tuning module %s\n", dahdidev);
fprintf(stdout, "Tuning module %d\n", devno);
if (1 == calibtype)
res = acim_tune(fd, dialstr, delayuntilsilence, silencegoodfor, &coefs);
@ -1138,6 +1191,7 @@ int main(int argc , char **argv)
{
int startdev = 1; /* -b */
int stopdev = 252; /* -e */
int dev_range = 0; /* false */
int calibtype = 2; /* -t */
int waveformtype = -1; /* -w multi-tone by default. If > 0, single tone of specified frequency */
int delaytosilence = 0; /* -l */
@ -1179,9 +1233,11 @@ int main(int argc , char **argv)
continue;
case 'b':
startdev = moreargs ? atoi(argv[++i]) : startdev;
dev_range = 1;
break;
case 'e':
stopdev = moreargs ? atoi(argv[++i]) : stopdev;
dev_range = 1;
break;
case 't':
calibtype = moreargs ? atoi(argv[++i]) : calibtype;
@ -1251,13 +1307,13 @@ int main(int argc , char **argv)
if (docalibrate){
res = do_calibrate(startdev, stopdev, calibtype, configfile, dialstr, delaytosilence, silencegoodfor);
if (!res)
return do_set(configfile);
return do_set(configfile, dev_range, startdev, stopdev);
else
return -1;
}
if (doset)
return do_set(configfile);
return do_set(configfile, dev_range, startdev, stopdev);
if (dodump){
res = do_dump(startdev, dialstr, delaytosilence, silencegoodfor, waveformtype);

View File

@ -33,6 +33,7 @@
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <dahdi/user.h>
#include <dahdi/wctdm_user.h>
@ -101,6 +102,41 @@ static int dahdi_ring_phone(int fd)
return res;
}
int channel_open(const char *name)
{
int channo, fd;
struct stat filestat;
const char *DEVICE = "/dev/dahdi/channel";
/* stat file, if character device, open it */
channo = strtoul(name, NULL, 10);
fd = stat(name, &filestat);
if (!fd && S_ISCHR(filestat.st_mode)) {
fd = open(name, O_RDWR, 0600);
if (fd < 0) {
perror(name);
return -1;
}
/* try out the dahdi_specify interface */
} else if (channo > 0) {
fd = open(DEVICE, O_RDWR, 0600);
if (fd < 0) {
perror(DEVICE);
return -1;
}
if (ioctl(fd, DAHDI_SPECIFY, &channo) < 0) {
perror("DAHDI_SPECIFY ioctl failed");
return -1;
}
/* die */
} else {
fprintf(stderr, "Specified channel is not a valid character "
"device or channel number");
return -1;
}
return fd;
}
int main(int argc, char *argv[])
{
int fd;
@ -121,7 +157,7 @@ int main(int argc, char *argv[])
" dtmfcid - create a dtmf cid spill without polarity reversal\n");
exit(1);
}
fd = open(argv[1], O_RDWR);
fd = channel_open(argv[1]);
if (fd < 0) {
fprintf(stderr, "Unable to open %s: %s\n", argv[1], strerror(errno));
exit(1);

View File

@ -40,7 +40,7 @@
#define RANDOM "/dev/urandom" /* Not genuinely random */
/* #define RANDOM "/dev/random" */ /* Quite genuinely random */
int myread(int fd, char *buf, int len)
int myread(int fd, unsigned char *buf, int len)
{
int sofar;
int res;

View File

@ -107,13 +107,12 @@ static struct fasthdlc_state fs;
void send_packet(unsigned char *buf, int len)
{
int res;
int x;
unsigned char outbuf[BLOCK_SIZE];
int pos=0;
unsigned int fcs = PPP_INITFCS;
if (hdlcmode)
res = write(fd, buf, len + 2);
write(fd, buf, len + 2);
else {
for (x=0;x<len;x++) {
if (fasthdlc_tx_load(&fs, buf[x]))

11
hotplug/Makefile.am Normal file
View File

@ -0,0 +1,11 @@
nobase_dist_dahditools_SCRIPTS = \
dahdi_handle_device \
dahdi_span_config \
dahdi_auto_assign_compat \
span_config.d/10-dahdi-cfg \
span_config.d/20-fxotune \
span_config.d/50-asterisk \
handle_device.d/10-span-types \
handle_device.d/20-span-assignments \
#

View File

@ -0,0 +1,30 @@
#! /bin/sh
devdir='/sys/bus/dahdi_devices/devices'
# DAHDI is loaded?
if [ ! -d "$devdir" ]; then
exit 0
fi
devices_by_registration_time() {
grep -H '' $devdir/*/registration_time 2>/dev/null | \
sed 's,/registration_time:,\t,' | \
sort -k 2,2
}
# First assign non-Astribank devices
devices_by_registration_time | \
grep -v '/astribanks:' | \
while read devpath time; do
echo >&2 "D: auto '$devpath'"
dahdi_span_assignments auto "$devpath"
done
# Now handle Astribanks
unmatched="`dahdi_span_assignments unmatched`"
if [ -n "$unmatched" ]; then
# Only if astribanks are not matched in span-assignments.conf
# TODO: have dahdi_registration run only on "$unmatched"
LC_ALL=C dahdi_registration -Rv on
fi

87
hotplug/dahdi_handle_device Executable file
View File

@ -0,0 +1,87 @@
#! /bin/sh
#
# /usr/share/dahdi/dahdi_handle_device
#
# Called by UDEV when a dahdi device is added/removed
#
me=`basename $0`
dir=`dirname $0`
LOGGER="logger -i -t '$me'"
NAME=`basename "$DEVPATH" | tr -c 'A-Za-z0-9-' '_'`
# Always redirect stderr somewhere, otherwise the shell script will die
# when it tries to do I/O related stuff on closed file descriptor.
# Our default is to throw it down the bit-bucket.
exec 2> /dev/null
# If you wish to trace this script:
#exec 2> "/tmp/${me}.$NAME" 1>&2
#exec 2> /dev/console
# Our directory in the beginning, so we can use local lab setup
PATH="$dir:/usr/sbin:/sbin:/usr/bin:/bin"
export PATH
set -e
#echo >&2 "$0($ACTION): DEBUG($# args): '$*'"
# Do we have a configuration?
if [ -f /etc/dahdi/init.conf ]; then
. /etc/dahdi/init.conf
fi
if [ "$DAHDI_UDEV_DISABLE_DEVICES" = 'yes' ]; then
echo "DAHDI_UDEV_DISABLE_DEVICES=yes. Skip $DEVPATH" | $LOGGER
exit 0
fi
# Can we pass a different value so we can use
# alternate (testing) configuration?
# Meanwhile, make it hard-coded.
DAHDICONFDIR='/etc/dahdi'
export DAHDICONFDIR
run_parts() {
# Have our internal "run-parts" (adapted from Fedora),
# as implementations differ
for i in `LC_ALL=C; ls -d $dir/handle_device.d/*[!~,] 2>/dev/null` ; do
[ -d "$i" ] && continue
[ ! -x "$i" ] && continue
# Don't run *.{rpmsave,rpmorig,rpmnew,swp,cfsaved} files
case "$i" in
*.cfsaved|*.rpmsave|*.rpmorig|*.rpmnew|*.swp|*,v)
continue
;;
esac
echo "D: Running '$i'"
"$i"
done
}
case "$ACTION" in
add)
echo "$ACTION: $DEVPATH" | $LOGGER
# Check if we can safely do our job
if [ ! -f /sys/module/dahdi/parameters/auto_assign_spans ]; then
echo "Old driver (no auto_assign_spans parameter). Skip $DEVPATH" | $LOGGER
exit 0
fi
if [ `cat /sys/module/dahdi/parameters/auto_assign_spans` -ne 0 ]; then
echo "auto_assign_spans=1. Skip $DEVPATH" | $LOGGER
exit 0
fi
# Background run -- don't block udev
run_parts 2>&1 < /dev/null | $LOGGER &
;;
remove)
echo "$ACTION: $DEVPATH" | $LOGGER
# Background run -- don't block udev
run_parts 2>&1 < /dev/null | $LOGGER &
;;
*)
echo "UNHANDLED: $ACTION: $DEVPATH" | $LOGGER
;;
esac

97
hotplug/dahdi_span_config Executable file
View File

@ -0,0 +1,97 @@
#! /bin/sh
#
# /usr/share/dahdi/dahdi_span_config
#
# Called by UDEV when a dahdi span is added/removed
#
me=`basename $0`
dir=`dirname $0`
LOGGER="logger -i -t '$me'"
NAME=`basename "$DEVPATH" | tr -c 'A-Za-z0-9-' '_'`
exec 2> /dev/null
# Always redirect stderr somewhere, otherwise the shell script will die
# when it tries to do I/O related stuff on closed file descriptor.
# Our default is to throw it down the bit-bucket.
#exec 2> /dev/console
## If you wish to trace this script:
#exec 2> "/tmp/${me}.$NAME" 1>&2
# Our directory in the beginning, so we can use local lab setup
PATH="$dir:/usr/sbin:/sbin:/usr/bin:/bin"
export PATH
set -e
#echo >&2 "$0($ACTION): DEBUG($# args): '$*'"
# Do we have a configuration?
if [ -f /etc/dahdi/init.conf ]; then
. /etc/dahdi/init.conf
fi
if [ "$DAHDI_UDEV_DISABLE_SPANS" = 'yes' ]; then
echo "DAHDI_UDEV_DISABLE_SPANS=yes. Skip $DEVPATH" | $LOGGER
exit 0
fi
# Can we pass a different value so we can use
# alternate (testing) configuration?
# Meanwhile, make it hard-coded.
DAHDICONFDIR='/etc/dahdi'
export DAHDICONFDIR
run_parts() {
# Have our internal "run-parts" (adapted from Fedora),
# as implementations differ
for i in `LC_ALL=C; ls -d $dir/span_config.d/*[!~,] 2>/dev/null` ; do
[ -d "$i" ] && continue
[ ! -x "$i" ] && continue
# Don't run *.{rpmsave,rpmorig,rpmnew,swp,cfsaved} files
case "$i" in
*.cfsaved|*.rpmsave|*.rpmorig|*.rpmnew|*.swp|*,v)
continue
;;
esac
#echo "D: Running '$i'"
"$i"
done
}
case "$ACTION" in
add)
echo "$ACTION: $DEVPATH" | $LOGGER
# Old driver. These scripts probably won't work anyway.
if [ ! -f /sys/module/dahdi/parameters/auto_assign_spans ]; then
if [ -f /sys/module/dahdi ]; then
$LOGGER "Old driver (no auto_assign_spans parameter). Skip $DEVPATH"
exit 0
fi
fi
if [ $(cat /sys/module/dahdi/parameters/auto_assign_spans) -ne 0 ]; then
$LOGGER "auto_assign_spans=1. Skip $DEVPATH"
exit 0
fi
# Set variables
span_devpath="/sys$DEVPATH"
SPANNO=`echo "$span_devpath" | sed 's,.*/span-,,'`
BASECHAN=`cat "$span_devpath/basechan"`
CHANNELS=`cat "$span_devpath/channels"`
ENDCHAN=`expr "$BASECHAN" + "$CHANNELS" - 1`
export SPANNO BASECHAN CHANNELS ENDCHAN
# Background run -- don't block udev
run_parts 2>&1 < /dev/null | $LOGGER &
;;
remove|online|offline)
# Nothing to do yet...
echo "$ACTION: $DEVPATH" | $LOGGER
;;
*)
echo "UNHANDLED: $ACTION: $DEVPATH" | $LOGGER
;;
esac

View File

@ -0,0 +1,12 @@
#! /bin/sh
case "$ACTION" in
add)
;;
*)
exit 0
esac
if [ -r "$DAHDICONFDIR/span-types.conf" ]; then
dahdi_span_types set "/sys$DEVPATH"
fi

View File

@ -0,0 +1,15 @@
#! /bin/sh
case "$ACTION" in
add)
;;
*)
exit 0
esac
# For now, handle only spans in assigned-spans.conf
# We leave other cases to /etc/init.d/dahdi, so
# legacy ordering can be preserved.
if [ -r "$DAHDICONFDIR/assigned-spans.conf" ]; then
dahdi_span_assignments add "/sys$DEVPATH"
fi

View File

@ -0,0 +1,18 @@
#! /bin/sh
# Run xpp_sync whenever an Astribank is connected.
# May be set in /etc/dahdi/init.conf
XPP_SYNC=${XPP_SYNC:-auto}
case "$ACTION" in
add) ;;
*) exit 0 ;;
esac
case "${DEVPATH##*/}" in
astribanks:*) ;;
*) exit 0 ;;
esac
xpp_sync "$XPP_SYNC"

View File

@ -0,0 +1,28 @@
#! /bin/sh
if [ "$ACTION" != 'add' ]; then
# Nothing to do here
exit 0
fi
# Sanity check
checkit=`"dahdi_cfg" --help 2>&1 | grep -- '-S' | wc -l`
if [ "$checkit" != 1 ]; then
echo "Bad dahdi_cfg (no -S support). Skipping"
exit 0
fi
run_dahdi_cfg() {
echo "dahdi_cfg: span $SPANNO <$BASECHAN-$ENDCHAN> ($DEVPATH)"
dahdi_cfg -c "$cfg_file" -S "$SPANNO" -C "$BASECHAN-$ENDCHAN"
}
# Configure DAHDI
cfg_file="$DAHDICONFDIR/system.conf"
if [ -r "$cfg_file" ]; then
run_dahdi_cfg
else
echo "Using auto-generated config for dahdi_cfg"
cfg_file='-'
DAHDI_CONF_FILE="$cfg_file" dahdi_genconf system | run_dahdi_cfg
fi

View File

@ -0,0 +1,12 @@
#! /bin/sh
if [ "$ACTION" != 'add' ]; then
# Nothing to do here
exit 0
fi
fxotune_cfg='/etc/fxotune.conf'
if [ -r "$fxotune_cfg" ]; then
echo "fxotune: span $SPANNO <$BASECHAN-$ENDCHAN> ($DEVPATH)"
fxotune -s -b "$BASECHAN" -e "$ENDCHAN"
fi

View File

@ -0,0 +1,14 @@
#! /bin/sh
# This file, if installed under /usr/share/dahdi/span_config.d/ , will
# attempt to add a newly-generated span to a running copy of Asterisk.
# Asterisk has to be running (if not: it will pick the span on its
# startup), and has to have the channels already configured.
if [ "$ACTION" != 'add' ]; then
# Nothing to do here
exit 0
fi
# Add to asterisk
asterisk -rx "dahdi create channels $BASECHAN $ENDCHAN"

View File

@ -17,3 +17,8 @@
#XPP_FIRMWARE_DIR=/usr/share/dahdi
#XPP_HOTPLUG_DISABLED=yes
#XPP_HOTPLUG_DAHDI=yes
#ASTERISK_SUPPORTS_DAHDI_HOTPLUG=yes
# Disable udev handling:
#DAHDI_UDEV_DISABLE_DEVICES=yes
#DAHDI_UDEV_DISABLE_SPANS=yes

0
m4/.placeholder Normal file
View File

View File

@ -38,6 +38,8 @@ PBX_USB=@PBX_USB@
USB_LIB=@USB_LIB@
USB_INCLUDE=@USB_INCLUDE@
PBX_HDLC=@PBX_HDLC@
DAHDI_INCLUDE=@DAHDI_INCLUDE@
USE_SELINUX=@USE_SELINUX@

View File

@ -1,123 +0,0 @@
#
# Asterisk -- A telephony toolkit for Linux.
#
# Makefile for Menuselect
#
# Copyright (C) 2005-2008, Digium, Inc.
#
# Russell Bryant <russell@digium.com>
#
# This program is free software, distributed under the terms of
# the GNU General Public License
#
# even though we could use '-include makeopts' here, use a wildcard
# lookup anyway, so that make won't try to build makeopts if it doesn't
# exist (other rules will force it to be built if needed)
ifneq ($(wildcard makeopts),)
include makeopts
endif
.PHONY: clean dist-clean distclean test ntest ctest gtest
# Basic set of sources and flags/libraries/includes
OBJS:=menuselect.o strcompat.o
CFLAGS+=-g -D_GNU_SOURCE -Wall
ifeq ($(MENUSELECT_DEBUG),yes)
CFLAGS += -DMENUSELECT_DEBUG
endif
ifdef NCURSES_LIB
C_OBJS += menuselect_curses.o
C_LIBS +=$(NCURSES_LIB)
C_INCLUDE += $(NCURSES_INCLUDE)
ALL_TGTS += cmenuselect
else
ifdef CURSES_LIB
C_OBJS += menuselect_curses.o
C_LIBS +=$(CURSES_LIB)
C_INCLUDE += $(CURSES_INCLUDE)
ALL_TGTS += cmenuselect
endif
endif
ifdef GTK2_LIB
G_OBJS += menuselect_gtk.o
G_LIBS += $(GTK2_LIB)
G_INCLUDE += $(GTK2_INCLUDE)
ALL_TGTS += gmenuselect
endif
ifdef NEWT_LIB
N_OBJS += menuselect_newt.o
N_LIBS += $(NEWT_LIB)
N_INCLUDE += $(NEWT_INCLUDE)
ALL_TGTS += nmenuselect
endif
M_OBJS += menuselect_stub.o
ALL_TGTS += menuselect
all: $(ALL_TGTS)
$(OBJS) $(C_OBJS) $(N_OBJS) $(G_OBJS) $(M_OBJS): autoconfig.h menuselect.h
makeopts autoconfig.h: autoconfig.h.in makeopts.in
@./configure $(CONFIGURE_SILENT)
$(ALL_TGTS): mxml/libmxml.a
ifdef C_OBJS
menuselect_curses.o: CFLAGS+=$(C_INCLUDE)
cmenuselect: $(OBJS) $(C_OBJS)
$(CC) $(LDFLAGS) -o $@ $^ $(C_LIBS)
else
cmenuselect:
endif
ifdef G_OBJS
menuselect_gtk.o: CFLAGS+=$(G_INCLUDE)
gmenuselect: $(OBJS) $(G_OBJS)
$(CC) $(LDFLAGS) -o $@ $^ $(G_LIBS)
else
gmenuselect:
endif
ifdef N_OBJS
menuselect_newt.o: CFLAGS+=$(N_INCLUDE)
nmenuselect: $(OBJS) $(N_OBJS)
$(CC) $(LDFLAGS) -o $@ $^ $(N_LIBS)
else
nmenuselect:
endif
menuselect: $(OBJS) $(M_OBJS)
$(CC) $(LDFLAGS) -o $@ $^ $(M_LIBS)
mxml/libmxml.a:
@if test ! -f mxml/Makefile ; then cd mxml && ./configure ; fi
@$(MAKE) -C mxml libmxml.a
test: menuselect
(cd test; ../$< menuselect.makeopts)
ctest: cmenuselect
(cd test; ../$< menuselect.makeopts)
gtest: gmenuselect
(cd test; ../$< menuselect.makeopts)
ntest: nmenuselect
(cd test; ../$< menuselect.makeopts)
clean:
rm -f menuselect cmenuselect gmenuselect nmenuselect $(OBJS) $(M_OBJS) $(C_OBJS) $(G_OBJS) $(N_OBJS)
@if test -f mxml/Makefile ; then $(MAKE) -C mxml clean ; fi
dist-clean: distclean
distclean: clean
@if test -f mxml/Makefile ; then $(MAKE) -C mxml distclean ; fi
rm -f autoconfig.h config.status config.log makeopts
rm -rf autom4te.cache

View File

@ -1,179 +0,0 @@
MENUSELECT
Copyright (C) 2005-2006, Digium, Inc.
Russell Bryant <russell@digium.com>
-------------------------------------------------------------------------------
ABOUT
Menuselect is a tool designed to be used in conjunction with GNU make. It
allows for an XML specification of Makefile variables and optional space
delimited values of these variables. These values can then be used in the
Makefile to make various decisions during the build process.
Menuselect also provides a mechanism for dependency checking for each possible
member (value) of each category (Makefile variable). These dependencies are
generally checked by using autoconf and the results provided to menuselect. If
dependencies for a member are not met, the user will not be allowed to make
that selection. In the same way the menuselect does dependency checking, it
also does conflict checking. If a listed conflict for a member is met, then
the user will not be allowed to select it.
For use with automated builds or when the user has no desire to make selections
different than the defined defaults, menuselect can generate a default output
file for use in the build.
Menuselect can also do a sanity check on existing input files. If any member
has been selected that has conflicts or unmet dependencies, then menuselect
will exit with an error and output to notify the user of the situation. This is
typically done at the beginning of the build process to ensure that given all
of the known information, the build is going to be successful.
MENUSELECT DEPENDENCIES
libncurses -- This is needed for the curses frontend.
libnewt -- This is needed for the newt frontend (optional).
libmxml -- This library, Mini-XML, is used for XML parsing.
(http://www.easysw.com/~mike/mxml/)
(Asterisk uses the code in http://svn.digium.com/svn/mxml/ )
ENVIRONMENT SETUP
The file menuselect.h contains a couple of defines which specify locations for
various files. These locations are relative to the directory from which
menuselect will be executed.
#define OUTPUT_MAKEOPTS_DEFAULT "menuselect.makeopts"
This is the location where the menuselect output will be saved.
#define MENUSELECT_DEPS "build_tools/menuselect-deps"
This is the location where menuselect will expect to find the input file that
provides dependency and conflict information. More information on the format of
this file can be found in the section about dependency and conflict checking.
DEPENDENCY AND CONFLICT CHECKING
Members may have as many conflicts and dependencies specified as needed. An
example of the MENUSELECT_DEPS file would look like this:
DEPENDENCY1=1
DEPENDENCY2=0
CONFLICT1=0
In this case, "DEPENDENCY1" has been met, "DEPENDENCY2" has not been met, and
"CONFLICT1" is not present.
To ask menuselect to do a background sanity check on dependencies and
conflicts, it can be called like this:
./menuselect --check-deps <input_file1> [input_file2] [...]
The format of the input files must be of the same format menuselect uses to
create the OUPUT_MAKEOPTS_DEFAULT.
ENABLING AND DISABLING OPTIONS FROM THE COMMAND LINE
If you would like menuselect to update choices via the command line, it can be
done with the following syntax:
Enable an option:
$ menuselect/menuselect --enable TEST_FRAMEWORK menuselect.makeopts
Enable all options in a category:
$ menuselect/menuselect --enable-category MENUSELECT_TEST menuselect.makeopts
Disable an option:
$ menuselect/menuselect --disable TEST_FRAMEWORK menuselect.makeopts
Disable all options in a category:
$ menuselect/menuselect --disable-category MENUSELECT_TEST menuselect.makeopts
SETTING UP AVAILABLE OPTIONS
The XML specification for the menu lives in the file "menuselect-tree" and should
be in the same directory that menuselect will be executed from. An example
menuselect-tree file as used in the Asterisk project (http://www.asterisk.org) is
provided in example_menuselect-tree
Menu:
The top level tag in menuselect-tree is the <menu> tag. All of the categories
reside inside of the <menu> ... </menu> block.
Menu Attributes:
name="Asterisk Module Selection"
This specifies the title of the menu. It is displayed at the top of the
screen when using the curses frontend
Categories:
A <category> contains members. The category tag can contain a number of
different attributes to specify different behavior.
Category Attributes:
name="MENUSELECT_APPS"
The name attribute is required. This is the name of the variable that will
be in the output from menuselect.
displayname="Applications"
If this is specfied, this is what will be shown in the menu to the user.
positive_output="yes"
The default for menuselect is to output all of the members of a category
that are *not* selected. This is because it is often convenient to be able
to define a full list in the Makefile and then filter out the results from
menuselect. Using GNU make, an example of this would be:
APPS:=$(filter-out $(MENUSELECT_APPS),$(APPS))
remove_on_change=".lastclean"
This attribute can contain a space delimited list of files to be deleted
when it is time to build an output file if any of the members of this
category have changed values from their values for existing input when the
application was started.
Members:
A <member> contains conflicts and dependencies. The member tag can contain a
number of different attributes to specify different behavior.
Member Attributes:
name="app_meetme"
The name attribute is required. This is the value that will be added to the
variable specified by the category when selected (or not selected) depending
on the setting of the positive_output attribute of the category.
displayname="Call Conferencing Application"
If this is specified, this will be provided as a description of this member
when the cursor is on it in the menu.
remove_on_change="apps/app_meetme.o apps/app_meetme.so"
This attribute can contain a space delimeted list of files to be deleted
when it is time to build an output file if the value of this member has
changed from its value in any existing input when the application was
started.
Dependencies:
A dependency for a <member> is specified using a <depend> tag. The name of
the dependency corresponds to names in the MENUSELECT_DEPS file. This is an
example of specifying a dependency for a member:
<member name="app_meetme">
<depend>zaptel</depend>
</member>
Conflicts:
A conflict for a <member> is specified using a <conflict> tag. The name of
the conflict corresponds to names in the MENUSELECT_DEPS file. This is an
example of specifying a dependency for a member:
<member name="res_musiconhold">
<conflict>win32</conflict>
</member>
REPORTING BUGS
Any bug reports or feature enhancement submissions to menuselect should be
submitted at https://issues.asterisk.org/
Thank you!

View File

@ -1,199 +0,0 @@
# Helper function to check for gcc attributes.
# AST_GCC_ATTRIBUTE([attribute name], [attribute syntax], [attribute scope], [makeopts flag])
AC_DEFUN([AST_GCC_ATTRIBUTE],
[
AC_MSG_CHECKING(checking for compiler 'attribute $1' support)
saved_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Wall -Wno-unused -Werror"
m4_ifval([$4],$4=0)
if test "x$2" = "x"
then
AC_COMPILE_IFELSE(
AC_LANG_PROGRAM([$3 void __attribute__(($1)) *test(void *muffin, ...) {return (void *) 0;}],
[]),
AC_MSG_RESULT(yes)
m4_ifval([$4],$4=1)
AC_DEFINE_UNQUOTED([HAVE_ATTRIBUTE_$1], 1, [Define to 1 if your GCC C compiler supports the '$1' attribute.]),
AC_MSG_RESULT(no)
)
else
AC_COMPILE_IFELSE(
AC_LANG_PROGRAM([$3 void __attribute__(($2)) *test(void *muffin, ...) {return (void *) 0;}],
[]),
AC_MSG_RESULT(yes)
m4_ifval([$4],$4=1)
AC_DEFINE_UNQUOTED([HAVE_ATTRIBUTE_$1], 1, [Define to 1 if your GCC C compiler supports the '$1' attribute.]),
AC_MSG_RESULT(no)
)
fi
m4_ifval([$4],[AC_SUBST($4)])
CFLAGS="$saved_CFLAGS"
])
# AST_EXT_LIB_SETUP([package symbol name], [package friendly name], [package option name], [additional help text])
AC_DEFUN([AST_EXT_LIB_SETUP],
[
$1_DESCRIP="$2"
$1_OPTION="$3"
AC_ARG_WITH([$3], AC_HELP_STRING([--with-$3=PATH],[use $2 files in PATH $4]),[
case ${withval} in
n|no)
USE_$1=no
;;
y|ye|yes)
$1_MANDATORY="yes"
;;
*)
$1_DIR="${withval}"
$1_MANDATORY="yes"
;;
esac
])
PBX_$1=0
AC_SUBST([$1_LIB])
AC_SUBST([$1_INCLUDE])
AC_SUBST([PBX_$1])
])
# AST_EXT_LIB_CHECK([package symbol name], [package library name], [function to check], [package header], [additional LIB data])
AC_DEFUN([AST_EXT_LIB_CHECK],
[
if test "${USE_$1}" != "no"; then
pbxlibdir=""
if test "x${$1_DIR}" != "x"; then
if test -d ${$1_DIR}/lib; then
pbxlibdir="-L${$1_DIR}/lib"
else
pbxlibdir="-L${$1_DIR}"
fi
fi
AC_CHECK_LIB([$2], [$3], [AST_$1_FOUND=yes], [AST_$1_FOUND=no], ${pbxlibdir} $5)
if test "${AST_$1_FOUND}" = "yes"; then
$1_LIB="-l$2 $5"
$1_HEADER_FOUND="1"
if test "x${$1_DIR}" != "x"; then
$1_LIB="${pbxlibdir} ${$1_LIB}"
$1_INCLUDE="-I${$1_DIR}/include"
if test "x$4" != "x" ; then
AC_CHECK_HEADER([${$1_DIR}/include/$4], [$1_HEADER_FOUND=1], [$1_HEADER_FOUND=0] )
fi
else
if test "x$4" != "x" ; then
AC_CHECK_HEADER([$4], [$1_HEADER_FOUND=1], [$1_HEADER_FOUND=0] )
fi
fi
if test "x${$1_HEADER_FOUND}" = "x0" ; then
if test ! -z "${$1_MANDATORY}" ;
then
AC_MSG_NOTICE( ***)
AC_MSG_NOTICE( *** It appears that you do not have the $2 development package installed.)
AC_MSG_NOTICE( *** Please install it to include ${$1_DESCRIP} support, or re-run configure)
AC_MSG_NOTICE( *** without explicitly specifying --with-${$1_OPTION})
exit 1
fi
$1_LIB=""
$1_INCLUDE=""
PBX_$1=0
else
PBX_$1=1
AC_DEFINE_UNQUOTED([HAVE_$1], 1, [Define to indicate the ${$1_DESCRIP} library])
fi
elif test ! -z "${$1_MANDATORY}";
then
AC_MSG_NOTICE(***)
AC_MSG_NOTICE(*** The ${$1_DESCRIP} installation on this system appears to be broken.)
AC_MSG_NOTICE(*** Either correct the installation, or run configure)
AC_MSG_NOTICE(*** without explicitly specifying --with-${$1_OPTION})
exit 1
fi
fi
])
AC_DEFUN(
[AST_CHECK_GNU_MAKE], [AC_CACHE_CHECK([for GNU make], [ac_cv_GNU_MAKE],
ac_cv_GNU_MAKE='Not Found' ;
ac_cv_GNU_MAKE_VERSION_MAJOR=0 ;
ac_cv_GNU_MAKE_VERSION_MINOR=0 ;
for a in make gmake gnumake ; do
if test -z "$a" ; then continue ; fi ;
if ( sh -c "$a --version" 2> /dev/null | grep GNU 2>&1 > /dev/null ) ; then
ac_cv_GNU_MAKE=$a ;
ac_cv_GNU_MAKE_VERSION_MAJOR=`$ac_cv_GNU_MAKE --version | grep "GNU Make" | cut -f3 -d' ' | cut -f1 -d'.'`
ac_cv_GNU_MAKE_VERSION_MINOR=`$ac_cv_GNU_MAKE --version | grep "GNU Make" | cut -f2 -d'.' | cut -c1-2`
break;
fi
done ;
) ;
if test "x$ac_cv_GNU_MAKE" = "xNot Found" ; then
AC_MSG_ERROR( *** Please install GNU make. It is required to build Asterisk!)
exit 1
fi
AC_SUBST([GNU_MAKE], [$ac_cv_GNU_MAKE])
])
# AST_FUNC_FORK
# -------------
AN_FUNCTION([fork], [AST_FUNC_FORK])
AN_FUNCTION([vfork], [AST_FUNC_FORK])
AC_DEFUN([AST_FUNC_FORK],
[AC_REQUIRE([AC_TYPE_PID_T])dnl
AC_CHECK_HEADERS(vfork.h)
AC_CHECK_FUNCS(fork vfork)
if test "x$ac_cv_func_fork" = xyes; then
_AST_FUNC_FORK
else
ac_cv_func_fork_works=$ac_cv_func_fork
fi
if test "x$ac_cv_func_fork_works" = xcross; then
case $host in
*-*-amigaos* | *-*-msdosdjgpp* | *-*-uclinux* | *-*-linux-uclibc* )
# Override, as these systems have only a dummy fork() stub
ac_cv_func_fork_works=no
;;
*)
ac_cv_func_fork_works=yes
;;
esac
AC_MSG_WARN([result $ac_cv_func_fork_works guessed because of cross compilation])
fi
ac_cv_func_vfork_works=$ac_cv_func_vfork
if test "x$ac_cv_func_vfork" = xyes; then
_AC_FUNC_VFORK
fi;
if test "x$ac_cv_func_fork_works" = xcross; then
ac_cv_func_vfork_works=$ac_cv_func_vfork
AC_MSG_WARN([result $ac_cv_func_vfork_works guessed because of cross compilation])
fi
if test "x$ac_cv_func_vfork_works" = xyes; then
AC_DEFINE(HAVE_WORKING_VFORK, 1, [Define to 1 if `vfork' works.])
else
AC_DEFINE(vfork, fork, [Define as `fork' if `vfork' does not work.])
fi
if test "x$ac_cv_func_fork_works" = xyes; then
AC_DEFINE(HAVE_WORKING_FORK, 1, [Define to 1 if `fork' works.])
fi
])# AST_FUNC_FORK
# _AST_FUNC_FORK
# -------------
AC_DEFUN([_AST_FUNC_FORK],
[AC_CACHE_CHECK(for working fork, ac_cv_func_fork_works,
[AC_RUN_IFELSE(
[AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT],
[
/* By Ruediger Kuhlmann. */
return fork () < 0;
])],
[ac_cv_func_fork_works=yes],
[ac_cv_func_fork_works=no],
[ac_cv_func_fork_works=cross])])]
)# _AST_FUNC_FORK

14
menuselect/aclocal.m4 vendored
View File

@ -1,14 +0,0 @@
# generated automatically by aclocal 1.11.1 -*- Autoconf -*-
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
# 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
m4_include([acinclude.m4])

View File

@ -1,128 +0,0 @@
/* autoconfig.h.in. Generated from configure.ac by autoheader. */
#ifndef MENUSELECT_AUTOCONFIG_H
#define MENUSELECT_AUTOCONFIG_H
#ifndef _REENTRANT
#define _REENTRANT
#endif
/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
systems. This function is required for `alloca.c' support on those systems.
*/
#undef CRAY_STACKSEG_END
/* Define to 1 if using `alloca.c'. */
#undef C_ALLOCA
/* Define to 1 if you have `alloca', as a function or macro. */
#undef HAVE_ALLOCA
/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
#undef HAVE_ALLOCA_H
/* Define to 1 if you have the `asprintf' function. */
#undef HAVE_ASPRINTF
/* Define to 1 if your GCC C compiler supports the 'weak' attribute. */
#undef HAVE_ATTRIBUTE_weak
/* Define to 1 if your GCC C compiler supports the 'weak_import' attribute. */
#undef HAVE_ATTRIBUTE_weak_import
/* Define to 1 if your GCC C compiler supports the 'weakref' attribute. */
#undef HAVE_ATTRIBUTE_weakref
/* Define to indicate the ${CURSES_DESCRIP} library */
#undef HAVE_CURSES
/* Define to 1 if you have the `getloadavg' function. */
#undef HAVE_GETLOADAVG
/* Define if your system has the GTK2 libraries. */
#undef HAVE_GTK2
/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H
/* Define to indicate the ${NCURSES_DESCRIP} library */
#undef HAVE_NCURSES
/* Define to indicate the ${NEWT_DESCRIP} library */
#undef HAVE_NEWT
/* Define to 1 if you have the `setenv' function. */
#undef HAVE_SETENV
/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the `strcasestr' function. */
#undef HAVE_STRCASESTR
/* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the `strndup' function. */
#undef HAVE_STRNDUP
/* Define to 1 if you have the `strnlen' function. */
#undef HAVE_STRNLEN
/* Define to 1 if you have the `strsep' function. */
#undef HAVE_STRSEP
/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define to 1 if you have the `unsetenv' function. */
#undef HAVE_UNSETENV
/* Define to 1 if you have the `vasprintf' function. */
#undef HAVE_VASPRINTF
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at runtime.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
#undef STACK_DIRECTION
/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS
#endif

View File

@ -1,41 +0,0 @@
#!/bin/sh
check_for_app() {
$1 --version 2>&1 >/dev/null
if [ $? != 0 ]
then
echo "Please install $1 and run bootstrap.sh again!"
exit 1
fi
}
uname -s | grep -q FreeBSD
if [ $? = 0 ]
then
check_for_app autoconf259
check_for_app autoheader259
check_for_app automake19
check_for_app aclocal19
echo "Generating the configure script ..."
aclocal19 2>/dev/null
autoconf259
autoheader259
automake19 --add-missing --copy 2>/dev/null
else
AUTOCONF_VERSION=2.59
AUTOMAKE_VERSION=1.9
export AUTOCONF_VERSION
export AUTOMAKE_VERSION
check_for_app autoconf
check_for_app autoheader
check_for_app automake
check_for_app aclocal
echo "Generating the configure script ..."
aclocal 2>/dev/null
autoconf
autoheader
automake --add-missing --copy 2>/dev/null
fi
exit 0

1501
menuselect/config.guess vendored

File diff suppressed because it is too large Load Diff

1705
menuselect/config.sub vendored

File diff suppressed because it is too large Load Diff

7422
menuselect/configure vendored

File diff suppressed because it is too large Load Diff

View File

@ -1,146 +0,0 @@
# Process this file with autoconf to produce a configure script.
AC_PREREQ(2.59)
m4_define([MENUSELECT_VERSION],
m4_bpatsubst(m4_esyscmd([./make_version .]),
[\([0-9.]*\)\(\w\|\W\)*],
[\1]))
AC_INIT(menuselect, MENUSELECT_VERSION, www.asterisk.org)
# check existence of the package
AC_CONFIG_SRCDIR([menuselect.c])
# specify output header file
AC_CONFIG_HEADER(autoconfig.h)
AC_COPYRIGHT("Menuselect")
AC_REVISION($Revision: 40837 $)
AC_CANONICAL_BUILD
AC_CANONICAL_HOST
HOST_OS=${host_os}
AC_SUBST(HOST_OS)
PBX_WINARCH=0
case "${host_os}" in
freebsd*)
OSARCH=FreeBSD
;;
netbsd*)
OSARCH=NetBSD
;;
openbsd*)
OSARCH=OpenBSD
;;
solaris*)
OSARCH=SunOS
;;
mingw32)
OSARCH=mingw32
PBX_WINARCH=1
;;
cygwin)
OSARCH=cygwin
PBX_WINARCH=1
;;
linux-gnueabi)
OSARCH=linux-gnu
;;
*)
OSARCH=${host_os}
;;
esac
AH_TOP(
#ifndef MENUSELECT_AUTOCONFIG_H
#define MENUSELECT_AUTOCONFIG_H
#ifndef _REENTRANT
#define _REENTRANT
#endif
)
AH_BOTTOM(
#endif
)
# Checks for programs.
AC_PROG_CC
AST_CHECK_GNU_MAKE
AC_LANG(C)
AC_ARG_ENABLE([debug],
[AS_HELP_STRING([--enable-debug], [Turn on debug mode])],
[case "${enableval}" in
y|ye|yes) MENUSELECT_DEBUG=yes ;;
n|no) MENUSELECT_DEBUG=no ;;
*) AC_MSG_ERROR(bad value ${enableval} for --enable-debug) ;;
esac])
AC_SUBST(MENUSELECT_DEBUG)
# Support weak symbols on a platform specific basis. The Mac OS X
# (Darwin) support must be isolated from the other platforms because
# it has caused other platforms to fail.
#
case "${OSARCH}" in
darwin*)
# Allow weak symbol support on Darwin platforms only because there
# is active community support for it.
# However, Darwin seems to break weak symbols for each new version.
#
AST_GCC_ATTRIBUTE(weak_import, [], [], PBX_WEAKREF)
# Several other platforms including Linux have GCC versions that
# define the weak attribute. However, this attribute is only
# setup for use in the code by Darwin.
AST_GCC_ATTRIBUTE(weak, [], [], PBX_WEAKREF)
;;
linux-gnu)
# Primarily support weak symbols on Linux platforms.
#
AST_GCC_ATTRIBUTE(weakref, [weakref("foo")], static, PBX_WEAKREF)
;;
*)
# Allow weak symbols on other platforms. However, any problems
# with this feature on other platforms must be fixed by the
# community.
#
AST_GCC_ATTRIBUTE(weakref, [weakref("foo")], static, PBX_WEAKREF)
;;
esac
AC_FUNC_ALLOCA
AC_CHECK_FUNCS([asprintf getloadavg setenv strcasestr strndup strnlen strsep unsetenv vasprintf])
# The frontend can use curses, ncurses, newt or GTK2 so check for all of them
AST_EXT_LIB_SETUP([NEWT], [newt], [newt])
AST_EXT_LIB_SETUP([CURSES], [curses], [curses])
AST_EXT_LIB_SETUP([NCURSES], [ncurses], [ncurses])
AST_EXT_LIB_CHECK([NEWT], [newt], [newtBell], [newt.h])
AST_EXT_LIB_CHECK([CURSES], [curses], [initscr], [curses.h])
AST_EXT_LIB_CHECK([NCURSES], [ncurses], [initscr], [curses.h])
PBX_GTK2=0
AC_CHECK_TOOL(PKGCONFIG, pkg-config, No)
if test ! "x${PKGCONFIG}" = xNo; then
GTK2_INCLUDE=$(${PKGCONFIG} gtk+-2.0 --cflags 2>/dev/null)
GTK2_LIB=$(${PKGCONFIG} gtk+-2.0 --libs)
PBX_GTK2=1
AC_DEFINE([HAVE_GTK2], 1, [Define if your system has the GTK2 libraries.])
fi
AC_SUBST(PBX_GTK2)
AC_SUBST(GTK2_INCLUDE)
AC_SUBST(GTK2_LIB)
test "$silent"=yes && ac_sub_configure_args="${ac_sub_configure_args} --silent"
AC_CONFIG_FILES([makeopts])
AC_CONFIG_SUBDIRS([mxml])
AC_OUTPUT
AC_MSG_NOTICE(Menuselect build configuration successfully completed)

View File

@ -1,17 +0,0 @@
all:
clean:
dist-clean:
makeopts:
menuselect:
./menuselect-dummy
# Generate some dummy files to satifsy dependencies from the main
# Makefile.
dummies:
touch linkedlists.h menuselect.c menuselect_curses.c \
menuselect.h menuselect_stub.c

View File

@ -1,741 +0,0 @@
#!/usr/bin/perl -w
# menuselect - a simple drop-in replacement of the batch-mode menuselect
# included with Asterisk.
#
# Copyright (C) 2008 by Tzafrir Cohen <tzafrir.cohen@xorcom.com>
#
# 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
# USA
# Installation: copy this script to menuselect/menuselect . Copy the
# included Makefile as menuselect/Makefile and run:
#
# make -C makefile dummies
#
# It takes configuration from build_tools/conf . Sample config file:
#
# By default all modules will be built (except those marked not be
# used by default)
#
# # exclude: Don't try to build the following modules.
# #exclude app_test
#
# # You can have multiple items in each line, and multiple lines.
# # Each item is a perl regular expression that must match the whole
# # module name.
# #exclude res_config_.*
#
# # include: syntax is the same as exclude. Overrides exclude and
# # modules that are marked as disabled by defualt:
# #include res_config_sqlite3 app_skel
#
# # If you want to make sure some modules will be conifgured to build,
# # you can require them. If modules that match any of the 'require'
# # pattern are not configured to build, menuselect will panic.
# # Same pattern rules apply here. Why would you want that? I have no
# # idea.
# #require chan_h323 app_directory
#
# # random - the value for this keyword is a number between 1 and
# # 100. The higher it is, more chances not to include each module.
# # Writes the list of modules that got hit to
# # build_tools/mods_removed_random .
# # Note that unlike 'make randomconfig' and such the random
# # configuration changes each time you run 'make', thus if a build
# # failed you should first read build_tools/mods_removed_random
# # before re-running make.
# #random 10
#
# # Anything after a '#' is ignored, and likewise empty lines.
# # Naturally.
use strict;
use Getopt::Long;
# Holds global dependncy information. Keys are module names.
my %ModInfo = ();
# extract configuration from kernel modules:
my $AutoconfDepsFile = "build_tools/menuselect-deps";
my $AutoconfOptsFile = "makeopts";
my %ConfigureOpts = (); #
# configuration file to read for some directives:
my $ConfFile = "build_tools/conf";
my $DumpFile = 'build_tools/dump_deps';
# Modules removed randomely:
my $RandomeModsFile = "build_tools/mods_removed_random";
my $MakedepsFile = "menuselect.makedeps";
my $MakeoptsFile = "menuselect.makeopts";
# If those modules are not present, the build will fail (PCRE patterns)
my @RequiredModules = ();
my @Subdirs = qw/addons apps bridges cdr cel channels codecs formats funcs main pbx res tests utils/;
my @XmlCategories = 'cflags';
# Modules should not bother building (PCRE patterns)
my @ExcludedModules = ();
# Do try building those. Overrides 'exclude' and 'defaultenable: no'
my @IncludedModules = ();
# A chance to rule-out a module randomely.
my $RandomKnockoutFactor = 0;
sub warning($) {
my $msg = shift;
print STDERR "$0: Warning: $msg\n";
}
# Convert XML syntax to mail-header-like syntax:
# <var>value</var> --> Var: value
sub extract_xml_key($) {
my %attr = ();
my $xml_line = shift;
if ($xml_line !~ m{^\s*<([a-z_A-Z0-9]+)(\s+([^>]*))?>([^<]*)</\1>}) {
warning "parsed empty value from XML line $xml_line";
return ('', ''); # warn?
}
my ($var, $val) = ($1, $4);
$var =~ s{^[a-z]}{\u$&};
if (defined $3) {
my $attr_text = $3;
while ($attr_text =~ /^( *([^=]+)="([^"]+)")/) {
my ($var, $val) = ($2, $3);
$attr_text =~ s/^$1//;
$attr{$var} = $val;
}
}
return ($var, $val, %attr);
}
# Get information embedded in source files from a subdirectory.
# First parameter is the subdirectory and further ones are the actual
# source files.
sub get_subdir_module_info {
my $subdir = shift;
my @files = @_;
my $dir = uc($subdir);
foreach my $src (@files) {
open SRC,$src or die "Can't read from source file $src: $!\n";
$src =~ m|.*/([^/]*)\.c|;
my $mod_name = $1;
my %data = (
Type=>'module',
Module=>$mod_name,
Dir=> $dir,
Avail=>1
);
while (<SRC>) {
next unless (m|^/\*\*\* MODULEINFO| .. m|^ *[*]+/|);
next unless (m|^[A-Z]| || m|^\s*<|);
# At this point we can assume we're in the module
# info section.
chomp;
my ($var, $val, %attr) = extract_xml_key($_);
foreach (keys %attr) {
push @{$data{$_}},($attr{$_});
}
if ($var =~ /^(Depend|Use)$/i) {
# use uppercase for dependency names;
$val = uc($val);
}
if ( ! exists $data{$var} ) {
$data{$var} = [$val];
} else {
push @{$data{$var}},($val);
}
}
close SRC;
$ModInfo{uc($mod_name)} = \%data;
}
}
# extract embedded information in all the source tree.
sub extract_subdirs {
for my $subdir(@_) {
get_subdir_module_info($subdir, <$subdir/*.c> , <$subdir/*.cc>);
}
}
# parse a partial XML document that is included as an input
# for menuselect in a few places. Naturally a full-fledged XML parsing
# will not be done here. A line-based parsing that happens to work will
# have to do.
sub parse_menuselect_xml_file($) {
my $file_name = shift;
open XML,$file_name or
die "Failed opening XML file $file_name: $!.\n";
my $header = <XML>;
$header =~ /^\s*<category\s+name="MENUSELECT_([^"]+)"\s/;
my $category = $1;
my $member;
while(<XML>){
next unless (m{^\s*<(/?[a-z]+)[>\s]});
my $tag = $1;
if ($tag eq 'member') {
if (! m{^\s*<member\s+name="([^"]+)" displayname="([^"]+)"\s*>}){
warning "Bad XML member line: $_ ($file_name:$.)\n";
next;
}
my ($name, $display_name) = ($1, $2);
$member = {
Type => 'XML',
Dir => $category,
Module => $1,
DisplayName => $2,
Defaultenabled => ['no'],
Avail => 1,
};
} elsif ($tag eq '/member') {
$ModInfo{$member->{Module}} = $member;
} elsif ($tag eq '/category') {
last;
} else {
if (! m/^\s*<([a-z]+)>([^<]+)</) {
warning "(1) Unknown XML line $_ ($file_name:$.)\n";
next
}
my ($key, $val) = extract_xml_key($_);
if ($key eq '') {
warning "Unknown XML line $_ ($file_name:$.)\n";
next
}
if (! exists $member->{$key}) {
$member->{$key} = [];
}
# Make sure dependencies are upper-case.
# FIXME: this is not the proper place for such a fix
$val = uc($val) if ($key =~ /Depend|Use/);
# Using "unshift' rather than 'push'.
# For a singleton value this makes the action an
# override, as only the first value counts.
# For a list value, however, it means a reversed
# order.
unshift @{$member->{$key}}, ($val);
}
}
close XML;
}
# Dump our data structure to a file.
sub dump_deps($) {
my $file = shift;
open OUTPUT,">$file" or
die "cannot open category file $file for writing: $!\n";
foreach my $mod_name (sort keys %ModInfo) {
print OUTPUT "Key: $mod_name\n";
my $data = $ModInfo{$mod_name};
foreach my $var (sort keys %{$data} ) {
my $val = $$data{$var};
if (ref($val) eq 'ARRAY') {
print OUTPUT $var.": ". (join ", ", @$val)."\n";
} else {
print OUTPUT "$var: $val\n";
}
}
print OUTPUT "\n";
}
close OUTPUT;
}
# Get the available libraries that autoconf generated.
sub get_autoconf_deps() {
open DEPS, $AutoconfDepsFile or
die "Failed to open $AutoconfDepsFile. Aborting: $!\n";
my @deps_list = (<DEPS>);
foreach (@deps_list){
chomp;
my ($lib, $avail_val) = split(/=/);
my ($avail, $avail_old) = split(/:/, $avail_val);
my $disabled = 0;
if ($avail == -1) {
$disabled = 1;
$avail = 0;
}
$ModInfo{$lib} = {
Type=>'lib', Avail=>$avail, Disabled => $disabled
};
if (defined $avail_old) {
$ModInfo{$lib}{AvailOld} = $avail_old;
}
# FIXME:
if (($avail ne "0") && ($avail ne "1")) {
warning "Library $lib has invalid availability ".
"value <$avail> (check $AutoconfDepsFile).\n";
}
}
close DEPS;
}
# Get the available libraries that autoconf generated.
sub get_autoconf_opts() {
open OPTS, $AutoconfOptsFile or
die "Failed to open $AutoconfOptsFile. Aborting: $!\n";
while (<OPTS>) {
chomp;
next if /^(#|$)/;
my ($var, $val) = split /\s*=\s*/, $_, 2;
$ConfigureOpts{$var} = $val;
}
close OPTS;
if (not exists $ConfigureOpts{AST_DEVMODE}) {
$ConfigureOpts{AST_DEVMODE} = 'no';
}
}
# Read our specific config file.
#
# Its format:
#
# keyword values
#
# values are always a spaces-separated list.
sub read_conf() {
open CONF,$ConfFile or return;
while (<CONF>) {
# remove comments and empty lines:
chomp;
s/#.*$//;
next if /^\s*$/;
my ($keyword, @value) = split;
if ($keyword eq 'exclude') {
push @ExcludedModules, @value;
} elsif ($keyword eq 'include') {
push @IncludedModules, @value;
} elsif ($keyword eq 'require') {
push @RequiredModules, @value;
} elsif ($keyword eq 'random') {
$RandomKnockoutFactor = $value[0] / 100;
} else {
warning "unknown keyword $keyword in line $. of $ConfFile.";
}
}
}
# generate menuselect.makedeps.
# In this file menuselect writes dependecies of each module. CFLAGS will
# then automatically include for each module the _INCLUDE and LDFLAGS
# will include the _LIBS from all the depedencies of the module.
sub gen_makedeps() {
open MAKEDEPSS, ">$MakedepsFile" or
die "Failed to open deps file $MakedepsFile for writing. Aborting: $!\n";
for my $mod_name (sort keys %ModInfo) {
next unless ($ModInfo{$mod_name}{Type} eq 'module');
my $mod = $ModInfo{$mod_name};
my @deps = ();
# if we have Depend or Use, put their values into
# @deps . If we have none, move on.
push @deps, @{$mod->{Depend}} if (exists $mod->{Depend});
push @deps, @{$mod->{Use}} if (exists $mod->{Use});
next unless @deps;
# TODO: don't print dependencies that are not external libs.
# Not done yet until I figure out if this is safe.
my $dep = join(' ', @deps);
print MAKEDEPSS "MENUSELECT_DEPENDS_".$mod->{Module}."=$dep\n";
}
close MAKEDEPSS;
}
# Set modules from patterns specified by 'exclude' in the configuration file
# to exclude modules from building (mark them as unavailable).
sub apply_excluded_patterns() {
foreach my $pattern (@ExcludedModules) {
my @excluded = grep {/^$pattern$/i} (keys %ModInfo);
foreach (@excluded) {
$ModInfo{$_}{Avail} = 0;
}
}
}
# Set modules from patterns specified by 'include' in the configuration
# file to exclude from building (mark them as available).
sub apply_included_patterns() {
foreach my $pattern (@IncludedModules) {
my @included = grep {/^$pattern$/i} (keys %ModInfo);
foreach (@included) {
$ModInfo{$_}{Avail} = 1;
}
}
}
# If user set the "random" config to anything > 0, drop some random
# modules. May help expose wrong dependencies.
sub apply_random_drop() {
return if ($RandomKnockoutFactor <= 0);
open MODS_LIST, ">$RandomeModsFile" or
die "Failed to open modules list file $RandomeModsFile for writing. Aborting: $!\n";
for my $mod (keys %ModInfo) {
next unless ($ModInfo{$mod}{Type} eq 'module');
next unless (rand() < $RandomKnockoutFactor);
$ModInfo{$mod}{Avail} = 0;
$ModInfo{$mod}{RandomKill} = 1;
print MODS_LIST $ModInfo{$mod}{Module}."\n";
}
close MODS_LIST;
}
sub check_required_patterns() {
my @failed = ();
foreach my $pattern (@RequiredModules) {
my @required = grep {/^$pattern$/i} (keys %ModInfo);
foreach my $mod (@required) {
if ((! exists $ModInfo{$mod}{Checked}) ||
(! $ModInfo{$mod}{Checked}) )
{
push @failed, $mod;
}
}
}
return unless (@failed);
my $failed_str = join ' ',@failed;
die("Missing dependencies for the following modules: $failed_str\n");
}
# Disable building for modules that were marked in the embedded module
# information as disabled for building by default.
sub apply_default_enabled() {
foreach my $mod (keys %ModInfo) {
if ((exists $ModInfo{$mod}{Defaultenabled}) &&
$ModInfo{$mod}{Defaultenabled}[0] eq 'no')
{
$ModInfo{$mod}{Avail} = 0;
}
}
}
# We found a dependency we don't know about. Warn the user, and add
# information about it:
sub handle_unknown_dep($$) {
my ($dep_mod, $mod) = @_;
my $mod_info = {
Type => 'Unknown',
Avail => 0,
Checked => 0,
};
$ModInfo{$dep_mod} = $mod_info;
warning "Unknown dependency module $dep_mod (for e.g. $mod)\n";
}
# recursively check dependency for a module.
#
# We run a scan for modules. Modules marked as 'Checked' are ones we
# have already fully verified to have proper dependencies.
#
# We can only use a module or library marked as Avail => 1 (library
# available or module not excluded).
sub check_module($);
sub check_module($) {
my $mod = shift;
# we checked it:
if (exists $ModInfo{$mod}{Checked}) {
return $ModInfo{$mod}{Checked};
}
# A library has no dependencies of its own.
if ($ModInfo{$mod}{Type} eq 'lib') {
return ($ModInfo{$mod}{Avail} || 0);
}
# An excluded module.
if ($ModInfo{$mod}{Avail} == 0) {
return 0;
}
if (! exists $ModInfo{$mod}{Depend}) {
$ModInfo{$mod}{Checked} = 1;
return 1;
}
my $deps_checked = 1; # may be reset below on failures:
if (exists $ModInfo{$mod}{Tested}) {
# this probably means a circular dependency of some sort.
warning "Got to module $mod that is already tested.";
}
$ModInfo{$mod}{Tested} = 1;
foreach my $dep_mod (@{$ModInfo{$mod}{Depend}} ) {
if (!exists ${ModInfo}{$dep_mod}) {
handle_unknown_dep($dep_mod, $mod);
return 0;
}
$deps_checked &= check_module($dep_mod);
last if(!$deps_checked) # no point testing further if we failed.
}
$ModInfo{$mod}{Checked} = $deps_checked;
return $deps_checked;
}
# The main dependency resolver function.
sub resolve_deps() {
apply_default_enabled();
apply_excluded_patterns();
apply_included_patterns();
foreach my $mod (keys %ModInfo) {
check_module($mod);
}
}
# generate menuselect.makeopts.
# The values in this file obey to different semantics:
# 1. For modules, a module will be built unles listed here
# 2. For XML values (sounds, CFLAGS) it will be enabled if listed here
sub gen_makeopts() {
open MAKEDEPS, ">$MakeoptsFile" or
die "Failed to open opts file $MakeoptsFile for writing. Aborting: $!\n";
my %Subdirs;
foreach my $mod (sort keys %ModInfo) {
next unless ($ModInfo{$mod}{Type} =~ /^(module|XML)$/);
if ($ModInfo{$mod}{Type} eq 'XML') {
next unless ($ModInfo{$mod}{Checked});
} else {
next if ($ModInfo{$mod}{Checked});
}
my $dir = $ModInfo{$mod}{Dir};
if (! exists $Subdirs{$dir}) {
$Subdirs{$dir} = [];
}
push @{$Subdirs{$dir}},( $ModInfo{$mod}{Module} );
}
foreach my $dir (sort keys %Subdirs) {
my $deps = join(' ', @{$Subdirs{$dir}});
print MAKEDEPS "MENUSELECT_$dir=$deps\n";
}
close MAKEDEPS;
}
# Main function for --check-deps
sub check_dependencies() {
read_conf();
extract_subdirs(@Subdirs);
get_autoconf_opts();
parse_menuselect_xml_file('build_tools/cflags.xml');
if ($ConfigureOpts{AST_DEVMODE} eq 'yes') {
parse_menuselect_xml_file('build_tools/cflags-devmode.xml');
}
parse_menuselect_xml_file('sounds/sounds.xml');
apply_random_drop();
get_autoconf_deps();
#dump_deps('build_tools/dump_deps_before_resolve');
resolve_deps();
# Handy debugging:
dump_deps($DumpFile);
check_required_patterns();
gen_makedeps();
gen_makeopts();
}
#
# The main program start here
#
sub read_dump() {
my %items = ();
my $saved_rs = $/;
$/ = "\n\n";
open DUMP_FILE,$DumpFile or die "Can't read from dump file $DumpFile\n";
while (<DUMP_FILE>) {
my %item = ();
my @item_lines = split /\n\r?/;
foreach (@item_lines) {
my ($var, $value) = split /: /, $_, 2;
$item{$var} = $value;
}
# FIXME: dependencies are a list. This should not be a
# special case.
if (exists $item{Depend}) {
$item{Depend} = [split /\s*,\s*/,$item{Depend}];
}
$items{$item{Key}} = \%item;
}
close DUMP_FILE;
$/ = $saved_rs;
return \%items;
}
# Explain why a module (read from the dump file) was not enabled.
# (We assume here that $item->{Avail} is 0)
sub fail_reason($) {
my $item = shift;
if ($item->{Type} eq 'lib') {
return " Not found: system library";
} elsif ($item->{Type} eq 'XML') {
if ($item->{Defaultenabled} !~ /^y/) {
return "Not enabled";
} else {
return "Missing dependencies";
}
} elsif ($item->{Type} eq 'module') {
if (exists ($item->{Defaultenabled}) &&
$item->{Defaultenabled} =~ /^n/) {
return "Disabled";
} else {
return "Missing dependencies";
}
}
}
sub item_used($) {
my $item = shift;
my $type = $item->{Type};
return $item->{Avail} if ($type eq 'lib');
return $item->{Checked};
}
sub print_module_status {
my $flag_verbose = shift;
my $items = read_dump();
my %items_matched = ();
foreach my $pattern (@_) {
foreach (keys %$items) {
if (/$pattern/i) {
$items_matched{$_} = 1;
}
}
}
my @items_list = sort keys %items_matched;
foreach my $item_name (@items_list) {
my $item = $items->{$item_name};
if ($flag_verbose) {
printf "%s %-8s %-30s\n",
(item_used($item)? 'Y':'n'),
$item->{Type},
$item->{Key};
if (!$item->{Avail}) {
my $reason = fail_reason($item);
print " $reason\n";
}
foreach (@{$item->{Depend}}) {
my $depmod = $items->{$_};
printf(" * %-12s ",$_);
print (item_used($depmod)? '': "un");
print "available\n";
}
} else {
printf "%s %-8s %-30s",
(item_used($item)? 'Y':'n'),
$item->{Type},
$item->{Key};
foreach (@{$item->{Depend}}) {
my $depmod = $items->{$_};
if (item_used($depmod)) {
print "$_ ";
} else {
printf "[%s] ", $_;
}
}
print "\n";
}
}
}
sub usage() {
print "$0: menuselect reimplementation\n";
print "\n";
print "Usage:\n";
print "$0 # menuselect processing\n";
print "$0 -m|--modinfo|--moduls-info PATTERN # Status of modules\n";
print "$0 -v|--verbose # verbose (modinfo)\n";
print "$0 -c|--check-deps # Check for dependencies\n";
print "\n";
print "PATTERN is a partial perl regex. Use '-m .' to list all.\n";
}
my @module_status = ();
my $flag_verbose = 0;
my $action = '';
my $rc = GetOptions(
'modinfo|modules-info|m=s' => \@module_status,
'verbose|v' => \$flag_verbose,
'check-deps|c:s' => sub { $action = 'check_dependencies'},
'help|h' => sub { usage(); exit 0 },
);
if (!$rc) {
usage();
exit $rc;
}
if (@module_status) {
$action = 'module_status';
}
if ($action eq 'module_status') {
print_module_status($flag_verbose, @module_status);
exit 0;
} elsif ( $action eq 'check_dependencies') {
check_dependencies();
} else {
usage(); exit(1);
}

View File

@ -1,487 +0,0 @@
<?xml version=1.0?>
<menu name="Asterisk Module Selection">
<category name="MENUSELECT_APPS" displayname="Applications">
<member name="app_adsiprog" displayname="Asterisk ADSI Programming Application" remove_on_change="apps/app_adsiprog.o apps/app_adsiprog.so">
</member>
<member name="app_alarmreceiver" displayname="Alarm Receiver for Asterisk" remove_on_change="apps/app_alarmreceiver.o apps/app_alarmreceiver.so">
</member>
<member name="app_amd" displayname="Answering Machine Detection Application" remove_on_change="apps/app_amd.o apps/app_amd.so">
</member>
<member name="app_authenticate" displayname="Authentication Application" remove_on_change="apps/app_authenticate.o apps/app_authenticate.so">
</member>
<member name="app_cdr" displayname="Tell Asterisk to not maintain a CDR for the current call" remove_on_change="apps/app_cdr.o apps/app_cdr.so">
</member>
<member name="app_chanisavail" displayname="Check channel availability" remove_on_change="apps/app_chanisavail.o apps/app_chanisavail.so">
</member>
<member name="app_channelredirect" displayname="Channel Redirect" remove_on_change="apps/app_channelredirect.o apps/app_channelredirect.so">
</member>
<member name="app_chanspy" displayname="Listen to the audio of an active channel" remove_on_change="apps/app_chanspy.o apps/app_chanspy.so">
</member>
<member name="app_controlplayback" displayname="Control Playback Application" remove_on_change="apps/app_controlplayback.o apps/app_controlplayback.so">
</member>
<member name="app_db" displayname="Database Access Functions" remove_on_change="apps/app_db.o apps/app_db.so">
</member>
<member name="app_dial" displayname="Dialing Application" remove_on_change="apps/app_dial.o apps/app_dial.so">
</member>
<member name="app_dictate" displayname="Virtual Dictation Machine" remove_on_change="apps/app_dictate.o apps/app_dictate.so">
</member>
<member name="app_directed_pickup" displayname="Directed Call Pickup Application" remove_on_change="apps/app_directed_pickup.o apps/app_directed_pickup.so">
</member>
<member name="app_directory" displayname="Extension Directory" remove_on_change="apps/app_directory.o apps/app_directory.so">
</member>
<member name="app_disa" displayname="DISA (Direct Inward System Access) Application" remove_on_change="apps/app_disa.o apps/app_disa.so">
</member>
<member name="app_dumpchan" displayname="Dump Info About The Calling Channel" remove_on_change="apps/app_dumpchan.o apps/app_dumpchan.so">
</member>
<member name="app_echo" displayname="Simple Echo Application" remove_on_change="apps/app_echo.o apps/app_echo.so">
</member>
<member name="app_exec" displayname="Executes dialplan applications" remove_on_change="apps/app_exec.o apps/app_exec.so">
</member>
<member name="app_externalivr" displayname="External IVR Interface Application" remove_on_change="apps/app_externalivr.o apps/app_externalivr.so">
</member>
<member name="app_festival" displayname="Simple Festival Interface" remove_on_change="apps/app_festival.o apps/app_festival.so">
</member>
<member name="app_flash" displayname="Flash zap trunk application" remove_on_change="apps/app_flash.o apps/app_flash.so">
<depend>zaptel</depend>
</member>
<member name="app_followme" displayname="Find-Me/Follow-Me Application" remove_on_change="apps/app_followme.o apps/app_followme.so">
</member>
<member name="app_forkcdr" displayname="Fork The CDR into 2 separate entities." remove_on_change="apps/app_forkcdr.o apps/app_forkcdr.so">
</member>
<member name="app_getcpeid" displayname="Get ADSI CPE ID" remove_on_change="apps/app_getcpeid.o apps/app_getcpeid.so">
</member>
<member name="app_hasnewvoicemail" displayname="Indicator for whether a voice mailbox has messages in a given folder." remove_on_change="apps/app_hasnewvoicemail.o apps/app_hasnewvoicemail.so">
</member>
<member name="app_ices" displayname="Encode and Stream via icecast and ices" remove_on_change="apps/app_ices.o apps/app_ices.so">
</member>
<member name="app_image" displayname="Image Transmission Application" remove_on_change="apps/app_image.o apps/app_image.so">
</member>
<member name="app_ivrdemo" displayname="IVR Demo Application" remove_on_change="apps/app_ivrdemo.o apps/app_ivrdemo.so">
<defaultenabled>no</defaultenabled>
</member>
<member name="app_lookupblacklist" displayname="Look up Caller*ID name/number from blacklist database" remove_on_change="apps/app_lookupblacklist.o apps/app_lookupblacklist.so">
</member>
<member name="app_lookupcidname" displayname="Look up CallerID Name from local database" remove_on_change="apps/app_lookupcidname.o apps/app_lookupcidname.so">
</member>
<member name="app_macro" displayname="Extension Macros" remove_on_change="apps/app_macro.o apps/app_macro.so">
</member>
<member name="app_meetme" displayname="MeetMe conference bridge" remove_on_change="apps/app_meetme.o apps/app_meetme.so">
<depend>zaptel</depend>
</member>
<member name="app_milliwatt" displayname="Digital Milliwatt (mu-law) Test Application" remove_on_change="apps/app_milliwatt.o apps/app_milliwatt.so">
</member>
<member name="app_mixmonitor" displayname="Mixed Audio Monitoring Application" remove_on_change="apps/app_mixmonitor.o apps/app_mixmonitor.so">
</member>
<member name="app_morsecode" displayname="Morse code" remove_on_change="apps/app_morsecode.o apps/app_morsecode.so">
</member>
<member name="app_mp3" displayname="Silly MP3 Application" remove_on_change="apps/app_mp3.o apps/app_mp3.so">
</member>
<member name="app_nbscat" displayname="Silly NBS Stream Application" remove_on_change="apps/app_nbscat.o apps/app_nbscat.so">
</member>
<member name="app_osplookup" displayname="Open Settlement Protocol Applications" remove_on_change="apps/app_osplookup.o apps/app_osplookup.so">
<depend>libosptk</depend>
<depend>ssl</depend>
</member>
<member name="app_page" displayname="Page Multiple Phones" remove_on_change="apps/app_page.o apps/app_page.so">
<depend>zaptel</depend>
</member>
<member name="app_parkandannounce" displayname="Call Parking and Announce Application" remove_on_change="apps/app_parkandannounce.o apps/app_parkandannounce.so">
</member>
<member name="app_playback" displayname="Sound File Playback Application" remove_on_change="apps/app_playback.o apps/app_playback.so">
</member>
<member name="app_privacy" displayname="Require phone number to be entered, if no CallerID sent" remove_on_change="apps/app_privacy.o apps/app_privacy.so">
</member>
<member name="app_queue" displayname="True Call Queueing" remove_on_change="apps/app_queue.o apps/app_queue.so">
</member>
<member name="app_random" displayname="Random goto" remove_on_change="apps/app_random.o apps/app_random.so">
</member>
<member name="app_read" displayname="Read Variable Application" remove_on_change="apps/app_read.o apps/app_read.so">
</member>
<member name="app_readfile" displayname="Stores output of file into a variable" remove_on_change="apps/app_readfile.o apps/app_readfile.so">
</member>
<member name="app_realtime" displayname="Realtime Data Lookup/Rewrite" remove_on_change="apps/app_realtime.o apps/app_realtime.so">
</member>
<member name="app_record" displayname="Trivial Record Application" remove_on_change="apps/app_record.o apps/app_record.so">
</member>
<member name="app_rpt" displayname="Radio Repeater / Remote Base version 0.48 06/13/2006" remove_on_change="apps/app_rpt.o apps/app_rpt.so">
<depend>zaptel</depend>
<defaultenabled>no</defaultenabled>
</member>
<member name="app_sayunixtime" displayname="Say time" remove_on_change="apps/app_sayunixtime.o apps/app_sayunixtime.so">
</member>
<member name="app_senddtmf" displayname="Send DTMF digits Application" remove_on_change="apps/app_senddtmf.o apps/app_senddtmf.so">
</member>
<member name="app_sendtext" displayname="Send Text Applications" remove_on_change="apps/app_sendtext.o apps/app_sendtext.so">
</member>
<member name="app_setcallerid" displayname="Set CallerID Application" remove_on_change="apps/app_setcallerid.o apps/app_setcallerid.so">
</member>
<member name="app_setcdruserfield" displayname="CDR user field apps" remove_on_change="apps/app_setcdruserfield.o apps/app_setcdruserfield.so">
</member>
<member name="app_settransfercapability" displayname="Set ISDN Transfer Capability" remove_on_change="apps/app_settransfercapability.o apps/app_settransfercapability.so">
</member>
<member name="app_skel" displayname="Trivial skeleton Application" remove_on_change="apps/app_skel.o apps/app_skel.so">
<defaultenabled>no</defaultenabled>
</member>
<member name="app_sms" displayname="SMS/PSTN handler" remove_on_change="apps/app_sms.o apps/app_sms.so">
</member>
<member name="app_softhangup" displayname="Hangs up the requested channel" remove_on_change="apps/app_softhangup.o apps/app_softhangup.so">
</member>
<member name="app_speech_utils" displayname="Dialplan Speech Applications" remove_on_change="apps/app_speech_utils.o apps/app_speech_utils.so">
</member>
<member name="app_stack" displayname="Stack Routines" remove_on_change="apps/app_stack.o apps/app_stack.so">
</member>
<member name="app_system" displayname="Generic System() application" remove_on_change="apps/app_system.o apps/app_system.so">
</member>
<member name="app_talkdetect" displayname="Playback with Talk Detection" remove_on_change="apps/app_talkdetect.o apps/app_talkdetect.so">
</member>
<member name="app_test" displayname="Interface Test Application" remove_on_change="apps/app_test.o apps/app_test.so">
</member>
<member name="app_transfer" displayname="Transfer" remove_on_change="apps/app_transfer.o apps/app_transfer.so">
</member>
<member name="app_url" displayname="Send URL Applications" remove_on_change="apps/app_url.o apps/app_url.so">
</member>
<member name="app_userevent" displayname="Custom User Event Application" remove_on_change="apps/app_userevent.o apps/app_userevent.so">
</member>
<member name="app_verbose" displayname="Send verbose output" remove_on_change="apps/app_verbose.o apps/app_verbose.so">
</member>
<member name="app_voicemail" displayname="Comedian Mail (Voicemail System)" remove_on_change="apps/app_voicemail.o apps/app_voicemail.so">
</member>
<member name="app_waitforring" displayname="Waits until first ring after time" remove_on_change="apps/app_waitforring.o apps/app_waitforring.so">
</member>
<member name="app_waitforsilence" displayname="Wait For Silence" remove_on_change="apps/app_waitforsilence.o apps/app_waitforsilence.so">
</member>
<member name="app_while" displayname="While Loops and Conditional Execution" remove_on_change="apps/app_while.o apps/app_while.so">
</member>
<member name="app_zapateller" displayname="Block Telemarketers with Special Information Tone" remove_on_change="apps/app_zapateller.o apps/app_zapateller.so">
</member>
<member name="app_zapbarge" displayname="Barge in on Zap channel application" remove_on_change="apps/app_zapbarge.o apps/app_zapbarge.so">
<depend>zaptel</depend>
</member>
<member name="app_zapras" displayname="Zap RAS Application" remove_on_change="apps/app_zapras.o apps/app_zapras.so">
<depend>zaptel</depend>
</member>
<member name="app_zapscan" displayname="Scan Zap channels application" remove_on_change="apps/app_zapscan.o apps/app_zapscan.so">
<depend>zaptel</depend>
</member>
</category>
<category name="MENUSELECT_CDR" displayname="Call Detail Recording">
<member name="cdr_csv" displayname="Comma Separated Values CDR Backend" remove_on_change="cdr/cdr_csv.o cdr/cdr_csv.so">
</member>
<member name="cdr_custom" displayname="Customizable Comma Separated Values CDR Backend" remove_on_change="cdr/cdr_custom.o cdr/cdr_custom.so">
</member>
<member name="cdr_manager" displayname="Asterisk Call Manager CDR Backend" remove_on_change="cdr/cdr_manager.o cdr/cdr_manager.so">
</member>
<member name="cdr_odbc" displayname="ODBC CDR Backend" remove_on_change="cdr/cdr_odbc.o cdr/cdr_odbc.so">
<depend>unixodbc</depend>
</member>
<member name="cdr_pgsql" displayname="PostgreSQL CDR Backend" remove_on_change="cdr/cdr_pgsql.o cdr/cdr_pgsql.so">
<depend>pgsql</depend>
</member>
<member name="cdr_radius" displayname="RADIUS CDR Backend" remove_on_change="cdr/cdr_radius.o cdr/cdr_radius.so">
<depend>radiusclient</depend>
</member>
<member name="cdr_sqlite" displayname="SQLite CDR Backend" remove_on_change="cdr/cdr_sqlite.o cdr/cdr_sqlite.so">
<depend>sqlite</depend>
</member>
<member name="cdr_tds" displayname="MSSQL CDR Backend" remove_on_change="cdr/cdr_tds.o cdr/cdr_tds.so">
<depend>freetds</depend>
</member>
</category>
<category name="MENUSELECT_CHANNELS" displayname="Channel Drivers">
<member name="chan_agent" displayname="Agent Proxy Channel" remove_on_change="channels/chan_agent.o channels/chan_agent.so">
</member>
<member name="chan_alsa" displayname="ALSA Console Channel Driver" remove_on_change="channels/chan_alsa.o channels/chan_alsa.so">
<depend>asound</depend>
</member>
<member name="chan_features" displayname="Feature Proxy Channel" remove_on_change="channels/chan_features.o channels/chan_features.so">
</member>
<member name="chan_h323" displayname="The NuFone Network's Open H.323 Channel Driver" remove_on_change="channels/chan_h323.o channels/chan_h323.so">
<depend>h323</depend>
</member>
<member name="chan_iax2" displayname="Inter Asterisk eXchange (Ver 2)" remove_on_change="channels/chan_iax2.o channels/chan_iax2.so">
</member>
<member name="chan_jingle" displayname="Jingle Channel Driver" remove_on_change="channels/chan_jingle.o channels/chan_jingle.so">
<depend>iksemel</depend>
</member>
<member name="chan_local" displayname="Local Proxy Channel" remove_on_change="channels/chan_local.o channels/chan_local.so">
</member>
<member name="chan_mgcp" displayname="Media Gateway Control Protocol (MGCP)" remove_on_change="channels/chan_mgcp.o channels/chan_mgcp.so">
</member>
<member name="chan_misdn" displayname="Channel driver for mISDN Support (Bri/Pri)" remove_on_change="channels/chan_misdn.o channels/chan_misdn.so">
</member>
<member name="chan_nbs" displayname="Network Broadcast Sound Driver" remove_on_change="channels/chan_nbs.o channels/chan_nbs.so">
<depend>nbs</depend>
</member>
<member name="chan_oss" displayname="OSS Console Channel Driver" remove_on_change="channels/chan_oss.o channels/chan_oss.so">
<depend>ossaudio</depend>
</member>
<member name="chan_phone" displayname="Standard Linux Telephony API Driver" remove_on_change="channels/chan_phone.o channels/chan_phone.so">
<depend>ixjuser</depend>
</member>
<member name="chan_sip" displayname="Session Initiation Protocol (SIP)" remove_on_change="channels/chan_sip.o channels/chan_sip.so">
</member>
<member name="chan_skinny" displayname="Skinny Client Control Protocol (Skinny)" remove_on_change="channels/chan_skinny.o channels/chan_skinny.so">
</member>
<member name="chan_vpb" displayname="Standard VoiceTronix API Driver" remove_on_change="channels/chan_vpb.o channels/chan_vpb.so">
<depend>vpbapi</depend>
</member>
<member name="chan_zap" displayname="Zapata Telephony" remove_on_change="channels/chan_zap.o channels/chan_zap.so">
<depend>zaptel</depend>
</member>
</category>
<category name="MENUSELECT_CODECS" displayname="Codec Translators">
<member name="codec_a_mu" displayname="A-law and Mulaw direct Coder/Decoder" remove_on_change="codecs/codec_a_mu.o codecs/codec_a_mu.so">
</member>
<member name="codec_adpcm" displayname="Adaptive Differential PCM Coder/Decoder" remove_on_change="codecs/codec_adpcm.o codecs/codec_adpcm.so">
</member>
<member name="codec_alaw" displayname="A-law Coder/Decoder" remove_on_change="codecs/codec_alaw.o codecs/codec_alaw.so">
</member>
<member name="codec_g723_1" displayname="" remove_on_change="codecs/codec_g723_1.o codecs/codec_g723_1.so">
<defaultenabled>no</defaultenabled>
</member>
<member name="codec_g726" displayname="ITU G.726-32kbps G726 Transcoder" remove_on_change="codecs/codec_g726.o codecs/codec_g726.so">
</member>
<member name="codec_gsm" displayname="GSM/PCM16 (signed linear) Codec Translator" remove_on_change="codecs/codec_gsm.o codecs/codec_gsm.so">
<depend>libgsm</depend>
</member>
<member name="codec_ilbc" displayname="iLBC/PCM16 (signed linear) Codec Translator" remove_on_change="codecs/codec_ilbc.o codecs/codec_ilbc.so">
</member>
<member name="codec_lpc10" displayname="LPC10 2.4kbps (signed linear) Voice Coder" remove_on_change="codecs/codec_lpc10.o codecs/codec_lpc10.so">
</member>
<member name="codec_speex" displayname="Speex/PCM16 (signed linear) Codec Translator" remove_on_change="codecs/codec_speex.o codecs/codec_speex.so">
<depend>libspeex</depend>
</member>
<member name="codec_ulaw" displayname="Mu-law Coder/Decoder" remove_on_change="codecs/codec_ulaw.o codecs/codec_ulaw.so">
</member>
<member name="codec_zap" displayname="Generic Zaptel Transcoder Codec Translator" remove_on_change="codecs/codec_zap.o codecs/codec_zap.so">
<depend>zaptel</depend>
</member>
</category>
<category name="MENUSELECT_FORMATS" displayname="Format Interpreters">
<member name="format_g723" displayname="G.723.1 Simple Timestamp File Format" remove_on_change="formats/format_g723.o formats/format_g723.so">
</member>
<member name="format_g726" displayname="Raw G.726 (16/24/32/40kbps) data" remove_on_change="formats/format_g726.o formats/format_g726.so">
</member>
<member name="format_g729" displayname="Raw G729 data" remove_on_change="formats/format_g729.o formats/format_g729.so">
</member>
<member name="format_gsm" displayname="Raw GSM data" remove_on_change="formats/format_gsm.o formats/format_gsm.so">
</member>
<member name="format_h263" displayname="Raw h263 data" remove_on_change="formats/format_h263.o formats/format_h263.so">
</member>
<member name="format_h264" displayname="Raw h264 data" remove_on_change="formats/format_h264.o formats/format_h264.so">
</member>
<member name="format_ilbc" displayname="Raw iLBC data" remove_on_change="formats/format_ilbc.o formats/format_ilbc.so">
</member>
<member name="format_jpeg" displayname="JPEG (Joint Picture Experts Group) Image Format" remove_on_change="formats/format_jpeg.o formats/format_jpeg.so">
</member>
<member name="format_ogg_vorbis" displayname="OGG/Vorbis audio" remove_on_change="formats/format_ogg_vorbis.o formats/format_ogg_vorbis.so">
<depend>libvorbis</depend>
<depend>ogg</depend>
</member>
<member name="format_pcm" displayname="Raw/Sun uLaw/ALaw 8khz Audio support (PCM,PCMA,AU)" remove_on_change="formats/format_pcm.o formats/format_pcm.so">
</member>
<member name="format_sln" displayname="Raw Signed Linear Audio support (SLN)" remove_on_change="formats/format_sln.o formats/format_sln.so">
</member>
<member name="format_vox" displayname="Dialogic VOX (ADPCM) File Format" remove_on_change="formats/format_vox.o formats/format_vox.so">
</member>
<member name="format_wav" displayname="Microsoft WAV format (8000hz Signed Linear)" remove_on_change="formats/format_wav.o formats/format_wav.so">
</member>
<member name="format_wav_gsm" displayname="Microsoft WAV format (Proprietary GSM)" remove_on_change="formats/format_wav_gsm.o formats/format_wav_gsm.so">
</member>
</category>
<category name="MENUSELECT_FUNCS" displayname="Dialplan Functions">
<member name="func_base64" displayname="base64 encode/decode dialplan functions" remove_on_change="funcs/func_base64.o funcs/func_base64.so">
</member>
<member name="func_callerid" displayname="Caller ID related dialplan function" remove_on_change="funcs/func_callerid.o funcs/func_callerid.so">
</member>
<member name="func_cdr" displayname="CDR dialplan function" remove_on_change="funcs/func_cdr.o funcs/func_cdr.so">
</member>
<member name="func_channel" displayname="Channel information dialplan function" remove_on_change="funcs/func_channel.o funcs/func_channel.so">
</member>
<member name="func_curl" displayname="Load external URL" remove_on_change="funcs/func_curl.o funcs/func_curl.so">
<depend>curl</depend>
</member>
<member name="func_cut" displayname="Cut out information from a string" remove_on_change="funcs/func_cut.o funcs/func_cut.so">
</member>
<member name="func_db" displayname="Database (astdb) related dialplan functions" remove_on_change="funcs/func_db.o funcs/func_db.so">
</member>
<member name="func_enum" displayname="ENUM related dialplan functions" remove_on_change="funcs/func_enum.o funcs/func_enum.so">
</member>
<member name="func_env" displayname="Environment/filesystem dialplan functions" remove_on_change="funcs/func_env.o funcs/func_env.so">
</member>
<member name="func_global" displayname="Global variable dialplan functions" remove_on_change="funcs/func_global.o funcs/func_global.so">
</member>
<member name="func_groupcount" displayname="Channel group dialplan functions" remove_on_change="funcs/func_groupcount.o funcs/func_groupcount.so">
</member>
<member name="func_language" displayname="Channel language dialplan function" remove_on_change="funcs/func_language.o funcs/func_language.so">
</member>
<member name="func_logic" displayname="Logical dialplan functions" remove_on_change="funcs/func_logic.o funcs/func_logic.so">
</member>
<member name="func_math" displayname="Mathematical dialplan function" remove_on_change="funcs/func_math.o funcs/func_math.so">
</member>
<member name="func_md5" displayname="MD5 digest dialplan functions" remove_on_change="funcs/func_md5.o funcs/func_md5.so">
</member>
<member name="func_moh" displayname="Music-on-hold dialplan function" remove_on_change="funcs/func_moh.o funcs/func_moh.so">
</member>
<member name="func_odbc" displayname="ODBC lookups" remove_on_change="funcs/func_odbc.o funcs/func_odbc.so">
<depend>unixodbc</depend>
</member>
<member name="func_rand" displayname="Random number dialplan function" remove_on_change="funcs/func_rand.o funcs/func_rand.so">
</member>
<member name="func_realtime" displayname="Read/Write values from a RealTime repository" remove_on_change="funcs/func_realtime.o funcs/func_realtime.so">
</member>
<member name="func_sha1" displayname="SHA-1 computation dialplan function" remove_on_change="funcs/func_sha1.o funcs/func_sha1.so">
</member>
<member name="func_strings" displayname="String handling dialplan functions" remove_on_change="funcs/func_strings.o funcs/func_strings.so">
</member>
<member name="func_timeout" displayname="Channel timeout dialplan functions" remove_on_change="funcs/func_timeout.o funcs/func_timeout.so">
</member>
<member name="func_uri" displayname="URI encode/decode dialplan functions" remove_on_change="funcs/func_uri.o funcs/func_uri.so">
</member>
</category>
<category name="MENUSELECT_PBX" displayname="PBX Modules">
<member name="pbx_ael" displayname="Asterisk Extension Language Compiler v2" remove_on_change="pbx/pbx_ael.o pbx/pbx_ael.so">
</member>
<member name="pbx_config" displayname="Text Extension Configuration" remove_on_change="pbx/pbx_config.o pbx/pbx_config.so">
</member>
<member name="pbx_dundi" displayname="Distributed Universal Number Discovery (DUNDi)" remove_on_change="pbx/pbx_dundi.o pbx/pbx_dundi.so">
<depend>zlib</depend>
</member>
<member name="pbx_gtkconsole" displayname="Asterisk PBX Console (GTK Version)" remove_on_change="pbx/pbx_gtkconsole.o pbx/pbx_gtkconsole.so">
<depend>gtk</depend>
<defaultenabled>no</defaultenabled>
</member>
<member name="pbx_loopback" displayname="Loopback Switch" remove_on_change="pbx/pbx_loopback.o pbx/pbx_loopback.so">
</member>
<member name="pbx_realtime" displayname="Realtime Switch" remove_on_change="pbx/pbx_realtime.o pbx/pbx_realtime.so">
</member>
<member name="pbx_spool" displayname="Outgoing Spool Support" remove_on_change="pbx/pbx_spool.o pbx/pbx_spool.so">
</member>
</category>
<category name="MENUSELECT_RES" displayname="Resource Modules">
<member name="res_adsi" displayname="ADSI Resource" remove_on_change="res/res_adsi.o res/res_adsi.so">
</member>
<member name="res_agi" displayname="Asterisk Gateway Interface (AGI)" remove_on_change="res/res_agi.o res/res_agi.so">
</member>
<member name="res_clioriginate" displayname="Call origination from the CLI" remove_on_change="res/res_clioriginate.o res/res_clioriginate.so">
</member>
<member name="res_config_odbc" displayname="ODBC Configuration" remove_on_change="res/res_config_odbc.o res/res_config_odbc.so">
<depend>unixodbc</depend>
</member>
<member name="res_config_pgsql" displayname="Postgresql RealTime Configuration Driver" remove_on_change="res/res_config_pgsql.o res/res_config_pgsql.so">
<depend>pgsql</depend>
</member>
<member name="res_convert" displayname="File format conversion CLI command" remove_on_change="res/res_convert.o res/res_convert.so">
</member>
<member name="res_crypto" displayname="Cryptographic Digital Signatures" remove_on_change="res/res_crypto.o res/res_crypto.so">
<depend>ssl</depend>
</member>
<member name="res_features" displayname="Call Features Resource" remove_on_change="res/res_features.o res/res_features.so">
</member>
<member name="res_indications" displayname="Indications Configuration" remove_on_change="res/res_indications.o res/res_indications.so">
</member>
<member name="res_jabber" displayname="AJI - Asterisk JABBER Interface" remove_on_change="res/res_jabber.o res/res_jabber.so">
<depend>iksemel</depend>
</member>
<member name="res_monitor" displayname="Call Monitoring Resource" remove_on_change="res/res_monitor.o res/res_monitor.so">
</member>
<member name="res_musiconhold" displayname="Music On Hold Resource" remove_on_change="res/res_musiconhold.o res/res_musiconhold.so">
<conflict>win32</conflict>
</member>
<member name="res_odbc" displayname="ODBC Resource" remove_on_change="res/res_odbc.o res/res_odbc.so">
<depend>unixodbc</depend>
</member>
<member name="res_osp" displayname="Open Settlement Protocol Support" remove_on_change="res/res_osp.o res/res_osp.so">
<depend>libosptk</depend>
<depend>ssl</depend>
</member>
<member name="res_smdi" displayname="Asterisk Simplified Message Desk Interface (SMDI) Module" remove_on_change="res/res_smdi.o res/res_smdi.so">
</member>
<member name="res_snmp" displayname="SNMP [Sub]Agent for Asterisk" remove_on_change="res/res_snmp.o res/res_snmp.so">
<depend>netsnmp</depend>
<defaultenabled>no</defaultenabled>
</member>
<member name="res_speech" displayname="Generic Speech Recognition API" remove_on_change="res/res_speech.o res/res_speech.so">
</member>
</category>
<category name="MENUSELECT_CFLAGS" displayname="Compiler Flags" positive_output="yes" remove_on_change=".lastclean">
<member name="DEBUG_CHANNEL_LOCKS" displayname="Debug Channel Locking">
</member>
<member name="DEBUG_SCHEDULER" displayname="Enable Scheduler Debugging Output">
</member>
<member name="DEBUG_THREADS" displayname="Enable Thread Debugging">
</member>
<member name="DETECT_DEADLOCKS" displayname="Detect Deadlocks">
</member>
<member name="DONT_OPTIMIZE" displayname="Disable Optimizations from the Compiler">
</member>
<member name="DUMP_SCHEDULER" displayname="Dump Scheduler Contents for Debugging">
</member>
<member name="LOW_MEMORY" displayname="Optimize for Low Memory Usage">
</member>
<member name="MALLOC_DEBUG" displayname="Keep Track of Memory Allocations">
</member>
<member name="MTX_PROFILE" displayname="Enable Code Profiling Using TSC Counters">
</member>
<member name="RADIO_RELAX" displayname="Relax DTMF for Radio Applications">
</member>
<member name="TRACE_FRAMES" displayname="Trace Frame Allocations">
</member>
</category>
<category name="MENUSELECT_CORE_SOUNDS" displayname="Core Sound Packages" positive_output="yes">
<member name="CORE-SOUNDS-EN-WAV" displayname="English, WAV format">
</member>
<member name="CORE-SOUNDS-EN-ULAW" displayname="English, mu-Law format">
</member>
<member name="CORE-SOUNDS-EN-ALAW" displayname="English, a-Law format">
</member>
<member name="CORE-SOUNDS-EN-GSM" displayname="English, GSM format" >
<defaultenabled>yes</defaultenabled>
</member>
<member name="CORE-SOUNDS-EN-G729" displayname="English, G.729 format">
</member>
<member name="CORE-SOUNDS-ES-WAV" displayname="Spanish, WAV format">
</member>
<member name="CORE-SOUNDS-ES-ULAW" displayname="Spanish, mu-Law format">
</member>
<member name="CORE-SOUNDS-ES-ALAW" displayname="Spanish, a-Law format">
</member>
<member name="CORE-SOUNDS-ES-GSM" displayname="Spanish, GSM format">
</member>
<member name="CORE-SOUNDS-ES-G729" displayname="Spanish, G.729 format">
</member>
<member name="CORE-SOUNDS-FR-WAV" displayname="French, WAV format">
</member>
<member name="CORE-SOUNDS-FR-ULAW" displayname="French, mu-Law format">
</member>
<member name="CORE-SOUNDS-FR-ALAW" displayname="French, a-Law format">
</member>
<member name="CORE-SOUNDS-FR-GSM" displayname="French, GSM format">
</member>
<member name="CORE-SOUNDS-FR-G729" displayname="French, G.729 format">
</member>
</category>
<category name="MENUSELECT_EXTRA_SOUNDS" displayname="Extras Sound Packages" positive_output="yes">
<member name="EXTRA-SOUNDS-EN-WAV" displayname="English, WAV format">
</member>
<member name="EXTRA-SOUNDS-EN-ULAW" displayname="English, mu-Law format">
</member>
<member name="EXTRA-SOUNDS-EN-ALAW" displayname="English, a-Law format">
</member>
<member name="EXTRA-SOUNDS-EN-GSM" displayname="English, GSM format" >
</member>
<member name="EXTRA-SOUNDS-EN-G729" displayname="English, G.729 format">
</member>
</category>
<category name="MENUSELECT_app_voicemail" displayname="Voicemail Build Options" positive_output="yes" remove_on_change="apps/app_voicemail.o">
<member name="ODBC_STORAGE" displayname="Storage of Voicemail using ODBC">
<depend>unixodbc</depend>
<defaultenabled>no</defaultenabled>
</member>
<member name="EXTENDED_ODBC_STORAGE" displayname="Storage of Voicemail using ODBC (extended)">
<depend>unixodbc</depend>
<defaultenabled>no</defaultenabled>
</member>
</category>
</menu>

View File

@ -1,323 +0,0 @@
#!/bin/sh
# install - install a program, script, or datafile
scriptversion=2005-05-14.22
# This originates from X11R5 (mit/util/scripts/install.sh), which was
# later released in X11R6 (xc/config/util/install.sh) with the
# following copyright and license.
#
# Copyright (C) 1994 X Consortium
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Except as contained in this notice, the name of the X Consortium shall not
# be used in advertising or otherwise to promote the sale, use or other deal-
# ings in this Software without prior written authorization from the X Consor-
# tium.
#
#
# FSF changes to this file are in the public domain.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# `make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch. It can only install one file at a time, a restriction
# shared with many OS's install programs.
# set DOITPROG to echo to test this script
# Don't use :- since 4.3BSD and earlier shells don't like it.
doit="${DOITPROG-}"
# put in absolute paths if you don't have them in your path; or use env. vars.
mvprog="${MVPROG-mv}"
cpprog="${CPPROG-cp}"
chmodprog="${CHMODPROG-chmod}"
chownprog="${CHOWNPROG-chown}"
chgrpprog="${CHGRPPROG-chgrp}"
stripprog="${STRIPPROG-strip}"
rmprog="${RMPROG-rm}"
mkdirprog="${MKDIRPROG-mkdir}"
chmodcmd="$chmodprog 0755"
chowncmd=
chgrpcmd=
stripcmd=
rmcmd="$rmprog -f"
mvcmd="$mvprog"
src=
dst=
dir_arg=
dstarg=
no_target_directory=
usage="Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
or: $0 [OPTION]... SRCFILES... DIRECTORY
or: $0 [OPTION]... -t DIRECTORY SRCFILES...
or: $0 [OPTION]... -d DIRECTORIES...
In the 1st form, copy SRCFILE to DSTFILE.
In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
In the 4th, create DIRECTORIES.
Options:
-c (ignored)
-d create directories instead of installing files.
-g GROUP $chgrpprog installed files to GROUP.
-m MODE $chmodprog installed files to MODE.
-o USER $chownprog installed files to USER.
-s $stripprog installed files.
-t DIRECTORY install into DIRECTORY.
-T report an error if DSTFILE is a directory.
--help display this help and exit.
--version display version info and exit.
Environment variables override the default commands:
CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG
"
while test -n "$1"; do
case $1 in
-c) shift
continue;;
-d) dir_arg=true
shift
continue;;
-g) chgrpcmd="$chgrpprog $2"
shift
shift
continue;;
--help) echo "$usage"; exit $?;;
-m) chmodcmd="$chmodprog $2"
shift
shift
continue;;
-o) chowncmd="$chownprog $2"
shift
shift
continue;;
-s) stripcmd=$stripprog
shift
continue;;
-t) dstarg=$2
shift
shift
continue;;
-T) no_target_directory=true
shift
continue;;
--version) echo "$0 $scriptversion"; exit $?;;
*) # When -d is used, all remaining arguments are directories to create.
# When -t is used, the destination is already specified.
test -n "$dir_arg$dstarg" && break
# Otherwise, the last argument is the destination. Remove it from $@.
for arg
do
if test -n "$dstarg"; then
# $@ is not empty: it contains at least $arg.
set fnord "$@" "$dstarg"
shift # fnord
fi
shift # arg
dstarg=$arg
done
break;;
esac
done
if test -z "$1"; then
if test -z "$dir_arg"; then
echo "$0: no input file specified." >&2
exit 1
fi
# It's OK to call `install-sh -d' without argument.
# This can happen when creating conditional directories.
exit 0
fi
for src
do
# Protect names starting with `-'.
case $src in
-*) src=./$src ;;
esac
if test -n "$dir_arg"; then
dst=$src
src=
if test -d "$dst"; then
mkdircmd=:
chmodcmd=
else
mkdircmd=$mkdirprog
fi
else
# Waiting for this to be detected by the "$cpprog $src $dsttmp" command
# might cause directories to be created, which would be especially bad
# if $src (and thus $dsttmp) contains '*'.
if test ! -f "$src" && test ! -d "$src"; then
echo "$0: $src does not exist." >&2
exit 1
fi
if test -z "$dstarg"; then
echo "$0: no destination specified." >&2
exit 1
fi
dst=$dstarg
# Protect names starting with `-'.
case $dst in
-*) dst=./$dst ;;
esac
# If destination is a directory, append the input filename; won't work
# if double slashes aren't ignored.
if test -d "$dst"; then
if test -n "$no_target_directory"; then
echo "$0: $dstarg: Is a directory" >&2
exit 1
fi
dst=$dst/`basename "$src"`
fi
fi
# This sed command emulates the dirname command.
dstdir=`echo "$dst" | sed -e 's,/*$,,;s,[^/]*$,,;s,/*$,,;s,^$,.,'`
# Make sure that the destination directory exists.
# Skip lots of stat calls in the usual case.
if test ! -d "$dstdir"; then
defaultIFS='
'
IFS="${IFS-$defaultIFS}"
oIFS=$IFS
# Some sh's can't handle IFS=/ for some reason.
IFS='%'
set x `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'`
shift
IFS=$oIFS
pathcomp=
while test $# -ne 0 ; do
pathcomp=$pathcomp$1
shift
if test ! -d "$pathcomp"; then
$mkdirprog "$pathcomp"
# mkdir can fail with a `File exist' error in case several
# install-sh are creating the directory concurrently. This
# is OK.
test -d "$pathcomp" || exit
fi
pathcomp=$pathcomp/
done
fi
if test -n "$dir_arg"; then
$doit $mkdircmd "$dst" \
&& { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \
&& { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \
&& { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \
&& { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; }
else
dstfile=`basename "$dst"`
# Make a couple of temp file names in the proper directory.
dsttmp=$dstdir/_inst.$$_
rmtmp=$dstdir/_rm.$$_
# Trap to clean up those temp files at exit.
trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
trap '(exit $?); exit' 1 2 13 15
# Copy the file name to the temp name.
$doit $cpprog "$src" "$dsttmp" &&
# and set any options; do chmod last to preserve setuid bits.
#
# If any of these fail, we abort the whole thing. If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $cpprog $src $dsttmp" command.
#
{ test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \
&& { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \
&& { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \
&& { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } &&
# Now rename the file to the real destination.
{ $doit $mvcmd -f "$dsttmp" "$dstdir/$dstfile" 2>/dev/null \
|| {
# The rename failed, perhaps because mv can't rename something else
# to itself, or perhaps because mv is so ancient that it does not
# support -f.
# Now remove or move aside any old file at destination location.
# We try this two ways since rm can't unlink itself on some
# systems and the destination file might be busy for other
# reasons. In this case, the final cleanup might fail but the new
# file should still install successfully.
{
if test -f "$dstdir/$dstfile"; then
$doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \
|| $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \
|| {
echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2
(exit 1); exit 1
}
else
:
fi
} &&
# Now rename the file to the real destination.
$doit $mvcmd "$dsttmp" "$dstdir/$dstfile"
}
}
fi || { (exit 1); exit 1; }
done
# The final little trick to "correctly" pass the exit status to the exit trap.
{
(exit 0); exit 0
}
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-end: "$"
# End:

View File

@ -1,372 +0,0 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 1999 - 2006, Digium, Inc.
*
* Mark Spencer <markster@digium.com>
* Kevin P. Fleming <kpfleming@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
#ifndef ASTERISK_LINKEDLISTS_H
#define ASTERISK_LINKEDLISTS_H
/*!
\brief Defines a structure to be used to hold a list of specified type (with no lock).
\param name This will be the name of the defined structure.
\param type This is the type of each list entry.
This macro creates a structure definition that can be used
to hold a list of the entries of type \a type. It does not actually
declare (allocate) a structure; to do that, either follow this
macro with the desired name of the instance you wish to declare,
or use the specified \a name to declare instances elsewhere.
Example usage:
\code
static AST_LIST_HEAD_NOLOCK(entry_list, entry) entries;
\endcode
This would define \c struct \c entry_list, and declare an instance of it named
\a entries, all intended to hold a list of type \c struct \c entry.
*/
#define AST_LIST_HEAD_NOLOCK(name, type) \
struct name { \
struct type *first; \
struct type *last; \
}
/*!
\brief Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK
*/
#define AST_LIST_HEAD_NOLOCK_INIT_VALUE { \
.first = NULL, \
.last = NULL, \
}
/*!
\brief Defines a structure to be used to hold a list of specified type, statically initialized.
This is the same as AST_LIST_HEAD_STATIC, except without the lock included.
*/
#define AST_LIST_HEAD_NOLOCK_STATIC(name, type) \
struct name { \
struct type *first; \
struct type *last; \
} name = AST_LIST_HEAD_NOLOCK_INIT_VALUE
/*!
\brief Initializes a list head structure with a specified first entry.
\param head This is a pointer to the list head structure
\param entry pointer to the list entry that will become the head of the list
This macro initializes a list head structure by setting the head
entry to the supplied value.
*/
#define AST_LIST_HEAD_SET_NOLOCK(head, entry) do { \
(head)->first = (entry); \
(head)->last = (entry); \
} while (0)
/*!
\brief Declare a forward link structure inside a list entry.
\param type This is the type of each list entry.
This macro declares a structure to be used to link list entries together.
It must be used inside the definition of the structure named in
\a type, as follows:
\code
struct list_entry {
...
AST_LIST_ENTRY(list_entry) list;
}
\endcode
The field name \a list here is arbitrary, and can be anything you wish.
*/
#define AST_LIST_ENTRY(type) \
struct { \
struct type *next; \
}
/*!
\brief Returns the first entry contained in a list.
\param head This is a pointer to the list head structure
*/
#define AST_LIST_FIRST(head) ((head)->first)
/*!
\brief Returns the last entry contained in a list.
\param head This is a pointer to the list tail structure
*/
#define AST_LIST_LAST(head) ((head)->last)
/*!
\brief Returns the next entry in the list after the given entry.
\param elm This is a pointer to the current entry.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
*/
#define AST_LIST_NEXT(elm, field) ((elm)->field.next)
/*!
\brief Checks whether the specified list contains any entries.
\param head This is a pointer to the list head structure
Returns non-zero if the list has entries, zero if not.
*/
#define AST_LIST_EMPTY(head) (AST_LIST_FIRST(head) == NULL)
/*!
\brief Loops over (traverses) the entries in a list.
\param head This is a pointer to the list head structure
\param var This is the name of the variable that will hold a pointer to the
current list entry on each iteration. It must be declared before calling
this macro.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
This macro is use to loop over (traverse) the entries in a list. It uses a
\a for loop, and supplies the enclosed code with a pointer to each list
entry as it loops. It is typically used as follows:
\code
static AST_LIST_HEAD(entry_list, list_entry) entries;
...
struct list_entry {
...
AST_LIST_ENTRY(list_entry) list;
}
...
struct list_entry *current;
...
AST_LIST_TRAVERSE(&entries, current, list) {
(do something with current here)
}
\endcode
\warning If you modify the forward-link pointer contained in the \a current entry while
inside the loop, the behavior will be unpredictable. At a minimum, the following
macros will modify the forward-link pointer, and should not be used inside
AST_LIST_TRAVERSE() against the entry pointed to by the \a current pointer without
careful consideration of their consequences:
\li AST_LIST_NEXT() (when used as an lvalue)
\li AST_LIST_INSERT_AFTER()
\li AST_LIST_INSERT_HEAD()
\li AST_LIST_INSERT_TAIL()
*/
#define AST_LIST_TRAVERSE(head,var,field) \
for((var) = (head)->first; (var); (var) = (var)->field.next)
/*!
\brief Loops safely over (traverses) the entries in a list.
\param head This is a pointer to the list head structure
\param var This is the name of the variable that will hold a pointer to the
current list entry on each iteration. It must be declared before calling
this macro.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
This macro is used to safely loop over (traverse) the entries in a list. It
uses a \a for loop, and supplies the enclosed code with a pointer to each list
entry as it loops. It is typically used as follows:
\code
static AST_LIST_HEAD(entry_list, list_entry) entries;
...
struct list_entry {
...
AST_LIST_ENTRY(list_entry) list;
}
...
struct list_entry *current;
...
AST_LIST_TRAVERSE_SAFE_BEGIN(&entries, current, list) {
(do something with current here)
}
AST_LIST_TRAVERSE_SAFE_END;
\endcode
It differs from AST_LIST_TRAVERSE() in that the code inside the loop can modify
(or even free, after calling AST_LIST_REMOVE_CURRENT()) the entry pointed to by
the \a current pointer without affecting the loop traversal.
*/
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field) { \
typeof((head)->first) __list_next; \
typeof((head)->first) __list_prev = NULL; \
typeof((head)->first) __new_prev = NULL; \
for ((var) = (head)->first, __new_prev = (var), \
__list_next = (var) ? (var)->field.next : NULL; \
(var); \
__list_prev = __new_prev, (var) = __list_next, \
__new_prev = (var), \
__list_next = (var) ? (var)->field.next : NULL \
)
/*!
\brief Removes the \a current entry from a list during a traversal.
\param head This is a pointer to the list head structure
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
\note This macro can \b only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN()
block; it is used to unlink the current entry from the list without affecting
the list traversal (and without having to re-traverse the list to modify the
previous entry, if any).
*/
#define AST_LIST_REMOVE_CURRENT(head, field) do { \
__new_prev->field.next = NULL; \
__new_prev = __list_prev; \
if (__list_prev) \
__list_prev->field.next = __list_next; \
else \
(head)->first = __list_next; \
if (!__list_next) \
(head)->last = __list_prev; \
} while (0)
/*!
\brief Inserts a list entry before the current entry during a traversal.
\param head This is a pointer to the list head structure
\param elm This is a pointer to the entry to be inserted.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
\note This macro can \b only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN()
block.
*/
#define AST_LIST_INSERT_BEFORE_CURRENT(head, elm, field) do { \
if (__list_prev) { \
(elm)->field.next = __list_prev->field.next; \
__list_prev->field.next = elm; \
} else { \
(elm)->field.next = (head)->first; \
(head)->first = (elm); \
} \
__new_prev = (elm); \
} while (0)
/*!
\brief Closes a safe loop traversal block.
*/
#define AST_LIST_TRAVERSE_SAFE_END }
/*!
\brief Initializes a list head structure.
\param head This is a pointer to the list head structure
This macro initializes a list head structure by setting the head
entry to \a NULL (empty list). There is no embedded lock handling
with this macro.
*/
#define AST_LIST_HEAD_INIT_NOLOCK(head) { \
(head)->first = NULL; \
(head)->last = NULL; \
}
/*!
\brief Inserts a list entry after a given entry.
\param head This is a pointer to the list head structure
\param listelm This is a pointer to the entry after which the new entry should
be inserted.
\param elm This is a pointer to the entry to be inserted.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
*/
#define AST_LIST_INSERT_AFTER(head, listelm, elm, field) do { \
(elm)->field.next = (listelm)->field.next; \
(listelm)->field.next = (elm); \
if ((head)->last == (listelm)) \
(head)->last = (elm); \
} while (0)
/*!
\brief Inserts a list entry at the head of a list.
\param head This is a pointer to the list head structure
\param elm This is a pointer to the entry to be inserted.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
*/
#define AST_LIST_INSERT_HEAD(head, elm, field) do { \
(elm)->field.next = (head)->first; \
(head)->first = (elm); \
if (!(head)->last) \
(head)->last = (elm); \
} while (0)
/*!
\brief Appends a list entry to the tail of a list.
\param head This is a pointer to the list head structure
\param elm This is a pointer to the entry to be appended.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
Note: The link field in the appended entry is \b not modified, so if it is
actually the head of a list itself, the entire list will be appended
temporarily (until the next AST_LIST_INSERT_TAIL is performed).
*/
#define AST_LIST_INSERT_TAIL(head, elm, field) do { \
if (!(head)->first) { \
(head)->first = (elm); \
(head)->last = (elm); \
} else { \
(head)->last->field.next = (elm); \
(head)->last = (elm); \
} \
} while (0)
/*!
\brief Removes and returns the head entry from a list.
\param head This is a pointer to the list head structure
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
Removes the head entry from the list, and returns a pointer to it.
This macro is safe to call on an empty list.
*/
#define AST_LIST_REMOVE_HEAD(head, field) ({ \
typeof((head)->first) cur = (head)->first; \
if (cur) { \
(head)->first = cur->field.next; \
cur->field.next = NULL; \
if ((head)->last == cur) \
(head)->last = NULL; \
} \
cur; \
})
/*!
\brief Removes a specific entry from a list.
\param head This is a pointer to the list head structure
\param elm This is a pointer to the entry to be removed.
\param field This is the name of the field (declared using AST_LIST_ENTRY())
used to link entries of this list together.
\warning The removed entry is \b not freed nor modified in any way.
*/
#define AST_LIST_REMOVE(head, elm, field) do { \
if ((head)->first == (elm)) { \
(head)->first = (elm)->field.next; \
if ((head)->last == (elm)) \
(head)->last = NULL; \
} else { \
typeof(elm) curelm = (head)->first; \
while (curelm && (curelm->field.next != (elm))) \
curelm = curelm->field.next; \
if (curelm) { \
curelm->field.next = (elm)->field.next; \
if ((head)->last == (elm)) \
(head)->last = curelm; \
} \
} \
(elm)->field.next = NULL; \
} while (0)
#endif /* _ASTERISK_LINKEDLISTS_H */

View File

@ -1,56 +0,0 @@
#!/bin/sh
if [ -f ${1}/.version ]; then
cat ${1}.version
elif [ -f ${1}/.svnrevision ]; then
echo SVN-`cat ${1}/.svnbranch`-r`cat ${1}/.svnrevision`
elif [ -d .svn ]; then
PARTS=`LANG=C svn info ${1} | grep URL | awk '{print $2;}' | sed -e 's:^.*/svn/menuselect/::' | sed -e 's:/: :g'`
BRANCH=0
TEAM=0
REV=`svnversion -c ${1} | cut -d: -f2`
if [ "${PARTS}" = "trunk" ]
then
echo SVN-'trunk'-r${REV}
exit 0
fi
for PART in $PARTS
do
if [ ${BRANCH} != 0 ]
then
RESULT="${RESULT}-${PART}"
break
fi
if [ ${TEAM} != 0 ]
then
RESULT="${RESULT}-${PART}"
continue
fi
if [ "${PART}" = "branches" ]
then
BRANCH=1
RESULT="branch"
continue
fi
if [ "${PART}" = "tags" ]
then
BRANCH=1
RESULT="tag"
continue
fi
if [ "${PART}" = "team" ]
then
TEAM=1
continue
fi
done
echo SVN-${RESULT##-}-r${REV}
fi

View File

@ -1,22 +0,0 @@
# NOTE: Names of _INCLUDE and _LIB entries in this file must be
# the exact uppercase equivalents of the names used for
# dependencies in menuselect for the same package.
CC=@CC@
OSARCH=@HOST_OS@
MENUSELECT_DEBUG=@MENUSELECT_DEBUG@
# The frontend can use curses, ncurses, newt or gtk2
CURSES_INCLUDE=@CURSES_INCLUDE@
CURSES_LIB=@CURSES_LIB@
GTK2_INCLUDE=@GTK2_INCLUDE@
GTK2_LIB=@GTK2_LIB@
NCURSES_INCLUDE=@NCURSES_INCLUDE@
NCURSES_LIB=@NCURSES_LIB@
NEWT_INCLUDE=@NEWT_INCLUDE@
NEWT_LIB=@NEWT_LIB@

File diff suppressed because it is too large Load Diff

View File

@ -1,157 +0,0 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2005-2006, Russell Bryant
*
* Russell Bryant <russell@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*!
* \file
*
* \brief public data structures and defaults for menuselect
*
*/
#ifndef MENUSELECT_H
#define MENUSELECT_H
#include "linkedlists.h"
#define OUTPUT_MAKEOPTS_DEFAULT "menuselect.makeopts"
#define OUTPUT_MAKEDEPS_DEFAULT "menuselect.makedeps"
#define MENUSELECT_DEPS "build_tools/menuselect-deps"
struct member;
struct reference {
/*! the name of the dependency */
const char *name;
/*! the display name of the dependency */
const char *displayname;
/*! if this dependency is a member, not an external object */
struct member *member;
/*! if this package was found */
unsigned char met:1;
/*! for linking */
AST_LIST_ENTRY(reference) list;
};
enum failure_types {
NO_FAILURE = 0,
SOFT_FAILURE = 1,
HARD_FAILURE = 2,
};
struct member {
/*! What will be sent to the makeopts file */
const char *name;
/*! Display name if known */
const char *displayname;
/*! Default setting */
const char *defaultenabled;
/*! Delete these file(s) if this member changes */
const char *remove_on_change;
/*! Touch these file(s) if this member changes */
const char *touch_on_change;
const char *support_level;
const char *replacement;
/*! This module is currently selected */
unsigned int enabled:1;
/*! This module was enabled when the config was loaded */
unsigned int was_enabled:1;
/*! This module has failed dependencies */
unsigned int depsfailed:2;
/*! This module has failed conflicts */
unsigned int conflictsfailed:2;
/*! This module's 'enabled' flag was changed by a default only */
unsigned int was_defaulted:1;
/*! This module is a dependency, and if it is selected then
we have included it in the MENUSELECT_BUILD_DEPS line
in the output file */
unsigned int build_deps_output:1;
/*! This module should never be enabled automatically, but only
* when explicitly set. */
unsigned int explicitly_enabled_only:1;
/*! This isn't actually a module! It's a separator, and it should
* be passed over for many of the usual purposes associated with members. */
unsigned int is_separator:1;
/*! dependencies of this module */
AST_LIST_HEAD_NOLOCK(, reference) deps;
/*! conflicts of this module */
AST_LIST_HEAD_NOLOCK(, reference) conflicts;
/*! optional packages used by this module */
AST_LIST_HEAD_NOLOCK(, reference) uses;
/*! for making a list of modules */
AST_LIST_ENTRY(member) list;
};
enum support_level_values {
SUPPORT_CORE = 0,
SUPPORT_EXTENDED = 1,
SUPPORT_DEPRECATED = 2,
SUPPORT_UNSPECIFIED = 3,
SUPPORT_COUNT = 4, /* Keep this item at the end of the list. Tracks total number of support levels. */
};
struct category {
struct member *separators[SUPPORT_COUNT];
/*! the Makefile variable */
const char *name;
/*! the name displayed in the menu */
const char *displayname;
/*! Delete these file(s) if anything in this category changes */
const char *remove_on_change;
/*! Touch these file(s) if anything in this category changes */
const char *touch_on_change;
/*! Output what is selected, as opposed to not selected */
unsigned int positive_output:1;
/*! All choices in this category are mutually exclusive */
unsigned int exclusive:1;
/*! the list of possible values to be set in this variable */
AST_LIST_HEAD_NOLOCK(, member) members;
/*! for linking */
AST_LIST_ENTRY(category) list;
};
extern AST_LIST_HEAD_NOLOCK(categories, category) categories;
extern const char *menu_name;
/*! This is implemented by the frontend */
int run_menu(void);
int count_categories(void);
int count_members(struct category *cat);
/*! \brief Toggle a member of a category at the specified index to enabled/disabled */
void toggle_enabled_index(struct category *cat, int index);
void toggle_enabled(struct member *mem);
/*! \brief Set a member of a category at the specified index to enabled */
void set_enabled(struct category *cat, int index);
/*! \brief Set a member of a category at the specified index to not enabled */
void clear_enabled(struct category *cat, int index);
/*! \brief Enable/Disable all members of a category as long as dependencies have been met and no conflicts are found */
void set_all(struct category *cat, int val);
/*! \brief returns non-zero if the string is not defined, or has zero length */
static inline int strlen_zero(const char *s)
{
return (!s || (*s == '\0'));
}
#endif /* MENUSELECT_H */

File diff suppressed because it is too large Load Diff

View File

@ -1,358 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gtk/gtk.h>
#include "menuselect.h"
enum {
/*! The row name */
COLUMN_NAME,
/*! Whether this row is enabled */
COLUMN_SELECTED,
/*! Dependencies */
COLUMN_DEPS,
/*! Optional dependencies */
COLUMN_USES,
/*! Conflicts */
COLUMN_CNFS,
/*! Number of columns, must be the last element in the enum */
NUM_COLUMNS,
};
static void handle_save(GtkWidget *w, gpointer data);
static void handle_about(GtkWidget *w, gpointer data);
static void handle_quit(GtkWidget *w, gpointer data);
static GtkItemFactoryEntry menu_items[] = {
{ "/_File", NULL, NULL, 0, "<Branch>" },
{ "/File/_Save And Quit", "<control>S", handle_save, 0, "<StockItem>", GTK_STOCK_SAVE },
{ "/File/sep1", NULL, NULL, 0, "<Separator>" },
{ "/File/_Quit", "<CTRL>Q", handle_quit, 0, "<StockItem>", GTK_STOCK_QUIT },
{ "/_Help", NULL, NULL, 0, "<LastBranch>" },
{ "/_Help/About", NULL, handle_about, 0, "<Item>" },
};
static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
static GtkTreeView *tree;
static GtkWidget *window;
/* 0, save ... non-zero, don't save */
static int main_res = 1;
static int change_made = 0;
static void handle_save(GtkWidget *w, gpointer data)
{
main_res = 0;
gtk_main_quit();
}
static void handle_about(GtkWidget *w, gpointer data)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"GMenuselect - http://www.asterisk.org/\n"
"Russell Bryant <russell@digium.com>\n"
"Copyright (C) 2007\n");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
return FALSE;
}
static void handle_quit(GtkWidget *widget, gpointer data)
{
gtk_main_quit();
}
static void destroy(GtkWidget *widget, gpointer data)
{
GtkWidget *dialog;
gint response;
if (!main_res || !change_made) {
gtk_main_quit();
return;
}
dialog = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, "Save before quit?");
response = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if (response == GTK_RESPONSE_YES)
main_res = 0;
gtk_main_quit();
}
static void toggled_handler(GtkCellRendererToggle *renderer, gchar *path, gpointer data)
{
gchar *cat_num_str, *mem_num_str;
int cat_num, mem_num;
int i = 0;
struct category *cat;
struct member *mem;
GtkTreeStore *store = data;
GtkTreeModel *model;
GtkTreeIter cat_iter, mem_iter;
mem_num_str = alloca(strlen(path)) + 1;
strcpy(mem_num_str, path);
cat_num_str = strsep(&mem_num_str, ":");
if (!mem_num_str || !*mem_num_str)
return;
cat_num = atoi(cat_num_str);
mem_num = atoi(mem_num_str);
AST_LIST_TRAVERSE(&categories, cat, list) {
if (i == cat_num)
break;
i++;
}
if (!cat)
return;
i = 0;
AST_LIST_TRAVERSE(&cat->members, mem, list) {
if (i == mem_num)
break;
i++;
}
if (!mem)
return;
toggle_enabled(mem);
model = gtk_tree_view_get_model(tree);
gtk_tree_model_get_iter_first(model, &cat_iter);
for (i = 0; i < cat_num; i++) {
if (!gtk_tree_model_iter_next(model, &cat_iter))
break;
}
if (i != cat_num)
return;
if (!gtk_tree_model_iter_children(model, &mem_iter, &cat_iter))
return;
for (i = 0; i < mem_num; i++) {
if (!gtk_tree_model_iter_next(model, &mem_iter))
break;
}
if (i != mem_num)
return;
gtk_tree_store_set(store, &mem_iter, COLUMN_SELECTED, mem->enabled, -1);
change_made = 1;
}
static void row_activated_handler(GtkTreeView *treeview, GtkTreePath *path,
GtkTreeViewColumn *col, gpointer data)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeStore *store = data;
gchar *name;
struct category *cat;
struct member *mem;
model = gtk_tree_view_get_model(treeview);
if (!gtk_tree_model_get_iter(model, &iter, path))
return;
gtk_tree_model_get(model, &iter, COLUMN_NAME, &name, -1);
AST_LIST_TRAVERSE(&categories, cat, list) {
AST_LIST_TRAVERSE(&cat->members, mem, list) {
if (strcmp(name, mem->name))
continue;
toggle_enabled(mem);
gtk_tree_store_set(store, &iter, COLUMN_SELECTED, mem->enabled, -1);
change_made = 1;
break;
}
if (mem)
break;
}
g_free(name);
}
static GtkWidget *get_menubar_menu(GtkWidget *window)
{
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
/* Make an accelerator group (shortcut keys) */
accel_group = gtk_accel_group_new();
/* Make an ItemFactory (that makes a menubar) */
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>",
accel_group);
/* This function generates the menu items. Pass the item factory,
the number of items in the array, the array itself, and any
callback data for the the menu items. */
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
/* Attach the new accelerator group to the window. */
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
/* Finally, return the actual menu bar created by the item factory. */
return gtk_item_factory_get_widget(item_factory, "<main>");
}
int run_menu(void)
{
int argc = 0;
char **argv = NULL;
GtkWidget *s_window;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeStore *store;
struct category *cat;
struct member *mem;
GtkWidget *main_vbox;
GtkWidget *menubar;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, 640, 480);
gtk_window_set_title(GTK_WINDOW(window), "GMenuselect");
main_vbox = gtk_vbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 1);
gtk_container_add(GTK_CONTAINER(window), main_vbox);
menubar = get_menubar_menu(window);
gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
s_window = gtk_scrolled_window_new(NULL, NULL);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_event), NULL);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(destroy), NULL);
store = gtk_tree_store_new(NUM_COLUMNS,
G_TYPE_STRING, /* COLUMN_NAME */
G_TYPE_BOOLEAN, /* COLUMN_SELECTED */
G_TYPE_STRING, /* COLUMN_DEPS */
G_TYPE_STRING, /* COLUMN_USES */
G_TYPE_STRING); /* COLUMN_CNFS */
AST_LIST_TRAVERSE(&categories, cat, list) {
GtkTreeIter iter, iter2;
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set(store, &iter,
COLUMN_NAME, cat->displayname,
COLUMN_SELECTED, TRUE,
-1);
AST_LIST_TRAVERSE(&cat->members, mem, list) {
char name_buf[64];
char dep_buf[64] = "";
char use_buf[64] = "";
char cnf_buf[64] = "";
struct reference *dep;
struct reference *use;
struct reference *cnf;
AST_LIST_TRAVERSE(&mem->deps, dep, list) {
strncat(dep_buf, dep->displayname, sizeof(dep_buf) - strlen(dep_buf) - 1);
strncat(dep_buf, dep->member ? "(M)" : "(E)", sizeof(dep_buf) - strlen(dep_buf) - 1);
if (AST_LIST_NEXT(dep, list))
strncat(dep_buf, ", ", sizeof(dep_buf) - strlen(dep_buf) - 1);
}
AST_LIST_TRAVERSE(&mem->uses, use, list) {
strncat(use_buf, use->displayname, sizeof(use_buf) - strlen(use_buf) - 1);
if (AST_LIST_NEXT(use, list))
strncat(use_buf, ", ", sizeof(use_buf) - strlen(use_buf) - 1);
}
AST_LIST_TRAVERSE(&mem->conflicts, cnf, list) {
strncat(cnf_buf, cnf->displayname, sizeof(cnf_buf) - strlen(cnf_buf) - 1);
strncat(cnf_buf, cnf->member ? "(M)" : "(E)", sizeof(cnf_buf) - strlen(cnf_buf) - 1);
if (AST_LIST_NEXT(cnf, list))
strncat(cnf_buf, ", ", sizeof(cnf_buf) - strlen(cnf_buf) - 1);
}
if (mem->is_separator) {
snprintf(name_buf, sizeof(name_buf), "--- %s ---", mem->name);
} else {
snprintf(name_buf, sizeof(name_buf), "%s", mem->name);
}
if (mem->depsfailed == HARD_FAILURE)
strncat(name_buf, " (Failed Deps.)", sizeof(name_buf) - strlen(name_buf) - 1);
if (mem->conflictsfailed == HARD_FAILURE)
strncat(name_buf, " (In Conflict)", sizeof(name_buf) - strlen(name_buf) - 1);
gtk_tree_store_append(store, &iter2, &iter);
gtk_tree_store_set(store, &iter2,
COLUMN_NAME, name_buf,
COLUMN_SELECTED, mem->enabled,
COLUMN_DEPS, dep_buf,
COLUMN_USES, use_buf,
COLUMN_CNFS, cnf_buf,
-1);
}
}
tree = (GtkTreeView *) gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_enable_tree_lines(tree, TRUE);
gtk_tree_view_set_grid_lines(tree, GTK_TREE_VIEW_GRID_LINES_BOTH);
#endif
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Name",
renderer, "text", COLUMN_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes("Selected",
renderer, "active", COLUMN_SELECTED, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
g_signal_connect(renderer, "toggled", (GCallback) toggled_handler, store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Depends On",
renderer, "text", COLUMN_DEPS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Can Use",
renderer, "text", COLUMN_USES, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Conflicts With",
renderer, "text", COLUMN_CNFS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
g_signal_connect(tree, "row-activated", (GCallback) row_activated_handler, store);
gtk_container_add(GTK_CONTAINER(s_window), GTK_WIDGET(tree));
gtk_box_pack_end(GTK_BOX(main_vbox), s_window, TRUE, TRUE, 0);
gtk_widget_show_all(window);
gtk_main();
return main_res;
}

View File

@ -1,427 +0,0 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2008 Sean Bright
*
* Sean Bright <sean.bright@gmail.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*
* \file
*
* \author Sean Bright <sean.bright@gmail.com>
*
* \brief newt frontend for selection maintenance
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <newt.h>
#include "menuselect.h"
#define MIN_X 80
#define MIN_Y 21
#define MIN(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a > __b) ? __b : __a);})
#define MAX(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a < __b) ? __b : __a);})
extern int changes_made;
static newtComponent rootOptions;
static newtComponent subOptions;
static newtComponent memberNameTextbox;
static newtComponent dependsLabel;
static newtComponent usesLabel;
static newtComponent conflictsLabel;
static newtComponent supportLevelLabel;
static newtComponent dependsDataTextbox;
static newtComponent usesDataTextbox;
static newtComponent conflictsDataTextbox;
static newtComponent supportLevelDataTextbox;
static newtComponent exitButton;
static newtComponent saveAndExitButton;
static void build_members_menu(int overlay);
static void root_menu_callback(newtComponent component, void *data);
static void toggle_all_options(int select)
{
struct category *cat = newtListboxGetCurrent(rootOptions);
set_all(cat, select);
/* Redraw */
build_members_menu(1);
return;
}
static void toggle_selected_option()
{
int i;
struct member *mem = newtListboxGetCurrent(subOptions);
toggle_enabled(mem);
/* Redraw */
build_members_menu(1);
/* Select the next item in the list */
for (i = 0; i < newtListboxItemCount(subOptions); i++) {
struct member *cur;
newtListboxGetEntry(subOptions, i, NULL, (void **) &cur);
if (cur == mem) {
i = MIN(i + 1, newtListboxItemCount(subOptions) - 1);
break;
}
}
newtListboxSetCurrent(subOptions, i);
return;
}
static void reset_display()
{
newtTextboxSetText(memberNameTextbox, "");
newtTextboxSetText(dependsDataTextbox, "");
newtTextboxSetText(usesDataTextbox, "");
newtTextboxSetText(conflictsDataTextbox, "");
newtTextboxSetText(supportLevelDataTextbox, "");
newtRefresh();
}
static void display_member_info(struct member *mem)
{
char buffer[128] = { 0 };
struct reference *dep;
struct reference *con;
struct reference *uses;
reset_display();
if (mem->displayname) {
newtTextboxSetText(memberNameTextbox, mem->displayname);
}
if (AST_LIST_EMPTY(&mem->deps)) {
if (mem->is_separator) {
newtTextboxSetText(dependsDataTextbox, "");
} else {
newtTextboxSetText(dependsDataTextbox, "N/A");
}
} else {
strcpy(buffer, "");
AST_LIST_TRAVERSE(&mem->deps, dep, list) {
strncat(buffer, dep->displayname, sizeof(buffer) - strlen(buffer) - 1);
strncat(buffer, dep->member ? "(M)" : "(E)", sizeof(buffer) - strlen(buffer) - 1);
if (AST_LIST_NEXT(dep, list))
strncat(buffer, ", ", sizeof(buffer) - strlen(buffer) - 1);
}
newtTextboxSetText(dependsDataTextbox, buffer);
}
if (AST_LIST_EMPTY(&mem->uses)) {
if (mem->is_separator) {
newtTextboxSetText(usesDataTextbox, "");
} else {
newtTextboxSetText(usesDataTextbox, "N/A");
}
} else {
strcpy(buffer, "");
AST_LIST_TRAVERSE(&mem->uses, uses, list) {
strncat(buffer, uses->displayname, sizeof(buffer) - strlen(buffer) - 1);
strncat(buffer, uses->member ? "(M)" : "(E)", sizeof(buffer) - strlen(buffer) - 1);
if (AST_LIST_NEXT(uses, list))
strncat(buffer, ", ", sizeof(buffer) - strlen(buffer) - 1);
}
newtTextboxSetText(usesDataTextbox, buffer);
}
if (AST_LIST_EMPTY(&mem->conflicts)) {
if (!mem->is_separator) {
newtTextboxSetText(conflictsDataTextbox, "N/A");
} else {
newtTextboxSetText(conflictsDataTextbox, "");
}
} else {
strcpy(buffer, "");
AST_LIST_TRAVERSE(&mem->conflicts, con, list) {
strncat(buffer, con->displayname, sizeof(buffer) - strlen(buffer) - 1);
strncat(buffer, con->member ? "(M)" : "(E)", sizeof(buffer) - strlen(buffer) - 1);
if (AST_LIST_NEXT(con, list))
strncat(buffer, ", ", sizeof(buffer) - strlen(buffer) - 1);
}
newtTextboxSetText(conflictsDataTextbox, buffer);
}
{ /* Support Level */
snprintf(buffer, sizeof(buffer), "%s", mem->support_level);
if (mem->replacement && *mem->replacement) {
char buf2[64];
snprintf(buf2, sizeof(buf2), ", Replaced by: %s", mem->replacement);
strncat(buffer, buf2, sizeof(buffer) - strlen(buffer) - 1);
}
if (mem->is_separator) {
newtTextboxSetText(supportLevelDataTextbox, "");
} else {
newtTextboxSetText(supportLevelDataTextbox, buffer);
}
}
}
static void build_members_menu(int overlay)
{
struct category *cat;
struct member *mem;
char buf[64];
int i = 0;
if (!overlay) {
reset_display();
newtListboxClear(subOptions);
}
cat = newtListboxGetCurrent(rootOptions);
AST_LIST_TRAVERSE(&cat->members, mem, list) {
if ((mem->depsfailed == HARD_FAILURE) || (mem->conflictsfailed == HARD_FAILURE)) {
snprintf(buf, sizeof(buf), "XXX %s", mem->name);
} else if (mem->is_separator) {
snprintf(buf, sizeof(buf), " --- %s ---", mem->name);
} else if (mem->depsfailed == SOFT_FAILURE) {
snprintf(buf, sizeof(buf), "<%s> %s", mem->enabled ? "*" : " ", mem->name);
} else if (mem->conflictsfailed == SOFT_FAILURE) {
snprintf(buf, sizeof(buf), "(%s) %s", mem->enabled ? "*" : " ", mem->name);
} else {
snprintf(buf, sizeof(buf), "[%s] %s", mem->enabled ? "*" : " ", mem->name);
}
if (overlay) {
newtListboxSetEntry(subOptions, i, buf);
} else {
newtListboxAppendEntry(subOptions, buf, mem);
}
i++;
}
if (!overlay) {
display_member_info(AST_LIST_FIRST(&cat->members));
}
return;
}
static void build_main_menu()
{
struct category *cat;
char buf[64];
int i = 1;
newtListboxClear(rootOptions);
AST_LIST_TRAVERSE(&categories, cat, list) {
if (!strlen_zero(cat->displayname))
snprintf(buf, sizeof(buf), " %s ", cat->displayname);
else
snprintf(buf, sizeof(buf), " %s ", cat->name);
newtListboxAppendEntry(rootOptions, buf, cat);
i++;
}
}
static void category_menu_callback(newtComponent component, void *data)
{
display_member_info(newtListboxGetCurrent(subOptions));
}
static void root_menu_callback(newtComponent component, void *data)
{
build_members_menu(0);
}
int run_confirmation_dialog(int *result)
{
int res = newtWinTernary("Are You Sure?", "Discard changes & Exit", "Save & Exit", "Cancel",
"It appears you have made some changes, and you have opted to Quit "
"without saving these changes. Please choose \"Discard changes & Exit\" to exit "
"without saving; Choose \"Cancel\" to cancel your decision to quit, and keep "
"working in menuselect, or choose \"Save & Exit\" to save your changes, and exit.");
switch (res) {
case 1:
/* Discard and exit */
*result = -1;
return 1;
case 2:
/* Save and exit */
*result = 0;
return 1;
case 3:
/* They either chose "No" or they hit F12 */
default:
*result = -1;
return 0;
}
}
int run_menu(void)
{
struct newtExitStruct es;
newtComponent form;
int x = 0, y = 0, res = 0;
newtInit();
newtCls();
newtGetScreenSize(&x, &y);
if (x < MIN_X || y < MIN_Y) {
newtFinished();
fprintf(stderr, "Terminal must be at least %d x %d.\n", MIN_X, MIN_Y);
return -1;
}
newtPushHelpLine(" <ENTER> toggles selection | <F12> saves & exits | <ESC> exits without save");
newtRefresh();
newtCenteredWindow(x - 8, y - 7, menu_name);
form = newtForm(NULL, NULL, 0);
/* F8 for select all */
newtFormAddHotKey(form, NEWT_KEY_F8);
/* F7 for deselect all */
newtFormAddHotKey(form, NEWT_KEY_F7);
newtFormSetTimer(form, 200);
rootOptions = newtListbox(2, 1, y - 15, 0);
newtListboxSetWidth(rootOptions, 34);
newtFormAddComponent(form, rootOptions);
newtComponentAddCallback(rootOptions, root_menu_callback, NULL);
subOptions = newtListbox(38, 1, y - 15, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
newtListboxSetWidth(subOptions, x - 47);
newtFormAddComponent(form, subOptions);
newtComponentAddCallback(subOptions, category_menu_callback, NULL);
memberNameTextbox = newtTextbox(2, y - 13, x - 10, 1, 0);
dependsLabel = newtLabel(2, y - 11, " Depends on:");
usesLabel = newtLabel(2, y - 10, " Can use:");
conflictsLabel = newtLabel(2, y - 9, "Conflicts with:");
supportLevelLabel = newtLabel(2, y - 8, " Support Level:");
dependsDataTextbox = newtTextbox(18, y - 11, x - 27, 1, 0);
usesDataTextbox = newtTextbox(18, y - 10, x - 27, 1, 0);
conflictsDataTextbox = newtTextbox(18, y - 9, x - 27, 1, 0);
supportLevelDataTextbox = newtTextbox(18, y - 8, x - 27, 1, 0);
exitButton = newtButton(x - 23, y - 11, " Exit ");
saveAndExitButton = newtButton(x - 43, y - 11, " Save & Exit ");
newtFormAddComponents(
form,
memberNameTextbox,
dependsLabel,
dependsDataTextbox,
usesLabel,
usesDataTextbox,
conflictsLabel,
conflictsDataTextbox,
supportLevelLabel,
supportLevelDataTextbox,
saveAndExitButton,
exitButton,
NULL);
build_main_menu();
root_menu_callback(rootOptions, AST_LIST_FIRST(&categories));
for (;;) {
do {
newtFormRun(form, &es);
} while (es.reason == NEWT_EXIT_TIMER);
if (es.reason == NEWT_EXIT_HOTKEY) {
int done = 1;
switch (es.u.key) {
case NEWT_KEY_F12:
res = 0;
break;
case NEWT_KEY_F7:
toggle_all_options(0);
done = 0;
break;
case NEWT_KEY_F8:
toggle_all_options(1);
done = 0;
break;
case NEWT_KEY_ESCAPE:
if (changes_made) {
done = run_confirmation_dialog(&res);
} else {
res = -1;
}
break;
default:
done = 0;
break;
}
if (done) {
break;
}
} else if (es.reason == NEWT_EXIT_COMPONENT) {
if (es.u.co == saveAndExitButton) {
res = 0;
break;
} else if (es.u.co == exitButton) {
int done = 1;
if (changes_made) {
done = run_confirmation_dialog(&res);
} else {
res = -1;
}
if (done) {
break;
}
} else if (es.u.co == subOptions) {
toggle_selected_option();
}
}
}
/* Cleanup */
reset_display();
newtFormDestroy(form);
newtPopWindow();
newtPopHelpLine();
newtCls();
newtFinished();
return res;
}

View File

@ -1,39 +0,0 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2005 - 2006, Russell Bryant
*
* Russell Bryant <russell@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
/*
* \file
*
* \author Russell Bryant <russell@digium.com>
*
* \brief Menu stub
*/
#include <stdlib.h>
#include <stdio.h>
#include "menuselect.h"
int run_menu(void)
{
fprintf(stderr, "**************************************************\n");
fprintf(stderr, "*** Install ncurses to use the menu interface! ***\n");
fprintf(stderr, "**************************************************\n");
return -1;
}

View File

@ -1,360 +0,0 @@
#! /bin/sh
# Common stub for a few missing GNU programs while installing.
scriptversion=2005-06-08.21
# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005
# Free Software Foundation, Inc.
# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
# 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, 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., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
if test $# -eq 0; then
echo 1>&2 "Try \`$0 --help' for more information"
exit 1
fi
run=:
# In the cases where this matters, `missing' is being run in the
# srcdir already.
if test -f configure.ac; then
configure_ac=configure.ac
else
configure_ac=configure.in
fi
msg="missing on your system"
case "$1" in
--run)
# Try to run requested program, and just exit if it succeeds.
run=
shift
"$@" && exit 0
# Exit code 63 means version mismatch. This often happens
# when the user try to use an ancient version of a tool on
# a file that requires a minimum version. In this case we
# we should proceed has if the program had been absent, or
# if --run hadn't been passed.
if test $? = 63; then
run=:
msg="probably too old"
fi
;;
-h|--h|--he|--hel|--help)
echo "\
$0 [OPTION]... PROGRAM [ARGUMENT]...
Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
error status if there is no known handling for PROGRAM.
Options:
-h, --help display this help and exit
-v, --version output version information and exit
--run try to run the given command, and emulate it if it fails
Supported PROGRAM values:
aclocal touch file \`aclocal.m4'
autoconf touch file \`configure'
autoheader touch file \`config.h.in'
automake touch all \`Makefile.in' files
bison create \`y.tab.[ch]', if possible, from existing .[ch]
flex create \`lex.yy.c', if possible, from existing .c
help2man touch the output file
lex create \`lex.yy.c', if possible, from existing .c
makeinfo touch the output file
tar try tar, gnutar, gtar, then tar without non-portable flags
yacc create \`y.tab.[ch]', if possible, from existing .[ch]
Send bug reports to <bug-automake@gnu.org>."
exit $?
;;
-v|--v|--ve|--ver|--vers|--versi|--versio|--version)
echo "missing $scriptversion (GNU Automake)"
exit $?
;;
-*)
echo 1>&2 "$0: Unknown \`$1' option"
echo 1>&2 "Try \`$0 --help' for more information"
exit 1
;;
esac
# Now exit if we have it, but it failed. Also exit now if we
# don't have it and --version was passed (most likely to detect
# the program).
case "$1" in
lex|yacc)
# Not GNU programs, they don't have --version.
;;
tar)
if test -n "$run"; then
echo 1>&2 "ERROR: \`tar' requires --run"
exit 1
elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
exit 1
fi
;;
*)
if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
# We have it, but it failed.
exit 1
elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
# Could not run --version or --help. This is probably someone
# running `$TOOL --version' or `$TOOL --help' to check whether
# $TOOL exists and not knowing $TOOL uses missing.
exit 1
fi
;;
esac
# If it does not exist, or fails to run (possibly an outdated version),
# try to emulate it.
case "$1" in
aclocal*)
echo 1>&2 "\
WARNING: \`$1' is $msg. You should only need it if
you modified \`acinclude.m4' or \`${configure_ac}'. You might want
to install the \`Automake' and \`Perl' packages. Grab them from
any GNU archive site."
touch aclocal.m4
;;
autoconf)
echo 1>&2 "\
WARNING: \`$1' is $msg. You should only need it if
you modified \`${configure_ac}'. You might want to install the
\`Autoconf' and \`GNU m4' packages. Grab them from any GNU
archive site."
touch configure
;;
autoheader)
echo 1>&2 "\
WARNING: \`$1' is $msg. You should only need it if
you modified \`acconfig.h' or \`${configure_ac}'. You might want
to install the \`Autoconf' and \`GNU m4' packages. Grab them
from any GNU archive site."
files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
test -z "$files" && files="config.h"
touch_files=
for f in $files; do
case "$f" in
*:*) touch_files="$touch_files "`echo "$f" |
sed -e 's/^[^:]*://' -e 's/:.*//'`;;
*) touch_files="$touch_files $f.in";;
esac
done
touch $touch_files
;;
automake*)
echo 1>&2 "\
WARNING: \`$1' is $msg. You should only need it if
you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
You might want to install the \`Automake' and \`Perl' packages.
Grab them from any GNU archive site."
find . -type f -name Makefile.am -print |
sed 's/\.am$/.in/' |
while read f; do touch "$f"; done
;;
autom4te)
echo 1>&2 "\
WARNING: \`$1' is needed, but is $msg.
You might have modified some files without having the
proper tools for further handling them.
You can get \`$1' as part of \`Autoconf' from any GNU
archive site."
file=`echo "$*" | sed -n 's/.*--output[ =]*\([^ ]*\).*/\1/p'`
test -z "$file" && file=`echo "$*" | sed -n 's/.*-o[ ]*\([^ ]*\).*/\1/p'`
if test -f "$file"; then
touch $file
else
test -z "$file" || exec >$file
echo "#! /bin/sh"
echo "# Created by GNU Automake missing as a replacement of"
echo "# $ $@"
echo "exit 0"
chmod +x $file
exit 1
fi
;;
bison|yacc)
echo 1>&2 "\
WARNING: \`$1' $msg. You should only need it if
you modified a \`.y' file. You may need the \`Bison' package
in order for those modifications to take effect. You can get
\`Bison' from any GNU archive site."
rm -f y.tab.c y.tab.h
if [ $# -ne 1 ]; then
eval LASTARG="\${$#}"
case "$LASTARG" in
*.y)
SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
if [ -f "$SRCFILE" ]; then
cp "$SRCFILE" y.tab.c
fi
SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
if [ -f "$SRCFILE" ]; then
cp "$SRCFILE" y.tab.h
fi
;;
esac
fi
if [ ! -f y.tab.h ]; then
echo >y.tab.h
fi
if [ ! -f y.tab.c ]; then
echo 'main() { return 0; }' >y.tab.c
fi
;;
lex|flex)
echo 1>&2 "\
WARNING: \`$1' is $msg. You should only need it if
you modified a \`.l' file. You may need the \`Flex' package
in order for those modifications to take effect. You can get
\`Flex' from any GNU archive site."
rm -f lex.yy.c
if [ $# -ne 1 ]; then
eval LASTARG="\${$#}"
case "$LASTARG" in
*.l)
SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
if [ -f "$SRCFILE" ]; then
cp "$SRCFILE" lex.yy.c
fi
;;
esac
fi
if [ ! -f lex.yy.c ]; then
echo 'main() { return 0; }' >lex.yy.c
fi
;;
help2man)
echo 1>&2 "\
WARNING: \`$1' is $msg. You should only need it if
you modified a dependency of a manual page. You may need the
\`Help2man' package in order for those modifications to take
effect. You can get \`Help2man' from any GNU archive site."
file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`
if test -z "$file"; then
file=`echo "$*" | sed -n 's/.*--output=\([^ ]*\).*/\1/p'`
fi
if [ -f "$file" ]; then
touch $file
else
test -z "$file" || exec >$file
echo ".ab help2man is required to generate this page"
exit 1
fi
;;
makeinfo)
echo 1>&2 "\
WARNING: \`$1' is $msg. You should only need it if
you modified a \`.texi' or \`.texinfo' file, or any other file
indirectly affecting the aspect of the manual. The spurious
call might also be the consequence of using a buggy \`make' (AIX,
DU, IRIX). You might want to install the \`Texinfo' package or
the \`GNU make' package. Grab either from any GNU archive site."
# The file to touch is that specified with -o ...
file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`
if test -z "$file"; then
# ... or it is the one specified with @setfilename ...
infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
file=`sed -n '/^@setfilename/ { s/.* \([^ ]*\) *$/\1/; p; q; }' $infile`
# ... or it is derived from the source name (dir/f.texi becomes f.info)
test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
fi
# If the file does not exist, the user really needs makeinfo;
# let's fail without touching anything.
test -f $file || exit 1
touch $file
;;
tar)
shift
# We have already tried tar in the generic part.
# Look for gnutar/gtar before invocation to avoid ugly error
# messages.
if (gnutar --version > /dev/null 2>&1); then
gnutar "$@" && exit 0
fi
if (gtar --version > /dev/null 2>&1); then
gtar "$@" && exit 0
fi
firstarg="$1"
if shift; then
case "$firstarg" in
*o*)
firstarg=`echo "$firstarg" | sed s/o//`
tar "$firstarg" "$@" && exit 0
;;
esac
case "$firstarg" in
*h*)
firstarg=`echo "$firstarg" | sed s/h//`
tar "$firstarg" "$@" && exit 0
;;
esac
fi
echo 1>&2 "\
WARNING: I can't seem to be able to run \`tar' with the given arguments.
You may want to install GNU tar or Free paxutils, or check the
command line arguments."
exit 1
;;
*)
echo 1>&2 "\
WARNING: \`$1' is needed, and is $msg.
You might have modified some files without having the
proper tools for further handling them. Check the \`README' file,
it often tells you about the needed prerequisites for installing
this package. You may also peek at any GNU archive site, in case
some other package would contain this missing \`$1' program."
exit 1
;;
esac
exit 0
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-end: "$"
# End:

View File

@ -1,5 +0,0 @@
Mini-XML 2.2.2 is now available for download from:
http://www.easysw.com/~mike/mxml/software.php
Mini-XML 2.2.2 fixes a bug in the reading of custom data nodes.

View File

@ -1,213 +0,0 @@
CHANGES - 05/19/2005
--------------------
CHANGES IN Mini-XML 2.2.2
- mxmlLoad*() did not treat custom data as opaque, so
whitespace characters would be lost.
CHANGES IN Mini-XML 2.2.1
- mxmlLoadFd(), mxmlLoadFile(), and mxmlLoadString() now
correctly return NULL on error (STR #21)
- mxmlNewInteger(), mxmlNewOpaque(), mxmlNewReal(),
mxmlNewText(), and mxmlNewTextf() incorrectly required
a parent node (STR #22)
- Fixed an XML output bug in mxmldoc.
- The "make install" target now uses the install command
to set the proper permissions on UNIX/Linux/OSX.
- Fixed a MingW/Cygwin compilation problem (STR #18)
CHANGES IN Mini-XML 2.2
- Added shared library support (STR #17)
- mxmlLoad*() now returns an error when an XML stream
contains illegal control characters (STR #10)
- mxmlLoad*() now returns an error when an element
contains two attributes with the same name in
conformance with the XML spec (STR #16)
- Added support for CDATA (STR #14, STR #15)
- Updated comment and processing instruction handling -
no entity support per XML specification.
- Added checking for invalid comment termination ("--->"
is not allowed)
CHANGES IN Mini-XML 2.1
- Added support for custom data nodes (STR #6)
- Now treat UTF-8 sequences which are longer than
necessary as an error (STR #4)
- Fixed entity number support (STR #8)
- Fixed mxmlLoadString() bug with UTF-8 (STR #7)
- Fixed entity lookup bug (STR #5)
- Added mxmlLoadFd() and mxmlSaveFd() functions.
- Fixed multi-word UTF-16 handling.
CHANGES IN Mini-XML 2.0
- New programmers manual.
- Added Visual C++ project files for Microsoft Windows
users.
- Added optimizations to mxmldoc, mxmlSaveFile(), and
mxmlIndexNew() (STR #2)
- mxmlEntityAddCallback() now returns an integer status
(STR #2)
- Added UTF-16 support (input only; all output is UTF-8)
- Added index functions to build a searchable index of
XML nodes.
- Added character entity callback interface to support
additional character entities beyond those defined in
the XHTML specification.
- Added support for XHTML character entities.
- The mxmldoc utility now produces XML output which
conforms to an updated XML schema, described in the file
"doc/mxmldoc.xsd".
- Changed the whitespace callback interface to return
strings instead of a single character, allowing for
greater control over the formatting of XML files
written using Mini-XML. THIS CHANGE WILL REQUIRE
CHANGES TO YOUR 1.x CODE IF YOU USE WHITESPACE
CALLBACKS.
- The mxmldoc utility is now capable of documenting C++
classes, functions, and structures, and correctly
handles C++ comments.
- Added new modular tests for mxmldoc.
- Updated the mxmldoc output to be more compatible with
embedding in manuals produced with HTMLDOC.
- The makefile incorrectly included a "/" separator
between the destination path and install path. This
caused problems when building and installing with
MingW.
CHANGES IN Mini-XML 1.3
- Fixes for mxmldoc.
- Added support for reading standard HTML entity names.
- mxmlLoadString/File() did not decode character
entities in element names, attribute names, or
attribute values.
- mxmlLoadString/File() would crash when loading non-
conformant XML data under an existing parent (top)
node.
- Fixed several bugs in the mxmldoc utility.
- Added new error callback function to catch a variety
of errors and log them to someplace other than stderr.
- The mxmlElementSetAttr() function now allows for NULL
attribute values.
- The load and save functions now properly handle quoted
element and attribute name strings properly, e.g. for
!DOCTYPE declarations.
CHANGES IN Mini-XML 1.2
- Added new "set" methods to set the value of a node.
- Added new formatted text methods mxmlNewTextf() and
mxmlSetTextf() to create/set a text node value using
printf-style formats.
- Added new standard callbacks for use with the mxmlLoad
functions.
- Updated the HTML documentation to include examples of
the walk and load function output.
- Added --with/without-ansi configure option to control
the strdup() function check.
- Added --with/without-snprintf configure option to
control the snprintf() and vsnprintf() function
checks.
CHANGES IN Mini-XML 1.1.2
- The mxml(3) man page wasn't updated for the string
functions.
- mxmlSaveString() returned the wrong number of
characters.
- mxml_add_char() updated the buffer pointer in the
wrong place.
CHANGES IN Mini-XML 1.1.1
- The private mxml_add_ch() function did not update the
start-of-buffer pointer which could cause a crash when
using mxmlSaveString().
- The private mxml_write_ws() function called putc()
instead of using the proper callback which could cause
a crash when using mxmlSaveString().
- Added a mxmlSaveAllocString() convenience function for
saving an XML node tree to an allocated string.
CHANGES IN Mini-XML 1.1
- The mxmlLoadFile() function now uses dynamically
allocated string buffers for element names, attribute
names, and attribute values. Previously they were
capped at 16383, 255, and 255 bytes, respectively.
- Added a new mxmlLoadString() function for loading an
XML node tree from a string.
- Added a new mxmlSaveString() function for saving an
XML node tree to a string.
- Add emulation of strdup() if the local platform does
not provide the function.
CHANGES IN Mini-XML 1.0
- The mxmldoc program now handles function arguments,
structures, unions, enumerations, classes, and
typedefs properly.
- Documentation provided via mxmldoc and more in-line
comments in the code.
- Added man pages and packaging files.
CHANGES IN Mini-XML 0.93
- New mxmldoc example program that is also used to
create and update code documentation using XML and
produce HTML reference pages.
- Added mxmlAdd() and mxmlRemove() functions to add and
remove nodes from a tree. This provides more
flexibility over where the nodes are inserted and
allows nodes to be moved within the tree as needed.
- mxmlLoadFile() now correctly handles comments.
- mxmlLoadFile() now supports the required "gt", "quot",
and "nbsp" character entities.
- mxmlSaveFile() now uses newlines as whitespace
when valid to do so.
- mxmlFindElement() now also takes attribute name and
attribute value string arguments to limit the search
to specific elements with attributes and/or values.
NULL pointers can be used as "wildcards".
- Added uninstall target to makefile, and auto-reconfig
if Makefile.in or configure.in are changed.
- mxmlFindElement(), mxmlWalkNext(), and mxmlWalkPrev()
now all provide "descend" arguments to control whether
they descend into child nodes in the tree.
- Fixed some whitespace issues in mxmlLoadFile().
- Fixed Unicode output and whitespace issues in
mxmlSaveFile().
- mxmlSaveFile() now supports a whitespace callback to
provide more human-readable XML output under program
control.
CHANGES IN Mini-XML 0.92
- mxmlSaveFile() didn't return a value on success.
CHANGES IN Mini-XML 0.91
- mxmlWalkNext() would go into an infinite loop.
CHANGES IN Mini-XML 0.9
- Initial public release.

View File

@ -1,482 +0,0 @@
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

View File

@ -1,342 +0,0 @@
#
# "$Id: Makefile.in 23382 2006-04-29 15:44:02Z russell $"
#
# Makefile for Mini-XML, a small XML-like file parsing library.
#
# Copyright 2003-2005 by Michael Sweet.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2, 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.
#
#
# Compiler tools definitions...
#
AR = @AR@
ARFLAGS = @ARFLAGS@
CC = @CC@
CFLAGS = $(OPTIM) @CFLAGS@ @CPPFLAGS@
CP = @CP@
DSO = @DSO@
DSOFLAGS = @DSOFLAGS@
LDFLAGS = $(OPTIM) @LDFLAGS@
INSTALL = @INSTALL@
LIBMXML = @LIBMXML@
LN = @LN@ -s
MKDIR = @MKDIR@
OPTIM = @OPTIM@
RANLIB = @RANLIB@
RM = @RM@ -f
SHELL = /bin/sh
#
# Configured directories...
#
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
includedir = @includedir@
libdir = @libdir@
mandir = @mandir@
docdir = @docdir@
datarootdir = @datarootdir@
BUILDROOT = $(DSTROOT)
#
# Install commands...
#
INSTALL_BIN = $(LIBTOOL) $(INSTALL) -m 755 -s
INSTALL_DATA = $(INSTALL) -m 644
INSTALL_DIR = $(INSTALL) -d
INSTALL_LIB = $(LIBTOOL) $(INSTALL) -m 755
INSTALL_MAN = $(INSTALL) -m 644
INSTALL_SCRIPT = $(INSTALL) -m 755
#
# Rules...
#
.SUFFIXES: .0 .1 .3 .c .man .o
.c.o:
$(CC) $(CFLAGS) -c $<
.man.0 .man.1 .man.3:
$(RM) $@
$(NROFF) -man $< >$@
#
# Targets...
#
DOCFILES = doc/mxml.html doc/mxmldoc.xsd \
README COPYING CHANGES
PUBLIBOBJS = mxml-attr.o mxml-entity.o mxml-file.o mxml-index.o \
mxml-node.o mxml-search.o mxml-set.o
LIBOBJS = $(PUBLIBOBJS) mxml-private.o mxml-string.o
OBJS = mxmldoc.o testmxml.o $(LIBOBJS)
TARGETS = $(LIBMXML) mxmldoc testmxml mxml.xml
#
# Make everything...
#
all: Makefile configure config.h $(TARGETS)
#
# Clean everything...
#
clean:
$(RM) $(OBJS) $(TARGETS)
$(RM) mxmldoc-static libmxml.a
$(RM) *.bck *.bak
$(RM) config.cache config.log config.status config.h
$(RM) -r autom4te*.cache
distclean: clean
$(RM) mxml.list Makefile
#
# Install everything...
#
install: $(TARGETS) install-$(LIBMXML) install-libmxml.a
$(INSTALL_DIR) $(BUILDROOT)$(bindir)
$(INSTALL_BIN) mxmldoc $(BUILDROOT)$(bindir)
$(INSTALL_DIR) $(BUILDROOT)$(docdir)
for file in $(DOCFILES); do \
$(INSTALL_MAN) $$file $(BUILDROOT)$(docdir); \
done
$(INSTALL_DIR) $(BUILDROOT)$(includedir)
$(INSTALL_DATA) mxml.h $(BUILDROOT)$(includedir)
$(INSTALL_DIR) $(BUILDROOT)$(libdir)/pkgconfig
$(INSTALL_DATA) mxml.pc $(BUILDROOT)$(libdir)/pkgconfig
$(INSTALL_DIR) $(BUILDROOT)$(mandir)/cat1
$(INSTALL_MAN) doc/mxmldoc.$(CAT1EXT) $(BUILDROOT)$(mandir)/cat1/mxmldoc.$(CAT1EXT)
$(INSTALL_DIR) $(BUILDROOT)$(mandir)/cat3
$(INSTALL_MAN) doc/mxml.$(CAT3EXT) $(BUILDROOT)$(mandir)/cat3/mxml.$(CAT3EXT)
$(INSTALL_DIR) $(BUILDROOT)$(mandir)/man1
$(INSTALL_MAN) doc/mxmldoc.man $(BUILDROOT)$(mandir)/man1/mxmldoc.$(MAN1EXT)
$(INSTALL_DIR) $(BUILDROOT)$(mandir)/man3
$(INSTALL_MAN) doc/mxml.man $(BUILDROOT)$(mandir)/man3/mxml.$(MAN3EXT)
install-libmxml.a:
$(INSTALL_DIR) $(BUILDROOT)$(libdir)
$(INSTALL_LIB) libmxml.a $(BUILDROOT)$(libdir)
install-libmxml.so.1.0:
$(INSTALL_DIR) $(BUILDROOT)$(libdir)
$(INSTALL_LIB) libmxml.so.1.0 $(BUILDROOT)$(libdir)
$(RM) $(BUILDROOT)$(libdir)/libmxml.so
$(LN) libmxml.so.1.0 $(BUILDROOT)$(libdir)/libmxml.so
$(RM) $(BUILDROOT)$(libdir)/libmxml.so.1
$(LN) libmxml.so.1.0 $(BUILDROOT)$(libdir)/libmxml.so.1
install-libmxml.sl.1:
$(INSTALL_DIR) $(BUILDROOT)$(libdir)
$(INSTALL_LIB) libmxml.sl.1 $(BUILDROOT)$(libdir)
$(RM) $(BUILDROOT)$(libdir)/libmxml.so
$(LN) libmxml.sl.1 $(BUILDROOT)$(libdir)/libmxml.sl
install-libmxml.1.dylib:
$(INSTALL_DIR) $(BUILDROOT)$(libdir)
$(INSTALL_LIB) libmxml.1.dylib $(BUILDROOT)$(libdir)
$(RM) $(BUILDROOT)$(libdir)/libmxml.dylib
$(LN) libmxml.1.dylib $(BUILDROOT)$(libdir)/libmxml.dylib
#
# Uninstall everything...
#
uninstall: uninstall-$(LIBMXML) uninstall-libmxml.a
$(RM) $(BUILDROOT)$(bindir)/mxmldoc
$(RM) -r $(BUILDROOT)$(docdir)
$(RM) $(BUILDROOT)$(includedir)/mxml.h
$(RM) $(BUILDROOT)$(libdir)/pkgconfig/mxml.pc
$(RM) $(BUILDROOT)$(mandir)/cat1/mxmldoc.$(CAT1EXT)
$(RM) $(BUILDROOT)$(mandir)/cat3/mxml.$(CAT3EXT)
$(RM) $(BUILDROOT)$(mandir)/man1/mxmldoc.$(MAN1EXT)
$(RM) $(BUILDROOT)$(mandir)/man3/mxml.$(MAN3EXT)
uninstall-libmxml.a:
$(RM) $(BUILDROOT)$(libdir)/libmxml.a
uninstall-libmxml.so.1.0:
$(RM) $(BUILDROOT)$(libdir)/libmxml.so
$(RM) $(BUILDROOT)$(libdir)/libmxml.so.1
$(RM) $(BUILDROOT)$(libdir)/libmxml.so.1.0
uninstall-libmxml.sl.1:
$(RM) $(BUILDROOT)$(libdir)/libmxml.sl
$(RM) $(BUILDROOT)$(libdir)/libmxml.sl.1
uninstall-libmxml.1.dylib:
$(RM) $(BUILDROOT)$(libdir)/libmxml.dylib
$(RM) $(BUILDROOT)$(libdir)/libmxml.1.dylib
#
# Make packages using EPM (http://www.easysw.com/epm/)
#
epm: all
epm --output-dir dist -v -f native mxml
epm --output-dir dist -v -f portable mxml
#
# autoconf stuff...
#
Makefile: Makefile.in
if test -f config.status; then \
./config.status --recheck; \
./config.status; \
else \
./configure; \
fi
touch config.h
config.h: configure config.h.in
if test -f config.status; then \
./config.status --recheck; \
./config.status; \
else \
./configure; \
fi
touch config.h
#
# libmxml.a
#
libmxml.a: $(LIBOBJS)
$(RM) $@
$(AR) $(ARFLAGS) $@ $(LIBOBJS)
$(RANLIB) $@
$(LIBOBJS): mxml.h
#
# libmxml.so.1.0
#
libmxml.so.1.0: $(LIBOBJS)
$(DSO) $(DSOFLAGS) -o libmxml.so.1.0 $(LIBOBJS)
$(RM) libmxml.so libmxml.so.1
$(LN) libmxml.so.1.0 libmxml.so
$(LN) libmxml.so.1.0 libmxml.so.1
#
# libmxml.sl.1
#
libmxml.sl.1: $(LIBOBJS)
$(DSO) $(DSOFLAGS) -o libmxml.sl.1 $(LIBOBJS)
$(RM) libmxml.sl libmxml.sl.1
$(LN) libmxml.sl.1 libmxml.sl
#
# libmxml.1.dylib
#
libmxml.1.dylib: $(LIBOBJS)
$(DSO) $(DSOFLAGS) -o libmxml.1.dylib \
-install_name $(libdir)/libmxml.dylib \
-current_version 1.0.0 \
-compatibility_version 1.0.0 \
$(LIBOBJS)
$(RM) libmxml.dylib libmxml.1.dylib
$(LN) libmxml.1.dylib libmxml.dylib
#
# mxmldoc
#
mxmldoc: $(LIBMXML) mxmldoc.o
$(CC) $(LDFLAGS) -o $@ mxmldoc.o -L. -lmxml
mxmldoc-static: libmxml.a mxmldoc.o
$(CC) $(LDFLAGS) -o $@ mxmldoc.o libmxml.a
mxmldoc.o: mxml.h
#
# testmxml
#
testmxml: libmxml.a testmxml.o
$(CC) $(LDFLAGS) -o $@ testmxml.o libmxml.a
@echo Testing library...
./testmxml test.xml >temp1.xml 2>temp1s.xml
./testmxml temp1.xml >temp2.xml 2>temp2s.xml
@if cmp temp1.xml temp2.xml; then \
echo Stdio file test passed!; \
$(RM) temp2.xml temp2s.xml; \
else \
echo Stdio file test failed!; \
fi
@if cmp temp1.xml temp1s.xml; then \
echo String test passed!; \
$(RM) temp1.xml temp1s.xml; \
else \
echo String test failed!; \
fi
@if cmp test.xml test.xmlfd; then \
echo File descriptor test passed!; \
$(RM) test.xmlfd; \
else \
echo File descriptor test failed!; \
fi
testmxml.o: mxml.h
#
# mxml.xml
#
mxml.xml: mxmldoc-static mxml.h $(PUBLIBOBJS:.o=.c)
$(RM) mxml.xml
./mxmldoc-static mxml.xml mxml.h $(PUBLIBOBJS:.o=.c) >doc/reference.html
valgrind: mxmldoc-static
$(RM) valgrind.xml
valgrind --tool=memcheck --leak-check=yes ./mxmldoc-static \
valgrind.xml mxml.h $(PUBLIBOBJS:.o=.c) \
>valgrind.html 2>valgrind.out
#
# All object files depend on the makefile...
#
$(OBJS): Makefile config.h
#
# End of "$Id: Makefile.in 23382 2006-04-29 15:44:02Z russell $".
#

View File

@ -1,204 +0,0 @@
README - 05/19/2005
-------------------
INTRODUCTION
This README file describes the Mini-XML library version
2.2.2.
Mini-XML is a small XML parsing library that you can use to
read XML and XML-like data files in your application without
requiring large non-standard libraries. Mini-XML only
requires an ANSI C compatible compiler (GCC works, as do
most vendors' ANSI C compilers) and a "make" program.
Mini-XML provides the following functionality:
- Reading of UTF-8 and UTF-16 and writing of UTF-8
encoded XML files and strings.
- Data is stored in a linked-list tree structure,
preserving the XML data hierarchy.
- Supports arbitrary element names, attributes, and
attribute values with no preset limits, just available
memory.
- Supports integer, real, opaque ("cdata"), and text
data types in "leaf" nodes.
- Functions for creating and managing trees of data.
- "Find" and "walk" functions for easily locating and
navigating trees of data.
Mini-XML doesn't do validation or other types of processing
on the data based upon schema files or other sources of
definition information.
BUILDING Mini-XML
Mini-XML comes with an autoconf-based configure script; just
type the following command to get things going:
./configure
The default install prefix is /usr/local, which can be
overridden using the --prefix option:
./configure --prefix=/foo
Other configure options can be found using the --help
option:
./configure --help
Once you have configured the software, type "make" to do the
build and run the test program to verify that things are
working, as follows:
make
If you are using Mini-XML under Microsoft Windows with
Visual C++, use the included project files in the "vcnet"
subdirectory to build the library instead.
INSTALLING Mini-XML
The "install" target will install Mini-XML in the lib and
include directories:
make install
Once you have installed it, use the "-lmxml" option to link
your application against it.
DOCUMENTATION
The documentation is available in the "doc" subdirectory in
the files "mxml.html" (HTML) and "mxml.pdf" (PDF). You can
also look at the "testmxml.c" and "mxmldoc.c" source files
for examples of using Mini-XML.
Mini-XML provides a single header file which you include:
#include <mxml.h>
Nodes are defined by the "mxml_node_t" structure; the "type"
member defines the node type (element, integer, opaque,
real, or text) which determines which value you want to look
at in the "value" union. New nodes can be created using the
"mxmlNewElement()", "mxmlNewInteger()", "mxmlNewOpaque()",
"mxmlNewReal()", and "mxmlNewText()" functions. Only
elements can have child nodes, and the top node must be an
element, usually "?xml".
You load an XML file using the "mxmlLoadFile()" function:
FILE *fp;
mxml_node_t *tree;
fp = fopen("filename.xml", "r");
tree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
fclose(fp);
Similarly, you save an XML file using the "mxmlSaveFile()"
function:
FILE *fp;
mxml_node_t *tree;
fp = fopen("filename.xml", "w");
mxmlSaveFile(tree, fp, MXML_NO_CALLBACK);
fclose(fp);
The "mxmlLoadString()", "mxmlSaveAllocString()", and
"mxmlSaveString()" functions load XML node trees from and
save XML node trees to strings:
char buffer[8192];
char *ptr;
mxml_node_t *tree;
...
tree = mxmlLoadString(NULL, buffer, MXML_NO_CALLBACK);
...
mxmlSaveString(tree, buffer, sizeof(buffer), MXML_NO_CALLBACK);
...
ptr = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
You can find a named element/node using the
"mxmlFindElement()" function:
mxml_node_t *node = mxmlFindElement(tree, tree, "name", "attr",
"value", MXML_DESCEND);
The "name", "attr", and "value" arguments can be passed as
NULL to act as wildcards, e.g.:
/* Find the first "a" element */
node = mxmlFindElement(tree, tree, "a", NULL, NULL, MXML_DESCEND);
/* Find the first "a" element with "href" attribute */
node = mxmlFindElement(tree, tree, "a", "href", NULL, MXML_DESCEND);
/* Find the first "a" element with "href" to a URL */
node = mxmlFindElement(tree, tree, "a", "href",
"http://www.easysw.com/~mike/mxml/",
MXML_DESCEND);
/* Find the first element with a "src" attribute*/
node = mxmlFindElement(tree, tree, NULL, "src", NULL, MXML_DESCEND);
/* Find the first element with a "src" = "foo.jpg" */
node = mxmlFindElement(tree, tree, NULL, "src", "foo.jpg",
MXML_DESCEND);
You can also iterate with the same function:
mxml_node_t *node;
for (node = mxmlFindElement(tree, tree, "name", NULL, NULL,
MXML_DESCEND);
node != NULL;
node = mxmlFindElement(node, tree, "name", NULL, NULL,
MXML_DESCEND))
{
... do something ...
}
Finally, once you are done with the XML data, use the
"mxmlDelete()" function to recursively free the memory that
is used for a particular node or the entire tree:
mxmlDelete(tree);
GETTING HELP AND REPORTING PROBLEMS
You can email me at "mxml@easysw.com" to report problems
and/or ask for help. Just don't expect an instant response,
as I get a *lot* of email...
LEGAL STUFF
The Mini-XML library is Copyright 2003-2005 by Michael Sweet.
This library is free software; you can redistribute it
and/or modify it under the terms of the GNU Library General
Public License as published by the Free Software Foundation;
either version 2 of the License, or (at your option) any
later version.
This library 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 Library General Public License for
more details.
You should have received a copy of the GNU Library General
Public License along with this library; if not, write to the
Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA
02139, USA.

View File

@ -1,69 +0,0 @@
/*
* "$Id: config.h.in 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Configuration file for Mini-XML, a small XML-like file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*/
/*
* Include necessary headers...
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
/*
* Version number...
*/
#define MXML_VERSION ""
/*
* Do we have the vsnprintf() function?
*/
#undef HAVE_VSNPRINTF
/*
* Do we have the strXXX() functions?
*/
#undef HAVE_STRDUP
/*
* Define prototypes for string functions as needed...
*/
# ifndef HAVE_STRDUP
extern char *mxml_strdup(const char *);
# define strdup mxml_strdup
# endif /* !HAVE_STRDUP */
extern char *mxml_strdupf(const char *, va_list);
# ifndef HAVE_VSNPRINTF
extern int mxml_vsnprintf(char *, size_t, const char *, va_list);
# define vsnprintf mxml_vsnprintf
# endif /* !HAVE_VSNPRINTF */
/*
* End of "$Id: config.h.in 22267 2006-04-24 17:11:45Z kpfleming $".
*/

File diff suppressed because it is too large Load Diff

View File

@ -1,343 +0,0 @@
dnl
dnl "$Id: configure.in 260 2010-04-27 19:11:06Z qwell $"
dnl
dnl Configuration script for Mini-XML, a small XML-like file parsing library.
dnl
dnl Copyright 2003-2009 by Michael Sweet.
dnl
dnl This program is free software; you can redistribute it and/or
dnl modify it under the terms of the GNU Library General Public
dnl License as published by the Free Software Foundation; either
dnl version 2, or (at your option) any later version.
dnl
dnl This program is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
dnl GNU General Public License for more details.
dnl
dnl Specify a source file from the distribution...
AC_INIT(mxml.h)
dnl Set the name of the config header file...
AC_CONFIG_HEADER(config.h)
dnl Version number...
VERSION=2.2.2
AC_SUBST(VERSION)
AC_DEFINE_UNQUOTED(MXML_VERSION, "Mini-XML v$VERSION")
dnl Clear default debugging options and set normal optimization by
dnl default unless the user asks for debugging specifically.
CFLAGS="${CFLAGS:=}"
CXXFLAGS="${CXXFLAGS:=}"
LDFLAGS="${LDFLAGS:=}"
AC_SUBST(LDFLAGS)
OPTIM=""
AC_SUBST(OPTIM)
AC_ARG_WITH(ansi, [ --with-ansi set full ANSI C mode, default=no],
use_ansi="$withval",
use_ansi="no")
AC_ARG_WITH(archflags, [ --with-archflags set additional architecture flags, default=none],
ARCHFLAGS="$withval",
ARCHFLAGS="")
AC_SUBST(ARCHFLAGS)
AC_ARG_ENABLE(debug, [ --enable-debug turn on debugging, default=no],
if eval "test x$enable_debug = xyes"; then
OPTIM="-g"
fi)
AC_ARG_WITH(docdir, [ --with-docdir set directory for documentation, default=${prefix}/share/doc/mxml],
docdir="$withval",
docdir="NONE")
AC_SUBST(docdir)
AC_ARG_WITH(vsnprintf, [ --with-vsnprintf use vsnprintf emulation functions, default=auto],
use_vsnprintf="$withval",
use_vsnprintf="no")
dnl Get the operating system and version number...
uname=`uname`
uversion=`uname -r | sed -e '1,$s/[[^0-9]]//g'`
if test x$uname = xIRIX64; then
uname="IRIX"
fi
dnl Checks for programs...
AC_PROG_CC
AC_PROG_CXX
AC_PROG_INSTALL
if test "$INSTALL" = "$ac_install_sh"; then
# Use full path to install-sh script...
INSTALL="`pwd`/install-sh -c"
fi
AC_PROG_RANLIB
AC_PATH_PROGS(AR,ar gar)
AC_PATH_PROG(CP,cp)
AC_PATH_PROG(LN,ln)
AC_PATH_PROG(MKDIR,mkdir)
AC_PATH_PROG(RM,rm)
if test -z $AR ; then
AC_MSG_ERROR('ar' binary is mandatory. Please either install the 'ar' binary or provide the path to configure with --with-ar=/path/to/ar)
fi
dnl Flags for "ar" command...
case "$uname" in
Darwin* | *BSD*)
ARFLAGS="-rcv"
;;
*)
ARFLAGS="crvs"
;;
esac
AC_SUBST(ARFLAGS)
dnl Inline functions...
AC_C_INLINE
dnl Checks for string functions.
if test "x$use_ansi" != xyes; then
AC_CHECK_FUNCS(strdup)
fi
if test "x$use_vsnprintf" != xyes; then
AC_CHECK_FUNCS(snprintf vsnprintf)
fi
dnl Check for "long long" support...
AC_CACHE_CHECK(for long long int, ac_cv_c_long_long,
[if test "$GCC" = yes; then
ac_cv_c_long_long=yes
else
AC_TRY_COMPILE(,[long long int i;],
ac_cv_c_long_long=yes,
ac_cv_c_long_long=no)
fi])
if test $ac_cv_c_long_long = yes; then
AC_DEFINE(HAVE_LONG_LONG)
fi
dnl Threading support
AC_ARG_ENABLE(threads, [ --enable-threads enable multi-threading support])
have_pthread=no
PTHREAD_FLAGS=""
PTHREAD_LIBS=""
if test "x$enable_threads" != xno; then
AC_CHECK_HEADER(pthread.h, AC_DEFINE(HAVE_PTHREAD_H))
if test x$ac_cv_header_pthread_h = xyes; then
dnl Check various threading options for the platforms we support
for flag in -lpthreads -lpthread -pthread; do
AC_MSG_CHECKING([for pthread_create using $flag])
SAVELIBS="$LIBS"
LIBS="$flag $LIBS"
AC_TRY_LINK([#include <pthread.h>],
[pthread_create(0, 0, 0, 0);],
have_pthread=yes)
AC_MSG_RESULT([$have_pthread])
LIBS="$SAVELIBS"
if test $have_pthread = yes; then
PTHREAD_FLAGS="-D_THREAD_SAFE -D_REENTRANT"
PTHREAD_LIBS="$flag"
# Solaris requires -D_POSIX_PTHREAD_SEMANTICS to
# be POSIX-compliant... :(
if test $uname = SunOS; then
PTHREAD_FLAGS="$PTHREAD_FLAGS -D_POSIX_PTHREAD_SEMANTICS"
fi
break
fi
done
fi
fi
AC_SUBST(PTHREAD_FLAGS)
AC_SUBST(PTHREAD_LIBS)
dnl Shared library support...
DSO="${DSO:=:}"
DSOFLAGS="${DSOFLAGS:=}"
AC_ARG_ENABLE(shared, [ --enable-shared turn on shared libraries, default=no])
if test x$enable_shared = xyes; then
AC_MSG_CHECKING(for shared library support)
PICFLAG=1
case "$uname" in
SunOS* | UNIX_S*)
AC_MSG_RESULT(yes)
LIBMXML="libmxml.so.1.4"
DSO="\$(CC)"
DSOFLAGS="$DSOFLAGS -Wl,-h,libmxml.so.1 -G -R\$(libdir) \$(OPTIM)"
LDFLAGS="$LDFLAGS -R\$(libdir)"
;;
HP-UX*)
AC_MSG_RESULT(yes)
LIBMXML="libmxml.sl.1"
DSO="ld"
DSOFLAGS="$DSOFLAGS -b -z +h libmxml.sl.1 +s +b \$(libdir)"
LDFLAGS="$LDFLAGS -Wl,+s,+b,\$(libdir)"
;;
IRIX)
AC_MSG_RESULT(yes)
LIBMXML="libmxml.so.1.4"
DSO="\$(CC)"
DSOFLAGS="$DSOFLAGS -Wl,-rpath,\$(libdir),-set_version,sgi1.0,-soname,libmxml.so.1 -shared \$(OPTIM)"
;;
OSF1* | Linux | GNU)
AC_MSG_RESULT(yes)
LIBMXML="libmxml.so.1.4"
DSO="\$(CC)"
DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-rpath,\$(libdir) -shared \$(OPTIM)"
LDFLAGS="$LDFLAGS -Wl,-rpath,\$(libdir)"
;;
*BSD*)
AC_MSG_RESULT(yes)
LIBMXML="libmxml.so.1.4"
DSO="\$(CC)"
DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-R\$(libdir) -shared \$(OPTIM)"
LDFLAGS="$LDFLAGS -Wl,-R\$(libdir)"
;;
Darwin*)
AC_MSG_RESULT(yes)
LIBMXML="libmxml.1.dylib"
DSO="\$(CC)"
DSOFLAGS="$DSOFLAGS \$(RC_CFLAGS) -dynamiclib -lc"
;;
*)
AC_MSG_RESULT(no)
AC_MSG_WARN(shared libraries not supported on this platform.)
PICFLAG=0
LIBMXML="libmxml.a"
;;
esac
else
PICFLAG=0
LIBMXML="libmxml.a"
fi
AC_SUBST(DSO)
AC_SUBST(DSOFLAGS)
AC_SUBST(LIBMXML)
AC_SUBST(PICFLAG)
dnl Add -Wall for GCC...
if test -n "$GCC"; then
CFLAGS="-Wall $CFLAGS"
if test "x$OPTIM" = x; then
OPTIM="-Os -g"
fi
if test "x$use_ansi" = xyes; then
CFLAGS="-ansi -pedantic $CFLAGS"
fi
if test $PICFLAG = 1 -a $uname != AIX; then
OPTIM="-fPIC $OPTIM"
fi
else
case $uname in
HP-UX*)
CFLAGS="-Ae $CFLAGS"
if test "x$OPTIM" = x; then
OPTIM="-O"
fi
OPTIM="+DAportable $OPTIM"
if test $PICFLAG = 1; then
OPTIM="+z $OPTIM"
fi
;;
UNIX_SVR* | SunOS*)
if test "x$OPTIM" = x; then
OPTIM="-O"
fi
if test $PICFLAG = 1; then
OPTIM="-KPIC $OPTIM"
fi
;;
*)
if test "x$OPTIM" = x; then
OPTIM="-O"
fi
;;
esac
fi
dnl Fix "prefix" variable if it hasn't been specified...
if test "$prefix" = "NONE"; then
prefix="/usr/local"
fi
dnl Fix "exec_prefix" variable if it hasn't been specified...
if test "$exec_prefix" = "NONE"; then
exec_prefix="$prefix"
fi
dnl Fix "docdir" variable if it hasn't been specified...
if test "$docdir" = "NONE"; then
docdir="$datadir/doc/mxml"
fi
dnl Fix "mandir" variable if it hasn't been specified...
if test "$mandir" = "\${prefix}/man" -a "$prefix" = "/usr"; then
case "$uname" in
*BSD* | Darwin* | Linux*)
# BSD, Darwin (MacOS X), and Linux
mandir="/usr/share/man"
;;
IRIX*)
# SGI IRIX
mandir="/usr/share/catman/u_man"
;;
*)
# All others
mandir="/usr/man"
;;
esac
fi
dnl pkg-config stuff...
if test "$includedir" != /usr/include; then
PC_CFLAGS="-I$includedir"
else
PC_CFLAGS=""
fi
if test "$libdir" != /usr/lib; then
PC_LIBS="-L$libdir -lmxml"
else
PC_LIBS="-lmxml"
fi
AC_SUBST(PC_CFLAGS)
AC_SUBST(PC_LIBS)
dnl Output the makefile, etc...
AC_OUTPUT(Makefile mxml.list mxml.pc)
dnl
dnl End of "$Id: configure.in 260 2010-04-27 19:11:06Z qwell $".
dnl

View File

@ -1,251 +0,0 @@
#!/bin/sh
#
# install - install a program, script, or datafile
# This comes from X11R5 (mit/util/scripts/install.sh).
#
# Copyright 1991 by the Massachusetts Institute of Technology
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation, and that the name of M.I.T. not be used in advertising or
# publicity pertaining to distribution of the software without specific,
# written prior permission. M.I.T. makes no representations about the
# suitability of this software for any purpose. It is provided "as is"
# without express or implied warranty.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# `make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch. It can only install one file at a time, a restriction
# shared with many OS's install programs.
# set DOITPROG to echo to test this script
# Don't use :- since 4.3BSD and earlier shells don't like it.
doit="${DOITPROG-}"
# put in absolute paths if you don't have them in your path; or use env. vars.
mvprog="${MVPROG-mv}"
cpprog="${CPPROG-cp}"
chmodprog="${CHMODPROG-chmod}"
chownprog="${CHOWNPROG-chown}"
chgrpprog="${CHGRPPROG-chgrp}"
stripprog="${STRIPPROG-strip}"
rmprog="${RMPROG-rm}"
mkdirprog="${MKDIRPROG-mkdir}"
transformbasename=""
transform_arg=""
instcmd="$mvprog"
chmodcmd="$chmodprog 0755"
chowncmd=""
chgrpcmd=""
stripcmd=""
rmcmd="$rmprog -f"
mvcmd="$mvprog"
src=""
dst=""
dir_arg=""
while [ x"$1" != x ]; do
case $1 in
-c) instcmd="$cpprog"
shift
continue;;
-d) dir_arg=true
shift
continue;;
-m) chmodcmd="$chmodprog $2"
shift
shift
continue;;
-o) chowncmd="$chownprog $2"
shift
shift
continue;;
-g) chgrpcmd="$chgrpprog $2"
shift
shift
continue;;
-s) stripcmd="$stripprog"
shift
continue;;
-t=*) transformarg=`echo $1 | sed 's/-t=//'`
shift
continue;;
-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
shift
continue;;
*) if [ x"$src" = x ]
then
src=$1
else
# this colon is to work around a 386BSD /bin/sh bug
:
dst=$1
fi
shift
continue;;
esac
done
if [ x"$src" = x ]
then
echo "install: no input file specified"
exit 1
else
:
fi
if [ x"$dir_arg" != x ]; then
dst=$src
src=""
if [ -d $dst ]; then
instcmd=:
chmodcmd=""
else
instcmd=$mkdirprog
fi
else
# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
# might cause directories to be created, which would be especially bad
# if $src (and thus $dsttmp) contains '*'.
if [ -f $src -o -d $src ]
then
:
else
echo "install: $src does not exist"
exit 1
fi
if [ x"$dst" = x ]
then
echo "install: no destination specified"
exit 1
else
:
fi
# If destination is a directory, append the input filename; if your system
# does not like double slashes in filenames, you may need to add some logic
if [ -d $dst ]
then
dst="$dst"/`basename $src`
else
:
fi
fi
## this sed command emulates the dirname command
dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
# Make sure that the destination directory exists.
# this part is taken from Noah Friedman's mkinstalldirs script
# Skip lots of stat calls in the usual case.
if [ ! -d "$dstdir" ]; then
defaultIFS='
'
IFS="${IFS-${defaultIFS}}"
oIFS="${IFS}"
# Some sh's can't handle IFS=/ for some reason.
IFS='%'
set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
IFS="${oIFS}"
pathcomp=''
while [ $# -ne 0 ] ; do
pathcomp="${pathcomp}${1}"
shift
if [ ! -d "${pathcomp}" ] ;
then
$mkdirprog "${pathcomp}"
else
:
fi
pathcomp="${pathcomp}/"
done
fi
if [ x"$dir_arg" != x ]
then
$doit $instcmd $dst &&
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else : ; fi &&
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else : ; fi &&
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else : ; fi &&
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else : ; fi
else
# If we're going to rename the final executable, determine the name now.
if [ x"$transformarg" = x ]
then
dstfile=`basename $dst`
else
dstfile=`basename $dst $transformbasename |
sed $transformarg`$transformbasename
fi
# don't allow the sed command to completely eliminate the filename
if [ x"$dstfile" = x ]
then
dstfile=`basename $dst`
else
:
fi
# Make a temp file name in the proper directory.
dsttmp=$dstdir/#inst.$$#
# Move or copy the file name to the temp name
$doit $instcmd $src $dsttmp &&
trap "rm -f ${dsttmp}" 0 &&
# and set any options; do chmod last to preserve setuid bits
# If any of these fail, we abort the whole thing. If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $instcmd $src $dsttmp" command.
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else :;fi &&
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else :;fi &&
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else :;fi &&
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else :;fi &&
# Now rename the file to the real destination.
$doit $rmcmd -f $dstdir/$dstfile &&
$doit $mvcmd $dsttmp $dstdir/$dstfile
fi &&
exit 0

View File

@ -1,181 +0,0 @@
/*
* "$Id: mxml-attr.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Attribute support code for Mini-XML, a small XML-like file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxmlElementGetAttr() - Get an attribute.
* mxmlElementSetAttr() - Set an attribute.
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml.h"
/*
* 'mxmlElementGetAttr()' - Get an attribute.
*
* This function returns NULL if the node is not an element or the
* named attribute does not exist.
*/
const char * /* O - Attribute value or NULL */
mxmlElementGetAttr(mxml_node_t *node, /* I - Element node */
const char *name) /* I - Name of attribute */
{
int i; /* Looping var */
mxml_attr_t *attr; /* Cirrent attribute */
#ifdef DEBUG
fprintf(stderr, "mxmlElementGetAttr(node=%p, name=\"%s\")\n",
node, name ? name : "(null)");
#endif /* DEBUG */
/*
* Range check input...
*/
if (!node || node->type != MXML_ELEMENT || !name)
return (NULL);
/*
* Look for the attribute...
*/
for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
i > 0;
i --, attr ++)
if (!strcmp(attr->name, name))
return (attr->value);
/*
* Didn't find attribute, so return NULL...
*/
return (NULL);
}
/*
* 'mxmlElementSetAttr()' - Set an attribute.
*
* If the named attribute already exists, the value of the attribute
* is replaced by the new string value. The string value is copied
* into the element node. This function does nothing if the node is
* not an element.
*/
void
mxmlElementSetAttr(mxml_node_t *node, /* I - Element node */
const char *name, /* I - Name of attribute */
const char *value) /* I - Attribute value */
{
int i; /* Looping var */
mxml_attr_t *attr; /* New attribute */
#ifdef DEBUG
fprintf(stderr, "mxmlElementSetAttr(node=%p, name=\"%s\", value=\"%s\")\n",
node, name ? name : "(null)", value ? value : "(null)");
#endif /* DEBUG */
/*
* Range check input...
*/
if (!node || node->type != MXML_ELEMENT || !name)
return;
/*
* Look for the attribute...
*/
for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
i > 0;
i --, attr ++)
if (!strcmp(attr->name, name))
{
/*
* Replace the attribute value and return...
*/
if (attr->value)
free(attr->value);
if (value)
{
if ((attr->value = strdup(value)) == NULL)
mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
name, node->value.element.name);
}
else
attr->value = NULL;
return;
}
/*
* Attribute not found, so add a new one...
*/
if (node->value.element.num_attrs == 0)
attr = malloc(sizeof(mxml_attr_t));
else
attr = realloc(node->value.element.attrs,
(node->value.element.num_attrs + 1) * sizeof(mxml_attr_t));
if (!attr)
{
mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
name, node->value.element.name);
return;
}
node->value.element.attrs = attr;
attr += node->value.element.num_attrs;
attr->name = strdup(name);
if (value)
attr->value = strdup(value);
else
attr->value = NULL;
if (!attr->name || (!attr->value && value))
{
if (attr->name)
free(attr->name);
if (attr->value)
free(attr->value);
mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
name, node->value.element.name);
return;
}
node->value.element.num_attrs ++;
}
/*
* End of "$Id: mxml-attr.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

View File

@ -1,472 +0,0 @@
/*
* "$Id: mxml-entity.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Character entity support code for Mini-XML, a small XML-like
* file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxmlEntityAddCallback() - Add a callback to convert entities to
* Unicode.
* mxmlEntityGetName() - Get the name that corresponds to the
* character value.
* mxmlEntityGetValue() - Get the character corresponding to a named
* entity.
* mxmlEntityRemoveCallback() - Remove a callback.
* default_callback() - Lookup standard (X)HTML entities.
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml.h"
/*
* Local functions...
*/
static int default_callback(const char *name);
/*
* Callback array...
*/
static int num_callbacks = 1;
static int (*callbacks[100])(const char *name) =
{
default_callback
};
/*
* 'mxmlEntityAddCallback()' - Add a callback to convert entities to Unicode.
*/
int /* O - 0 on success, -1 on failure */
mxmlEntityAddCallback(int (*cb)(const char *name))
/* I - Callback function to add */
{
if (num_callbacks < (int)(sizeof(callbacks) / sizeof(callbacks[0])))
{
callbacks[num_callbacks] = cb;
num_callbacks ++;
return (0);
}
else
{
mxml_error("Unable to add entity callback!");
return (-1);
}
}
/*
* 'mxmlEntityGetName()' - Get the name that corresponds to the character value.
*
* If val does not need to be represented by a named entity, NULL is returned.
*/
const char * /* O - Entity name or NULL */
mxmlEntityGetName(int val) /* I - Character value */
{
switch (val)
{
case '&' :
return ("amp");
case '<' :
return ("lt");
case '>' :
return ("gt");
case '\"' :
return ("quot");
default :
return (NULL);
}
}
/*
* 'mxmlEntityGetValue()' - Get the character corresponding to a named entity.
*
* The entity name can also be a numeric constant. -1 is returned if the
* name is not known.
*/
int /* O - Character value or -1 on error */
mxmlEntityGetValue(const char *name) /* I - Entity name */
{
int i; /* Looping var */
int ch; /* Character value */
for (i = 0; i < num_callbacks; i ++)
if ((ch = (callbacks[i])(name)) >= 0)
return (ch);
return (-1);
}
/*
* 'mxmlEntityRemoveCallback()' - Remove a callback.
*/
void
mxmlEntityRemoveCallback(int (*cb)(const char *name))
/* I - Callback function to remove */
{
int i; /* Looping var */
for (i = 0; i < num_callbacks; i ++)
if (cb == callbacks[i])
{
/*
* Remove the callback...
*/
num_callbacks --;
if (i < num_callbacks)
memmove(callbacks + i, callbacks + i + 1,
(num_callbacks - i) * sizeof(callbacks[0]));
return;
}
}
/*
* 'default_callback()' - Lookup standard (X)HTML entities.
*/
static int /* O - Unicode value or -1 */
default_callback(const char *name) /* I - Entity name */
{
int diff, /* Difference between names */
current, /* Current entity in search */
first, /* First entity in search */
last; /* Last entity in search */
static const struct
{
const char *name; /* Entity name */
int val; /* Character value */
} entities[] =
{
{ "AElig", 198 },
{ "Aacute", 193 },
{ "Acirc", 194 },
{ "Agrave", 192 },
{ "Alpha", 913 },
{ "Aring", 197 },
{ "Atilde", 195 },
{ "Auml", 196 },
{ "Beta", 914 },
{ "Ccedil", 199 },
{ "Chi", 935 },
{ "Dagger", 8225 },
{ "Delta", 916 },
{ "Dstrok", 208 },
{ "ETH", 208 },
{ "Eacute", 201 },
{ "Ecirc", 202 },
{ "Egrave", 200 },
{ "Epsilon", 917 },
{ "Eta", 919 },
{ "Euml", 203 },
{ "Gamma", 915 },
{ "Iacute", 205 },
{ "Icirc", 206 },
{ "Igrave", 204 },
{ "Iota", 921 },
{ "Iuml", 207 },
{ "Kappa", 922 },
{ "Lambda", 923 },
{ "Mu", 924 },
{ "Ntilde", 209 },
{ "Nu", 925 },
{ "OElig", 338 },
{ "Oacute", 211 },
{ "Ocirc", 212 },
{ "Ograve", 210 },
{ "Omega", 937 },
{ "Omicron", 927 },
{ "Oslash", 216 },
{ "Otilde", 213 },
{ "Ouml", 214 },
{ "Phi", 934 },
{ "Pi", 928 },
{ "Prime", 8243 },
{ "Psi", 936 },
{ "Rho", 929 },
{ "Scaron", 352 },
{ "Sigma", 931 },
{ "THORN", 222 },
{ "Tau", 932 },
{ "Theta", 920 },
{ "Uacute", 218 },
{ "Ucirc", 219 },
{ "Ugrave", 217 },
{ "Upsilon", 933 },
{ "Uuml", 220 },
{ "Xi", 926 },
{ "Yacute", 221 },
{ "Yuml", 376 },
{ "Zeta", 918 },
{ "aacute", 225 },
{ "acirc", 226 },
{ "acute", 180 },
{ "aelig", 230 },
{ "agrave", 224 },
{ "alefsym", 8501 },
{ "alpha", 945 },
{ "amp", '&' },
{ "and", 8743 },
{ "ang", 8736 },
{ "aring", 229 },
{ "asymp", 8776 },
{ "atilde", 227 },
{ "auml", 228 },
{ "bdquo", 8222 },
{ "beta", 946 },
{ "brkbar", 166 },
{ "brvbar", 166 },
{ "bull", 8226 },
{ "cap", 8745 },
{ "ccedil", 231 },
{ "cedil", 184 },
{ "cent", 162 },
{ "chi", 967 },
{ "circ", 710 },
{ "clubs", 9827 },
{ "cong", 8773 },
{ "copy", 169 },
{ "crarr", 8629 },
{ "cup", 8746 },
{ "curren", 164 },
{ "dArr", 8659 },
{ "dagger", 8224 },
{ "darr", 8595 },
{ "deg", 176 },
{ "delta", 948 },
{ "diams", 9830 },
{ "die", 168 },
{ "divide", 247 },
{ "eacute", 233 },
{ "ecirc", 234 },
{ "egrave", 232 },
{ "empty", 8709 },
{ "emsp", 8195 },
{ "ensp", 8194 },
{ "epsilon", 949 },
{ "equiv", 8801 },
{ "eta", 951 },
{ "eth", 240 },
{ "euml", 235 },
{ "euro", 8364 },
{ "exist", 8707 },
{ "fnof", 402 },
{ "forall", 8704 },
{ "frac12", 189 },
{ "frac14", 188 },
{ "frac34", 190 },
{ "frasl", 8260 },
{ "gamma", 947 },
{ "ge", 8805 },
{ "gt", '>' },
{ "hArr", 8660 },
{ "harr", 8596 },
{ "hearts", 9829 },
{ "hellip", 8230 },
{ "hibar", 175 },
{ "iacute", 237 },
{ "icirc", 238 },
{ "iexcl", 161 },
{ "igrave", 236 },
{ "image", 8465 },
{ "infin", 8734 },
{ "int", 8747 },
{ "iota", 953 },
{ "iquest", 191 },
{ "isin", 8712 },
{ "iuml", 239 },
{ "kappa", 954 },
{ "lArr", 8656 },
{ "lambda", 955 },
{ "lang", 9001 },
{ "laquo", 171 },
{ "larr", 8592 },
{ "lceil", 8968 },
{ "ldquo", 8220 },
{ "le", 8804 },
{ "lfloor", 8970 },
{ "lowast", 8727 },
{ "loz", 9674 },
{ "lrm", 8206 },
{ "lsaquo", 8249 },
{ "lsquo", 8216 },
{ "lt", '<' },
{ "macr", 175 },
{ "mdash", 8212 },
{ "micro", 181 },
{ "middot", 183 },
{ "minus", 8722 },
{ "mu", 956 },
{ "nabla", 8711 },
{ "nbsp", 160 },
{ "ndash", 8211 },
{ "ne", 8800 },
{ "ni", 8715 },
{ "not", 172 },
{ "notin", 8713 },
{ "nsub", 8836 },
{ "ntilde", 241 },
{ "nu", 957 },
{ "oacute", 243 },
{ "ocirc", 244 },
{ "oelig", 339 },
{ "ograve", 242 },
{ "oline", 8254 },
{ "omega", 969 },
{ "omicron", 959 },
{ "oplus", 8853 },
{ "or", 8744 },
{ "ordf", 170 },
{ "ordm", 186 },
{ "oslash", 248 },
{ "otilde", 245 },
{ "otimes", 8855 },
{ "ouml", 246 },
{ "para", 182 },
{ "part", 8706 },
{ "permil", 8240 },
{ "perp", 8869 },
{ "phi", 966 },
{ "pi", 960 },
{ "piv", 982 },
{ "plusmn", 177 },
{ "pound", 163 },
{ "prime", 8242 },
{ "prod", 8719 },
{ "prop", 8733 },
{ "psi", 968 },
{ "quot", '\"' },
{ "rArr", 8658 },
{ "radic", 8730 },
{ "rang", 9002 },
{ "raquo", 187 },
{ "rarr", 8594 },
{ "rceil", 8969 },
{ "rdquo", 8221 },
{ "real", 8476 },
{ "reg", 174 },
{ "rfloor", 8971 },
{ "rho", 961 },
{ "rlm", 8207 },
{ "rsaquo", 8250 },
{ "rsquo", 8217 },
{ "sbquo", 8218 },
{ "scaron", 353 },
{ "sdot", 8901 },
{ "sect", 167 },
{ "shy", 173 },
{ "sigma", 963 },
{ "sigmaf", 962 },
{ "sim", 8764 },
{ "spades", 9824 },
{ "sub", 8834 },
{ "sube", 8838 },
{ "sum", 8721 },
{ "sup", 8835 },
{ "sup1", 185 },
{ "sup2", 178 },
{ "sup3", 179 },
{ "supe", 8839 },
{ "szlig", 223 },
{ "tau", 964 },
{ "there4", 8756 },
{ "theta", 952 },
{ "thetasym", 977 },
{ "thinsp", 8201 },
{ "thorn", 254 },
{ "tilde", 732 },
{ "times", 215 },
{ "trade", 8482 },
{ "uArr", 8657 },
{ "uacute", 250 },
{ "uarr", 8593 },
{ "ucirc", 251 },
{ "ugrave", 249 },
{ "uml", 168 },
{ "upsih", 978 },
{ "upsilon", 965 },
{ "uuml", 252 },
{ "weierp", 8472 },
{ "xi", 958 },
{ "yacute", 253 },
{ "yen", 165 },
{ "yuml", 255 },
{ "zeta", 950 },
{ "zwj", 8205 },
{ "zwnj", 8204 }
};
/*
* Do a binary search for the named entity...
*/
first = 0;
last = (int)(sizeof(entities) / sizeof(entities[0]) - 1);
while ((last - first) > 1)
{
current = (first + last) / 2;
if ((diff = strcmp(name, entities[current].name)) == 0)
return (entities[current].val);
else if (diff < 0)
last = current;
else
first = current;
}
/*
* If we get here, there is a small chance that there is still
* a match; check first and last...
*/
if (!strcmp(name, entities[first].name))
return (entities[first].val);
else if (!strcmp(name, entities[last].name))
return (entities[last].val);
else
return (-1);
}
/*
* End of "$Id: mxml-entity.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

File diff suppressed because it is too large Load Diff

View File

@ -1,649 +0,0 @@
/*
* "$Id: mxml-index.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Index support code for Mini-XML, a small XML-like file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxmlIndexDelete() - Delete an index.
* mxmlIndexEnum() - Return the next node in the index.
* mxmlIndexFind() - Find the next matching node.
* mxmlIndexNew() - Create a new index.
* mxmlIndexReset() - Reset the enumeration/find pointer in the index and
* return the first node in the index.
* index_compare() - Compare two nodes.
* index_find() - Compare a node with index values.
* index_sort() - Sort the nodes in the index...
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml.h"
/*
* Sort functions...
*/
static int index_compare(mxml_index_t *ind, mxml_node_t *first,
mxml_node_t *second);
static int index_find(mxml_index_t *ind, const char *element,
const char *value, mxml_node_t *node);
static void index_sort(mxml_index_t *ind, int left, int right);
/*
* 'mxmlIndexDelete()' - Delete an index.
*/
void
mxmlIndexDelete(mxml_index_t *ind) /* I - Index to delete */
{
/*
* Range check input..
*/
if (!ind)
return;
/*
* Free memory...
*/
if (ind->attr)
free(ind->attr);
if (ind->alloc_nodes)
free(ind->nodes);
free(ind);
}
/*
* 'mxmlIndexEnum()' - Return the next node in the index.
*
* Nodes are returned in the sorted order of the index.
*/
mxml_node_t * /* O - Next node or NULL if there is none */
mxmlIndexEnum(mxml_index_t *ind) /* I - Index to enumerate */
{
/*
* Range check input...
*/
if (!ind)
return (NULL);
/*
* Return the next node...
*/
if (ind->cur_node < ind->num_nodes)
return (ind->nodes[ind->cur_node ++]);
else
return (NULL);
}
/*
* 'mxmlIndexFind()' - Find the next matching node.
*
* You should call mxmlIndexReset() prior to using this function for
* the first time with a particular set of "element" and "value"
* strings. Passing NULL for both "element" and "value" is equivalent
* to calling mxmlIndexEnum().
*/
mxml_node_t * /* O - Node or NULL if none found */
mxmlIndexFind(mxml_index_t *ind, /* I - Index to search */
const char *element, /* I - Element name to find, if any */
const char *value) /* I - Attribute value, if any */
{
int diff, /* Difference between names */
current, /* Current entity in search */
first, /* First entity in search */
last; /* Last entity in search */
#ifdef DEBUG
printf("mxmlIndexFind(ind=%p, element=\"%s\", value=\"%s\")\n",
ind, element ? element : "(null)", value ? value : "(null)");
#endif /* DEBUG */
/*
* Range check input...
*/
if (!ind || (!ind->attr && value))
{
#ifdef DEBUG
puts(" returning NULL...");
printf(" ind->attr=\"%s\"\n", ind->attr ? ind->attr : "(null)");
#endif /* DEBUG */
return (NULL);
}
/*
* If both element and value are NULL, just enumerate the nodes in the
* index...
*/
if (!element && !value)
return (mxmlIndexEnum(ind));
/*
* If there are no nodes in the index, return NULL...
*/
if (!ind->num_nodes)
{
#ifdef DEBUG
puts(" returning NULL...");
puts(" no nodes!");
#endif /* DEBUG */
return (NULL);
}
/*
* If cur_node == 0, then find the first matching node...
*/
if (ind->cur_node == 0)
{
/*
* Find the first node using a modified binary search algorithm...
*/
first = 0;
last = ind->num_nodes - 1;
#ifdef DEBUG
printf(" find first time, num_nodes=%d...\n", ind->num_nodes);
#endif /* DEBUG */
while ((last - first) > 1)
{
current = (first + last) / 2;
#ifdef DEBUG
printf(" first=%d, last=%d, current=%d\n", first, last, current);
#endif /* DEBUG */
if ((diff = index_find(ind, element, value, ind->nodes[current])) == 0)
{
/*
* Found a match, move back to find the first...
*/
#ifdef DEBUG
puts(" match!");
#endif /* DEBUG */
while (current > 0 &&
!index_find(ind, element, value, ind->nodes[current - 1]))
current --;
#ifdef DEBUG
printf(" returning first match=%d\n", current);
#endif /* DEBUG */
/*
* Return the first match and save the index to the next...
*/
ind->cur_node = current + 1;
return (ind->nodes[current]);
}
else if (diff < 0)
last = current;
else
first = current;
#ifdef DEBUG
printf(" diff=%d\n", diff);
#endif /* DEBUG */
}
/*
* If we get this far, then we found exactly 0 or 1 matches...
*/
for (current = first; current <= last; current ++)
if (!index_find(ind, element, value, ind->nodes[current]))
{
/*
* Found exactly one (or possibly two) match...
*/
#ifdef DEBUG
printf(" returning only match %d...\n", current);
#endif /* DEBUG */
ind->cur_node = current + 1;
return (ind->nodes[current]);
}
/*
* No matches...
*/
ind->cur_node = ind->num_nodes;
#ifdef DEBUG
puts(" returning NULL...");
#endif /* DEBUG */
return (NULL);
}
else if (ind->cur_node < ind->num_nodes &&
!index_find(ind, element, value, ind->nodes[ind->cur_node]))
{
/*
* Return the next matching node...
*/
#ifdef DEBUG
printf(" returning next match %d...\n", ind->cur_node);
#endif /* DEBUG */
return (ind->nodes[ind->cur_node ++]);
}
/*
* If we get this far, then we have no matches...
*/
ind->cur_node = ind->num_nodes;
#ifdef DEBUG
puts(" returning NULL...");
#endif /* DEBUG */
return (NULL);
}
/*
* 'mxmlIndexNew()' - Create a new index.
*
* The index will contain all nodes that contain the named element and/or
* attribute. If both "element" and "attr" are NULL, then the index will
* contain a sorted list of the elements in the node tree. Nodes are
* sorted by element name and optionally by attribute value if the "attr"
* argument is not NULL.
*/
mxml_index_t * /* O - New index */
mxmlIndexNew(mxml_node_t *node, /* I - XML node tree */
const char *element, /* I - Element to index or NULL for all */
const char *attr) /* I - Attribute to index or NULL for none */
{
mxml_index_t *ind; /* New index */
mxml_node_t *current, /* Current node in index */
**temp; /* Temporary node pointer array */
/*
* Range check input...
*/
#ifdef DEBUG
printf("mxmlIndexNew(node=%p, element=\"%s\", attr=\"%s\")\n",
node, element ? element : "(null)", attr ? attr : "(null)");
#endif /* DEBUG */
if (!node)
return (NULL);
/*
* Create a new index...
*/
if ((ind = calloc(1, sizeof(mxml_index_t))) == NULL)
{
mxml_error("Unable to allocate %d bytes for index - %s",
sizeof(mxml_index_t), strerror(errno));
return (NULL);
}
if (attr)
ind->attr = strdup(attr);
if (!element && !attr)
current = node;
else
current = mxmlFindElement(node, node, element, attr, NULL, MXML_DESCEND);
while (current)
{
if (ind->num_nodes >= ind->alloc_nodes)
{
if (!ind->alloc_nodes)
temp = malloc(64 * sizeof(mxml_node_t *));
else
temp = realloc(ind->nodes, (ind->alloc_nodes + 64) * sizeof(mxml_node_t *));
if (!temp)
{
/*
* Unable to allocate memory for the index, so abort...
*/
mxml_error("Unable to allocate %d bytes for index: %s",
(ind->alloc_nodes + 64) * sizeof(mxml_node_t *),
strerror(errno));
mxmlIndexDelete(ind);
return (NULL);
}
ind->nodes = temp;
ind->alloc_nodes += 64;
}
ind->nodes[ind->num_nodes ++] = current;
current = mxmlFindElement(current, node, element, attr, NULL, MXML_DESCEND);
}
/*
* Sort nodes based upon the search criteria...
*/
#ifdef DEBUG
{
int i; /* Looping var */
printf("%d node(s) in index.\n\n", ind->num_nodes);
if (attr)
{
printf("Node Address Element %s\n", attr);
puts("-------- -------- -------------- ------------------------------");
for (i = 0; i < ind->num_nodes; i ++)
printf("%8d %-8p %-14.14s %s\n", i, ind->nodes[i],
ind->nodes[i]->value.element.name,
mxmlElementGetAttr(ind->nodes[i], attr));
}
else
{
puts("Node Address Element");
puts("-------- -------- --------------");
for (i = 0; i < ind->num_nodes; i ++)
printf("%8d %-8p %s\n", i, ind->nodes[i],
ind->nodes[i]->value.element.name);
}
putchar('\n');
}
#endif /* DEBUG */
if (ind->num_nodes > 1)
index_sort(ind, 0, ind->num_nodes - 1);
#ifdef DEBUG
{
int i; /* Looping var */
puts("After sorting:\n");
if (attr)
{
printf("Node Address Element %s\n", attr);
puts("-------- -------- -------------- ------------------------------");
for (i = 0; i < ind->num_nodes; i ++)
printf("%8d %-8p %-14.14s %s\n", i, ind->nodes[i],
ind->nodes[i]->value.element.name,
mxmlElementGetAttr(ind->nodes[i], attr));
}
else
{
puts("Node Address Element");
puts("-------- -------- --------------");
for (i = 0; i < ind->num_nodes; i ++)
printf("%8d %-8p %s\n", i, ind->nodes[i],
ind->nodes[i]->value.element.name);
}
putchar('\n');
}
#endif /* DEBUG */
/*
* Return the new index...
*/
return (ind);
}
/*
* 'mxmlIndexReset()' - Reset the enumeration/find pointer in the index and
* return the first node in the index.
*
* This function should be called prior to using mxmlIndexEnum() or
* mxmlIndexFind() for the first time.
*/
mxml_node_t * /* O - First node or NULL if there is none */
mxmlIndexReset(mxml_index_t *ind) /* I - Index to reset */
{
#ifdef DEBUG
printf("mxmlIndexReset(ind=%p)\n", ind);
#endif /* DEBUG */
/*
* Range check input...
*/
if (!ind)
return (NULL);
/*
* Set the index to the first element...
*/
ind->cur_node = 0;
/*
* Return the first node...
*/
if (ind->num_nodes)
return (ind->nodes[0]);
else
return (NULL);
}
/*
* 'index_compare()' - Compare two nodes.
*/
static int /* O - Result of comparison */
index_compare(mxml_index_t *ind, /* I - Index */
mxml_node_t *first, /* I - First node */
mxml_node_t *second) /* I - Second node */
{
int diff; /* Difference */
/*
* Check the element name...
*/
if ((diff = strcmp(first->value.element.name,
second->value.element.name)) != 0)
return (diff);
/*
* Check the attribute value...
*/
if (ind->attr)
{
if ((diff = strcmp(mxmlElementGetAttr(first, ind->attr),
mxmlElementGetAttr(second, ind->attr))) != 0)
return (diff);
}
/*
* No difference, return 0...
*/
return (0);
}
/*
* 'index_find()' - Compare a node with index values.
*/
static int /* O - Result of comparison */
index_find(mxml_index_t *ind, /* I - Index */
const char *element, /* I - Element name or NULL */
const char *value, /* I - Attribute value or NULL */
mxml_node_t *node) /* I - Node */
{
int diff; /* Difference */
/*
* Check the element name...
*/
if (element)
{
if ((diff = strcmp(element, node->value.element.name)) != 0)
return (diff);
}
/*
* Check the attribute value...
*/
if (value)
{
if ((diff = strcmp(value, mxmlElementGetAttr(node, ind->attr))) != 0)
return (diff);
}
/*
* No difference, return 0...
*/
return (0);
}
/*
* 'index_sort()' - Sort the nodes in the index...
*
* This function implements the classic quicksort algorithm...
*/
static void
index_sort(mxml_index_t *ind, /* I - Index to sort */
int left, /* I - Left node in partition */
int right) /* I - Right node in partition */
{
mxml_node_t *pivot, /* Pivot node */
*temp; /* Swap node */
int templ, /* Temporary left node */
tempr; /* Temporary right node */
/*
* Loop until we have sorted all the way to the right...
*/
do
{
/*
* Sort the pivot in the current partition...
*/
pivot = ind->nodes[left];
for (templ = left, tempr = right; templ < tempr;)
{
/*
* Move left while left node <= pivot node...
*/
while ((templ < right) &&
index_compare(ind, ind->nodes[templ], pivot) <= 0)
templ ++;
/*
* Move right while right node > pivot node...
*/
while ((tempr > left) &&
index_compare(ind, ind->nodes[tempr], pivot) > 0)
tempr --;
/*
* Swap nodes if needed...
*/
if (templ < tempr)
{
temp = ind->nodes[templ];
ind->nodes[templ] = ind->nodes[tempr];
ind->nodes[tempr] = temp;
}
}
/*
* When we get here, the right (tempr) node is the new position for the
* pivot node...
*/
if (index_compare(ind, pivot, ind->nodes[tempr]) > 0)
{
ind->nodes[left] = ind->nodes[tempr];
ind->nodes[tempr] = pivot;
}
/*
* Recursively sort the left partition as needed...
*/
if (left < (tempr - 1))
index_sort(ind, left, tempr - 1);
}
while (right > (left = tempr + 1));
}
/*
* End of "$Id: mxml-index.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

View File

@ -1,664 +0,0 @@
/*
* "$Id: mxml-node.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Node support code for Mini-XML, a small XML-like file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxmlAdd() - Add a node to a tree.
* mxmlDelete() - Delete a node and all of its children.
* mxmlNewElement() - Create a new element node.
* mxmlNewInteger() - Create a new integer node.
* mxmlNewOpaque() - Create a new opaque string.
* mxmlNewReal() - Create a new real number node.
* mxmlNewText() - Create a new text fragment node.
* mxmlNewTextf() - Create a new formatted text fragment node.
* mxmlRemove() - Remove a node from its parent.
* mxml_new() - Create a new node.
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml.h"
/*
* Local functions...
*/
static mxml_node_t *mxml_new(mxml_node_t *parent, mxml_type_t type);
/*
* 'mxmlAdd()' - Add a node to a tree.
*
* Adds the specified node to the parent. If the child argument is not
* NULL, puts the new node before or after the specified child depending
* on the value of the where argument. If the child argument is NULL,
* puts the new node at the beginning of the child list (MXML_ADD_BEFORE)
* or at the end of the child list (MXML_ADD_AFTER). The constant
* MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.
*/
void
mxmlAdd(mxml_node_t *parent, /* I - Parent node */
int where, /* I - Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER */
mxml_node_t *child, /* I - Child node for where or MXML_ADD_TO_PARENT */
mxml_node_t *node) /* I - Node to add */
{
#ifdef DEBUG
fprintf(stderr, "mxmlAdd(parent=%p, where=%d, child=%p, node=%p)\n", parent,
where, child, node);
#endif /* DEBUG */
/*
* Range check input...
*/
if (!parent || !node)
return;
#if DEBUG > 1
fprintf(stderr, " BEFORE: node->parent=%p\n", node->parent);
if (parent)
{
fprintf(stderr, " BEFORE: parent->child=%p\n", parent->child);
fprintf(stderr, " BEFORE: parent->last_child=%p\n", parent->last_child);
fprintf(stderr, " BEFORE: parent->prev=%p\n", parent->prev);
fprintf(stderr, " BEFORE: parent->next=%p\n", parent->next);
}
#endif /* DEBUG > 1 */
/*
* Remove the node from any existing parent...
*/
if (node->parent)
mxmlRemove(node);
/*
* Reset pointers...
*/
node->parent = parent;
switch (where)
{
case MXML_ADD_BEFORE :
if (!child || child == parent->child || child->parent != parent)
{
/*
* Insert as first node under parent...
*/
node->next = parent->child;
if (parent->child)
parent->child->prev = node;
else
parent->last_child = node;
parent->child = node;
}
else
{
/*
* Insert node before this child...
*/
node->next = child;
node->prev = child->prev;
if (child->prev)
child->prev->next = node;
else
parent->child = node;
child->prev = node;
}
break;
case MXML_ADD_AFTER :
if (!child || child == parent->last_child || child->parent != parent)
{
/*
* Insert as last node under parent...
*/
node->parent = parent;
node->prev = parent->last_child;
if (parent->last_child)
parent->last_child->next = node;
else
parent->child = node;
parent->last_child = node;
}
else
{
/*
* Insert node after this child...
*/
node->prev = child;
node->next = child->next;
if (child->next)
child->next->prev = node;
else
parent->last_child = node;
child->next = node;
}
break;
}
#if DEBUG > 1
fprintf(stderr, " AFTER: node->parent=%p\n", node->parent);
if (parent)
{
fprintf(stderr, " AFTER: parent->child=%p\n", parent->child);
fprintf(stderr, " AFTER: parent->last_child=%p\n", parent->last_child);
fprintf(stderr, " AFTER: parent->prev=%p\n", parent->prev);
fprintf(stderr, " AFTER: parent->next=%p\n", parent->next);
}
#endif /* DEBUG > 1 */
}
/*
* 'mxmlDelete()' - Delete a node and all of its children.
*
* If the specified node has a parent, this function first removes the
* node from its parent using the mxmlRemove() function.
*/
void
mxmlDelete(mxml_node_t *node) /* I - Node to delete */
{
int i; /* Looping var */
#ifdef DEBUG
fprintf(stderr, "mxmlDelete(node=%p)\n", node);
#endif /* DEBUG */
/*
* Range check input...
*/
if (!node)
return;
/*
* Remove the node from its parent, if any...
*/
mxmlRemove(node);
/*
* Delete children...
*/
while (node->child)
mxmlDelete(node->child);
/*
* Now delete any node data...
*/
switch (node->type)
{
case MXML_ELEMENT :
if (node->value.element.name)
free(node->value.element.name);
if (node->value.element.num_attrs)
{
for (i = 0; i < node->value.element.num_attrs; i ++)
{
if (node->value.element.attrs[i].name)
free(node->value.element.attrs[i].name);
if (node->value.element.attrs[i].value)
free(node->value.element.attrs[i].value);
}
free(node->value.element.attrs);
}
break;
case MXML_INTEGER :
/* Nothing to do */
break;
case MXML_OPAQUE :
if (node->value.opaque)
free(node->value.opaque);
break;
case MXML_REAL :
/* Nothing to do */
break;
case MXML_TEXT :
if (node->value.text.string)
free(node->value.text.string);
break;
case MXML_CUSTOM :
if (node->value.custom.data &&
node->value.custom.destroy)
(*(node->value.custom.destroy))(node->value.custom.data);
break;
}
/*
* Free this node...
*/
free(node);
}
/*
* 'mxmlNewCustom()' - Create a new custom data node.
*
* The new custom node is added to the end of the specified parent's child
* list. The constant MXML_NO_PARENT can be used to specify that the new
* element node has no parent. NULL can be passed when the data in the
* node is not dynamically allocated or is separately managed.
*/
mxml_node_t * /* O - New node */
mxmlNewCustom(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
void *data, /* I - Pointer to data */
void (*destroy)(void *))
/* I - Function to destroy data */
{
mxml_node_t *node; /* New node */
#ifdef DEBUG
fprintf(stderr, "mxmlNewCustom(parent=%p, data=%p, destroy=%p)\n", parent,
data, destroy);
#endif /* DEBUG */
/*
* Create the node and set the value...
*/
if ((node = mxml_new(parent, MXML_CUSTOM)) != NULL)
{
node->value.custom.data = data;
node->value.custom.destroy = destroy;
}
return (node);
}
/*
* 'mxmlNewElement()' - Create a new element node.
*
* The new element node is added to the end of the specified parent's child
* list. The constant MXML_NO_PARENT can be used to specify that the new
* element node has no parent.
*/
mxml_node_t * /* O - New node */
mxmlNewElement(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
const char *name) /* I - Name of element */
{
mxml_node_t *node; /* New node */
#ifdef DEBUG
fprintf(stderr, "mxmlNewElement(parent=%p, name=\"%s\")\n", parent,
name ? name : "(null)");
#endif /* DEBUG */
/*
* Range check input...
*/
if (!name)
return (NULL);
/*
* Create the node and set the element name...
*/
if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
node->value.element.name = strdup(name);
return (node);
}
/*
* 'mxmlNewInteger()' - Create a new integer node.
*
* The new integer node is added to the end of the specified parent's child
* list. The constant MXML_NO_PARENT can be used to specify that the new
* integer node has no parent.
*/
mxml_node_t * /* O - New node */
mxmlNewInteger(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
int integer) /* I - Integer value */
{
mxml_node_t *node; /* New node */
#ifdef DEBUG
fprintf(stderr, "mxmlNewInteger(parent=%p, integer=%d)\n", parent, integer);
#endif /* DEBUG */
/*
* Create the node and set the element name...
*/
if ((node = mxml_new(parent, MXML_INTEGER)) != NULL)
node->value.integer = integer;
return (node);
}
/*
* 'mxmlNewOpaque()' - Create a new opaque string.
*
* The new opaque node is added to the end of the specified parent's child
* list. The constant MXML_NO_PARENT can be used to specify that the new
* opaque node has no parent. The opaque string must be nul-terminated and
* is copied into the new node.
*/
mxml_node_t * /* O - New node */
mxmlNewOpaque(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
const char *opaque) /* I - Opaque string */
{
mxml_node_t *node; /* New node */
#ifdef DEBUG
fprintf(stderr, "mxmlNewOpaque(parent=%p, opaque=\"%s\")\n", parent,
opaque ? opaque : "(null)");
#endif /* DEBUG */
/*
* Range check input...
*/
if (!opaque)
return (NULL);
/*
* Create the node and set the element name...
*/
if ((node = mxml_new(parent, MXML_OPAQUE)) != NULL)
node->value.opaque = strdup(opaque);
return (node);
}
/*
* 'mxmlNewReal()' - Create a new real number node.
*
* The new real number node is added to the end of the specified parent's
* child list. The constant MXML_NO_PARENT can be used to specify that
* the new real number node has no parent.
*/
mxml_node_t * /* O - New node */
mxmlNewReal(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
double real) /* I - Real number value */
{
mxml_node_t *node; /* New node */
#ifdef DEBUG
fprintf(stderr, "mxmlNewReal(parent=%p, real=%g)\n", parent, real);
#endif /* DEBUG */
/*
* Create the node and set the element name...
*/
if ((node = mxml_new(parent, MXML_REAL)) != NULL)
node->value.real = real;
return (node);
}
/*
* 'mxmlNewText()' - Create a new text fragment node.
*
* The new text node is added to the end of the specified parent's child
* list. The constant MXML_NO_PARENT can be used to specify that the new
* text node has no parent. The whitespace parameter is used to specify
* whether leading whitespace is present before the node. The text
* string must be nul-terminated and is copied into the new node.
*/
mxml_node_t * /* O - New node */
mxmlNewText(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
const char *string) /* I - String */
{
mxml_node_t *node; /* New node */
#ifdef DEBUG
fprintf(stderr, "mxmlNewText(parent=%p, whitespace=%d, string=\"%s\")\n",
parent, whitespace, string ? string : "(null)");
#endif /* DEBUG */
/*
* Range check input...
*/
if (!string)
return (NULL);
/*
* Create the node and set the text value...
*/
if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
{
node->value.text.whitespace = whitespace;
node->value.text.string = strdup(string);
}
return (node);
}
/*
* 'mxmlNewTextf()' - Create a new formatted text fragment node.
*
* The new text node is added to the end of the specified parent's child
* list. The constant MXML_NO_PARENT can be used to specify that the new
* text node has no parent. The whitespace parameter is used to specify
* whether leading whitespace is present before the node. The format
* string must be nul-terminated and is formatted into the new node.
*/
mxml_node_t * /* O - New node */
mxmlNewTextf(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
const char *format, /* I - Printf-style frmat string */
...) /* I - Additional args as needed */
{
mxml_node_t *node; /* New node */
va_list ap; /* Pointer to arguments */
#ifdef DEBUG
fprintf(stderr, "mxmlNewTextf(parent=%p, whitespace=%d, format=\"%s\", ...)\n",
parent, whitespace, format ? format : "(null)");
#endif /* DEBUG */
/*
* Range check input...
*/
if (!format)
return (NULL);
/*
* Create the node and set the text value...
*/
if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
{
va_start(ap, format);
node->value.text.whitespace = whitespace;
node->value.text.string = mxml_strdupf(format, ap);
va_end(ap);
}
return (node);
}
/*
* 'mxmlRemove()' - Remove a node from its parent.
*
* Does not free memory used by the node - use mxmlDelete() for that.
* This function does nothing if the node has no parent.
*/
void
mxmlRemove(mxml_node_t *node) /* I - Node to remove */
{
#ifdef DEBUG
fprintf(stderr, "mxmlRemove(node=%p)\n", node);
#endif /* DEBUG */
/*
* Range check input...
*/
if (!node || !node->parent)
return;
/*
* Remove from parent...
*/
#if DEBUG > 1
fprintf(stderr, " BEFORE: node->parent=%p\n", node->parent);
if (node->parent)
{
fprintf(stderr, " BEFORE: node->parent->child=%p\n", node->parent->child);
fprintf(stderr, " BEFORE: node->parent->last_child=%p\n", node->parent->last_child);
}
fprintf(stderr, " BEFORE: node->child=%p\n", node->child);
fprintf(stderr, " BEFORE: node->last_child=%p\n", node->last_child);
fprintf(stderr, " BEFORE: node->prev=%p\n", node->prev);
fprintf(stderr, " BEFORE: node->next=%p\n", node->next);
#endif /* DEBUG > 1 */
if (node->prev)
node->prev->next = node->next;
else
node->parent->child = node->next;
if (node->next)
node->next->prev = node->prev;
else
node->parent->last_child = node->prev;
node->parent = NULL;
node->prev = NULL;
node->next = NULL;
#if DEBUG > 1
fprintf(stderr, " AFTER: node->parent=%p\n", node->parent);
if (node->parent)
{
fprintf(stderr, " AFTER: node->parent->child=%p\n", node->parent->child);
fprintf(stderr, " AFTER: node->parent->last_child=%p\n", node->parent->last_child);
}
fprintf(stderr, " AFTER: node->child=%p\n", node->child);
fprintf(stderr, " AFTER: node->last_child=%p\n", node->last_child);
fprintf(stderr, " AFTER: node->prev=%p\n", node->prev);
fprintf(stderr, " AFTER: node->next=%p\n", node->next);
#endif /* DEBUG > 1 */
}
/*
* 'mxml_new()' - Create a new node.
*/
static mxml_node_t * /* O - New node */
mxml_new(mxml_node_t *parent, /* I - Parent node */
mxml_type_t type) /* I - Node type */
{
mxml_node_t *node; /* New node */
#if DEBUG > 1
fprintf(stderr, "mxml_new(parent=%p, type=%d)\n", parent, type);
#endif /* DEBUG > 1 */
/*
* Allocate memory for the node...
*/
if ((node = calloc(1, sizeof(mxml_node_t))) == NULL)
{
#if DEBUG > 1
fputs(" returning NULL\n", stderr);
#endif /* DEBUG > 1 */
return (NULL);
}
#if DEBUG > 1
fprintf(stderr, " returning %p\n", node);
#endif /* DEBUG > 1 */
/*
* Set the node type...
*/
node->type = type;
/*
* Add to the parent if present...
*/
if (parent)
mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
/*
* Return the new node...
*/
return (node);
}
/*
* End of "$Id: mxml-node.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

View File

@ -1,128 +0,0 @@
/*
* "$Id: mxml-private.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Private functions for Mini-XML, a small XML-like file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxml_error() - Display an error message.
* mxml_integer_cb() - Default callback for integer values.
* mxml_opaque_cb() - Default callback for opaque values.
* mxml_real_cb() - Default callback for real number values.
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml.h"
/*
* Error callback function...
*/
void (*mxml_error_cb)(const char *) = NULL;
/*
* 'mxml_error()' - Display an error message.
*/
void
mxml_error(const char *format, /* I - Printf-style format string */
...) /* I - Additional arguments as needed */
{
va_list ap; /* Pointer to arguments */
char *s; /* Message string */
/*
* Range check input...
*/
if (!format)
return;
/*
* Format the error message string...
*/
va_start(ap, format);
s = mxml_strdupf(format, ap);
va_end(ap);
/*
* And then display the error message...
*/
if (mxml_error_cb)
(*mxml_error_cb)(s);
else
fprintf(stderr, "mxml: %s\n", s);
/*
* Free the string...
*/
free(s);
}
/*
* 'mxml_integer_cb()' - Default callback for integer values.
*/
mxml_type_t /* O - Node type */
mxml_integer_cb(mxml_node_t *node) /* I - Current node */
{
(void)node;
return (MXML_INTEGER);
}
/*
* 'mxml_opaque_cb()' - Default callback for opaque values.
*/
mxml_type_t /* O - Node type */
mxml_opaque_cb(mxml_node_t *node) /* I - Current node */
{
(void)node;
return (MXML_OPAQUE);
}
/*
* 'mxml_real_cb()' - Default callback for real number values.
*/
mxml_type_t /* O - Node type */
mxml_real_cb(mxml_node_t *node) /* I - Current node */
{
(void)node;
return (MXML_REAL);
}
/*
* End of "$Id: mxml-private.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

View File

@ -1,199 +0,0 @@
/*
* "$Id: mxml-search.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Search/navigation functions for Mini-XML, a small XML-like file
* parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxmlFindElement() - Find the named element.
* mxmlWalkNext() - Walk to the next logical node in the tree.
* mxmlWalkPrev() - Walk to the previous logical node in the tree.
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml.h"
/*
* 'mxmlFindElement()' - Find the named element.
*
* The search is constrained by the name, attribute name, and value; any
* NULL names or values are treated as wildcards, so different kinds of
* searches can be implemented by looking for all elements of a given name
* or all elements with a specific attribute. The descend argument determines
* whether the search descends into child nodes; normally you will use
* MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find
* additional direct descendents of the node. The top node argument
* constrains the search to a particular node's children.
*/
mxml_node_t * /* O - Element node or NULL */
mxmlFindElement(mxml_node_t *node, /* I - Current node */
mxml_node_t *top, /* I - Top node */
const char *name, /* I - Element name or NULL for any */
const char *attr, /* I - Attribute name, or NULL for none */
const char *value, /* I - Attribute value, or NULL for any */
int descend) /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
{
const char *temp; /* Current attribute value */
/*
* Range check input...
*/
if (!node || !top || (!attr && value))
return (NULL);
/*
* Start with the next node...
*/
node = mxmlWalkNext(node, top, descend);
/*
* Loop until we find a matching element...
*/
while (node != NULL)
{
/*
* See if this node matches...
*/
if (node->type == MXML_ELEMENT &&
node->value.element.name &&
(!name || !strcmp(node->value.element.name, name)))
{
/*
* See if we need to check for an attribute...
*/
if (!attr)
return (node); /* No attribute search, return it... */
/*
* Check for the attribute...
*/
if ((temp = mxmlElementGetAttr(node, attr)) != NULL)
{
/*
* OK, we have the attribute, does it match?
*/
if (!value || !strcmp(value, temp))
return (node); /* Yes, return it... */
}
}
/*
* No match, move on to the next node...
*/
if (descend == MXML_DESCEND)
node = mxmlWalkNext(node, top, MXML_DESCEND);
else
node = node->next;
}
return (NULL);
}
/*
* 'mxmlWalkNext()' - Walk to the next logical node in the tree.
*
* The descend argument controls whether the first child is considered
* to be the next node. The top node argument constrains the walk to
* the node's children.
*/
mxml_node_t * /* O - Next node or NULL */
mxmlWalkNext(mxml_node_t *node, /* I - Current node */
mxml_node_t *top, /* I - Top node */
int descend) /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
{
if (!node)
return (NULL);
else if (node->child && descend)
return (node->child);
else if (node->next)
return (node->next);
else if (node->parent && node->parent != top)
{
node = node->parent;
while (!node->next)
if (node->parent == top || !node->parent)
return (NULL);
else
node = node->parent;
return (node->next);
}
else
return (NULL);
}
/*
* 'mxmlWalkPrev()' - Walk to the previous logical node in the tree.
*
* The descend argument controls whether the previous node's last child
* is considered to be the previous node. The top node argument constrains
* the walk to the node's children.
*/
mxml_node_t * /* O - Previous node or NULL */
mxmlWalkPrev(mxml_node_t *node, /* I - Current node */
mxml_node_t *top, /* I - Top node */
int descend) /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
{
if (!node)
return (NULL);
else if (node->prev)
{
if (node->prev->last_child && descend)
{
/*
* Find the last child under the previous node...
*/
node = node->prev->last_child;
while (node->last_child)
node = node->last_child;
return (node);
}
else
return (node->prev);
}
else if (node->parent != top)
return (node->parent);
else
return (NULL);
}
/*
* End of "$Id: mxml-search.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

View File

@ -1,257 +0,0 @@
/*
* "$Id: mxml-set.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* Node set functions for Mini-XML, a small XML-like file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxmlSetElement() - Set the name of an element node.
* mxmlSetInteger() - Set the value of an integer node.
* mxmlSetOpaque() - Set the value of an opaque node.
* mxmlSetReal() - Set the value of a real number node.
* mxmlSetText() - Set the value of a text node.
* mxmlSetTextf() - Set the value of a text node to a formatted string.
*/
/*
* Include necessary headers...
*/
#include "config.h"
#include "mxml.h"
/*
* 'mxmlSetCustom()' - Set the data and destructor of a custom data node.
*
* The node is not changed if it is not a custom node.
*/
int /* O - 0 on success, -1 on failure */
mxmlSetCustom(mxml_node_t *node, /* I - Node to set */
void *data, /* I - New data pointer */
void (*destroy)(void *))
/* I - New destructor function */
{
/*
* Range check input...
*/
if (!node || node->type != MXML_CUSTOM)
return (-1);
/*
* Free any old element value and set the new value...
*/
if (node->value.custom.data && node->value.custom.destroy)
(*(node->value.custom.destroy))(node->value.custom.data);
node->value.custom.data = data;
node->value.custom.destroy = destroy;
return (0);
}
/*
* 'mxmlSetElement()' - Set the name of an element node.
*
* The node is not changed if it is not an element node.
*/
int /* O - 0 on success, -1 on failure */
mxmlSetElement(mxml_node_t *node, /* I - Node to set */
const char *name) /* I - New name string */
{
/*
* Range check input...
*/
if (!node || node->type != MXML_ELEMENT || !name)
return (-1);
/*
* Free any old element value and set the new value...
*/
if (node->value.element.name)
free(node->value.element.name);
node->value.element.name = strdup(name);
return (0);
}
/*
* 'mxmlSetInteger()' - Set the value of an integer node.
*
* The node is not changed if it is not an integer node.
*/
int /* O - 0 on success, -1 on failure */
mxmlSetInteger(mxml_node_t *node, /* I - Node to set */
int integer) /* I - Integer value */
{
/*
* Range check input...
*/
if (!node || node->type != MXML_INTEGER)
return (-1);
/*
* Set the new value and return...
*/
node->value.integer = integer;
return (0);
}
/*
* 'mxmlSetOpaque()' - Set the value of an opaque node.
*
* The node is not changed if it is not an opaque node.
*/
int /* O - 0 on success, -1 on failure */
mxmlSetOpaque(mxml_node_t *node, /* I - Node to set */
const char *opaque) /* I - Opaque string */
{
/*
* Range check input...
*/
if (!node || node->type != MXML_OPAQUE || !opaque)
return (-1);
/*
* Free any old opaque value and set the new value...
*/
if (node->value.opaque)
free(node->value.opaque);
node->value.opaque = strdup(opaque);
return (0);
}
/*
* 'mxmlSetReal()' - Set the value of a real number node.
*
* The node is not changed if it is not a real number node.
*/
int /* O - 0 on success, -1 on failure */
mxmlSetReal(mxml_node_t *node, /* I - Node to set */
double real) /* I - Real number value */
{
/*
* Range check input...
*/
if (!node || node->type != MXML_REAL)
return (-1);
/*
* Set the new value and return...
*/
node->value.real = real;
return (0);
}
/*
* 'mxmlSetText()' - Set the value of a text node.
*
* The node is not changed if it is not a text node.
*/
int /* O - 0 on success, -1 on failure */
mxmlSetText(mxml_node_t *node, /* I - Node to set */
int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
const char *string) /* I - String */
{
/*
* Range check input...
*/
if (!node || node->type != MXML_TEXT || !string)
return (-1);
/*
* Free any old string value and set the new value...
*/
if (node->value.text.string)
free(node->value.text.string);
node->value.text.whitespace = whitespace;
node->value.text.string = strdup(string);
return (0);
}
/*
* 'mxmlSetTextf()' - Set the value of a text node to a formatted string.
*
* The node is not changed if it is not a text node.
*/
int /* O - 0 on success, -1 on failure */
mxmlSetTextf(mxml_node_t *node, /* I - Node to set */
int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
const char *format, /* I - Printf-style format string */
...) /* I - Additional arguments as needed */
{
va_list ap; /* Pointer to arguments */
/*
* Range check input...
*/
if (!node || node->type != MXML_TEXT || !format)
return (-1);
/*
* Free any old string value and set the new value...
*/
if (node->value.text.string)
free(node->value.text.string);
va_start(ap, format);
node->value.text.whitespace = whitespace;
node->value.text.string = mxml_strdupf(format, ap);
va_end(ap);
return (0);
}
/*
* End of "$Id: mxml-set.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

View File

@ -1,377 +0,0 @@
/*
* "$Id: mxml-string.c 22267 2006-04-24 17:11:45Z kpfleming $"
*
* String functions for Mini-XML, a small XML-like file parsing library.
*
* Copyright 2003-2005 by Michael Sweet.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2, 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.
*
* Contents:
*
* mxml_strdup() - Duplicate a string.
* mxml_strdupf() - Format and duplicate a string.
* mxml_vsnprintf() - Format a string into a fixed size buffer.
*/
/*
* Include necessary headers...
*/
#include "config.h"
/*
* 'mxml_strdup()' - Duplicate a string.
*/
#ifndef HAVE_STRDUP
char * /* O - New string pointer */
mxml_strdup(const char *s) /* I - String to duplicate */
{
char *t; /* New string pointer */
if (s == NULL)
return (NULL);
if ((t = malloc(strlen(s) + 1)) == NULL)
return (NULL);
return (strcpy(t, s));
}
#endif /* !HAVE_STRDUP */
/*
* 'mxml_strdupf()' - Format and duplicate a string.
*/
char * /* O - New string pointer */
mxml_strdupf(const char *format, /* I - Printf-style format string */
va_list ap) /* I - Pointer to additional arguments */
{
int bytes; /* Number of bytes required */
char *buffer, /* String buffer */
temp[256]; /* Small buffer for first vsnprintf */
/*
* First format with a tiny buffer; this will tell us how many bytes are
* needed...
*/
bytes = vsnprintf(temp, sizeof(temp), format, ap);
if (bytes < sizeof(temp))
{
/*
* Hey, the formatted string fits in the tiny buffer, so just dup that...
*/
return (strdup(temp));
}
/*
* Allocate memory for the whole thing and reformat to the new, larger
* buffer...
*/
if ((buffer = calloc(1, bytes + 1)) != NULL)
vsnprintf(buffer, bytes + 1, format, ap);
/*
* Return the new string...
*/
return (buffer);
}
#ifndef HAVE_VSNPRINTF
/*
* 'mxml_vsnprintf()' - Format a string into a fixed size buffer.
*/
int /* O - Number of bytes formatted */
mxml_vsnprintf(char *buffer, /* O - Output buffer */
size_t bufsize, /* O - Size of output buffer */
const char *format, /* I - Printf-style format string */
va_list ap) /* I - Pointer to additional arguments */
{
char *bufptr, /* Pointer to position in buffer */
*bufend, /* Pointer to end of buffer */
sign, /* Sign of format width */
size, /* Size character (h, l, L) */
type; /* Format type character */
const char *bufformat; /* Start of format */
int width, /* Width of field */
prec; /* Number of characters of precision */
char tformat[100], /* Temporary format string for sprintf() */
temp[1024]; /* Buffer for formatted numbers */
char *s; /* Pointer to string */
int slen; /* Length of string */
int bytes; /* Total number of bytes needed */
/*
* Loop through the format string, formatting as needed...
*/
bufptr = buffer;
bufend = buffer + bufsize - 1;
bytes = 0;
while (*format)
{
if (*format == '%')
{
bufformat = format;
format ++;
if (*format == '%')
{
*bufptr++ = *format++;
continue;
}
else if (strchr(" -+#\'", *format))
sign = *format++;
else
sign = 0;
width = 0;
while (isdigit(*format))
width = width * 10 + *format++ - '0';
if (*format == '.')
{
format ++;
prec = 0;
while (isdigit(*format))
prec = prec * 10 + *format++ - '0';
}
else
prec = -1;
if (*format == 'l' && format[1] == 'l')
{
size = 'L';
format += 2;
}
else if (*format == 'h' || *format == 'l' || *format == 'L')
size = *format++;
if (!*format)
break;
type = *format++;
switch (type)
{
case 'E' : /* Floating point formats */
case 'G' :
case 'e' :
case 'f' :
case 'g' :
if ((format - bufformat + 1) > sizeof(tformat) ||
(width + 2) > sizeof(temp))
break;
strncpy(tformat, bufformat, format - bufformat);
tformat[format - bufformat] = '\0';
sprintf(temp, tformat, va_arg(ap, double));
bytes += strlen(temp);
if (bufptr)
{
if ((bufptr + strlen(temp)) > bufend)
{
strncpy(bufptr, temp, bufend - bufptr);
bufptr = bufend;
break;
}
else
{
strcpy(bufptr, temp);
bufptr += strlen(temp);
}
}
break;
case 'B' : /* Integer formats */
case 'X' :
case 'b' :
case 'd' :
case 'i' :
case 'o' :
case 'u' :
case 'x' :
if ((format - bufformat + 1) > sizeof(tformat) ||
(width + 2) > sizeof(temp))
break;
strncpy(tformat, bufformat, format - bufformat);
tformat[format - bufformat] = '\0';
sprintf(temp, tformat, va_arg(ap, int));
bytes += strlen(temp);
if (bufptr)
{
if ((bufptr + strlen(temp)) > bufend)
{
strncpy(bufptr, temp, bufend - bufptr);
bufptr = bufend;
break;
}
else
{
strcpy(bufptr, temp);
bufptr += strlen(temp);
}
}
break;
case 'p' : /* Pointer value */
if ((format - bufformat + 1) > sizeof(tformat) ||
(width + 2) > sizeof(temp))
break;
strncpy(tformat, bufformat, format - bufformat);
tformat[format - bufformat] = '\0';
sprintf(temp, tformat, va_arg(ap, void *));
bytes += strlen(temp);
if (bufptr)
{
if ((bufptr + strlen(temp)) > bufend)
{
strncpy(bufptr, temp, bufend - bufptr);
bufptr = bufend;
break;
}
else
{
strcpy(bufptr, temp);
bufptr += strlen(temp);
}
}
break;
case 'c' : /* Character or character array */
bytes += width;
if (bufptr)
{
if (width <= 1)
*bufptr++ = va_arg(ap, int);
else
{
if ((bufptr + width) > bufend)
width = bufend - bufptr;
memcpy(bufptr, va_arg(ap, char *), width);
bufptr += width;
}
}
break;
case 's' : /* String */
if ((s = va_arg(ap, char *)) == NULL)
s = "(null)";
slen = strlen(s);
if (slen > width && prec != width)
width = slen;
bytes += width;
if (bufptr)
{
if ((bufptr + width) > bufend)
width = bufend - bufptr;
if (slen > width)
slen = width;
if (sign == '-')
{
strncpy(bufptr, s, slen);
memset(bufptr + slen, ' ', width - slen);
}
else
{
memset(bufptr, ' ', width - slen);
strncpy(bufptr + width - slen, s, slen);
}
bufptr += width;
}
break;
case 'n' : /* Output number of chars so far */
if ((format - bufformat + 1) > sizeof(tformat) ||
(width + 2) > sizeof(temp))
break;
strncpy(tformat, bufformat, format - bufformat);
tformat[format - bufformat] = '\0';
sprintf(temp, tformat, va_arg(ap, int));
bytes += strlen(temp);
if (bufptr)
{
if ((bufptr + strlen(temp)) > bufend)
{
strncpy(bufptr, temp, bufend - bufptr);
bufptr = bufend;
break;
}
else
{
strcpy(bufptr, temp);
bufptr += strlen(temp);
}
}
break;
}
}
else
{
bytes ++;
if (bufptr && bufptr < bufend)
*bufptr++ = *format++;
}
}
/*
* Nul-terminate the string and return the number of characters needed.
*/
*bufptr = '\0';
return (bytes);
}
#endif /* !HAVE_VSNPRINTF */
/*
* End of "$Id: mxml-string.c 22267 2006-04-24 17:11:45Z kpfleming $".
*/

Some files were not shown because too many files have changed in this diff Show More